G2

Otacilio Pedro S.

Data Engineering Manager

Consumer Goods

Small-Business (50 or fewer emp.)

9/10/2026

"Code-first agents with the simple @tool decorator and true model-agnostic flexibility"

4/5

What do you like best about Hugging Face smolagents?

Three things stood out:

1. CodeAgent over JSON tool-calling

Most agent frameworks force the LLM to output structured JSON dictionaries. smolagents lets the LLM write actual Python code instead. This sounds scary but it's the whole point — it uses 30% fewer LLM steps and the agent can do things like loop over search results, transform data, and call tools in a single step instead of going back-and-forth 5 times.

In Demo 2, the agent couldn't just call a tool — it noticed an error, imported HfApi directly, called it with different arguments, compared results across two categories, and synthesized a final answer. All in one step.

2. The @tool decorator

@tool

def get_most_popular_model(task: str) -> str:

"""Returns the most downloaded model for a given task on HF Hub."""

model = next(iter(list_models(filter=task, sort="downloads", direction=-1)))

return model.id

That's it. One function + docstring = working tool. No YAML schemas, no register_tool() calls, no boilerplate. The docstring becomes the LLM's instruction manual automatically.

3. Model-agnostic flexibility

We swapped from HF Inference API to an Unsloth GGUF endpoint mid-POC with a one-line model change. No framework lock-in. InferenceClientModel, OpenAIModel, LiteLLMModel, TransformersModel — pick whichever fits your stack. Most agent frameworks are married to one or two providers. Review collected by and hosted on G2.com.

What do you dislike about Hugging Face smolagents?

Four main pain points from the POC:

1. Zero visibility into cost/token burn

We had no idea how many tokens we were consuming until a run finished (or timed out). In Demo 2, the agent burned 32,000+ tokens across 8 steps just to answer a simple comparison question. There's no running counter, no budget cap, no warning when you're about to blow through credits. For production use, this is a dealbreaker — you need to know your burn rate.

2. Built-in tools can silently break

Demo 2 used @tool with list_models(filter=task, sort="downloads", direction=-1). That tool failed at runtime because huggingface_hub removed the `direction` parameter. The library's own default tools are not version-pinned or tested against the latest API. The agent recovered autonomously (which was impressive), but the bug shouldn't have been there in the first place.

3. Multi-agent has no safety nets

Demo 3 (manager + web search agent) ran for 15+ minutes without producing output. No timeout, no max-iterations per sub-agent, no way to cancel cleanly. In a production pipeline, a runaway multi-agent loop could burn hundreds of thousands of tokens before you notice. You have to build all the guardrails yourself.

4. Error messages are raw tracebacks

When InferenceClientModel hit a 402 (credits exhausted), the error was a 60-line Python traceback ending with a generic HTTPStatusError. No "Your HF free credits are depleted — add prepaid credits or switch providers." Just a wall of stack frames. New users will stare at this confused.

Summary: The core agent logic is excellent. The operational tooling around it — cost tracking, error UX, runtime safety — is what's missing. If you're building a quick prototype, none of this matters. If you're deploying to production, expect to build these layers yourself. Review collected by and hosted on G2.com.

What problems is Hugging Face smolagents solving and how is that benefiting you?

Three core problems it solves, and how we benefited:

1. Rapid agent prototyping with minimal boilerplate

Before smolagents, building an LLM-powered agent meant either using a heavyweight framework (LangChain, CrewAI) with layers of abstraction, or rolling your own from scratch with raw API calls. smolagents sits in the sweet spot — we had a working web-searching agent in ~20 lines of code. Demo 1 went from `pip install` to real output in under 5 minutes. For a G2 review where we needed to evaluate quickly, this speed was critical.

2. Provider lock-in is eliminated

We didn't have an available HF Inference API token (credits exhausted), so we wired it to an Unsloth GGUF endpoint via OpenAIModel with a one-line swap. No refactoring, no adapter pattern, no config files. This matters because real teams don't all use the same LLM provider — you need to evaluate across OpenAI, Anthropic, local models, and whatever your infra team has deployed. smolagents lets you do that without changing agent logic.

3. Custom tool creation without ceremony

We needed a tool that queries HuggingFace Hub for popular models. With smolagents, that's one function decorated with @tool, plus a docstring that doubles as the LLM's instruction manual. No YAML schemas, no class inheritance, no registry pattern. We created two custom tools in minutes, and the agent used them autonomously to answer a comparison question it had never seen before.

Real-world benefit: For evaluation and prototype work, smolagents dramatically reduces the time from idea to working agent. The @tool decorator and model-agnostic architecture mean you can test different LLMs and tools without rewriting agent logic. The tradeoff is that production guardrails (cost tracking, timeouts, error UX) are your responsibility to build. Review collected by and hosted on G2.com.