Comparisons / CrewAI vs Smolagents
CrewAI vs Smolagents: Which Agent Framework to Use?
CrewAI crewai organizes work into agents, tasks, and crews. Smolagents smolagents is huggingface's minimalist agent library. Here is how they compare — and what the same patterns look like in plain Python.
By the numbers
CrewAI
48.0k
6.5k
Python
MIT
2023-10-27
João Moura
Smolagents
26.4k
2.4k
Python
Apache-2.0
2024-12-05
Hugging Face
GitHub stats as of April 2026. Stars indicate community interest, not necessarily quality or fit for your use case.
| Concept | CrewAI | Smolagents | Plain Python |
|---|---|---|---|
| Agent | Agent(role, goal, backstory, tools, llm) | CodeAgent or ToolCallingAgent with model and tools list | A function with a system prompt and a tools dict |
| Tools | Tool registration with @tool decorator, custom Tool classes | @tool decorator or Tool class with name, description, and callable | A dict: tools[name](**args) |
| Agent Loop | Internal to Agent execution, hidden from user | Internal loop: think (LLM reasons), act (code/tool call), observe (result) | A while loop over messages with tool_calls check |
| Task Delegation | Crew(agents, tasks, process=sequential/hierarchical) | — | A task queue processed in a while loop with a budget cap |
| Memory | ShortTermMemory, LongTermMemory, EntityMemory | — | A dict injected into the system prompt |
| State | Task output passed between agents via Crew orchestration | — | A dict tracking tool calls and results |
| Code Actions | — | CodeAgent writes Python code as its action, executed in sandbox | LLM returns code string, you run exec(code, {"tools": tools}) |
| Sandbox | — | E2B, Docker, Modal, or Pyodide sandbox for safe code execution | subprocess.run() in a Docker container, or restricted exec() with limited globals |
| Model Support | — | HuggingFace Hub models, OpenAI, Anthropic, local via LiteLLM | An HTTP POST to whichever provider's API you choose |
What both do in plain Python
Every concept in the table above — agent, tools, loop, memory, state — maps to a handful of Python primitives: a function, a dict, a list, and a while loop. Both CrewAI and Smolagents wrap these primitives in their own class hierarchies and APIs. The underlying pattern is the same ~60 lines of code. The difference is how much ceremony each framework adds on top.
When to use CrewAI
CrewAI shines for multi-agent setups where you want named roles ("researcher", "writer"). But the core mechanics — tool dispatch, the agent loop, task scheduling — are the same patterns you can build in plain Python.
What CrewAI does
CrewAI models multi-agent systems as a crew of specialists. Each Agent has a role ("Senior Researcher"), a goal ("Find the best data sources"), a backstory that shapes its behavior, and a set of tools it can use. Tasks define discrete units of work with expected outputs. The Crew orchestrates execution — sequentially, hierarchically, or with a custom process. CrewAI also provides memory systems (short-term, long-term, entity) and delegation, where one agent can hand off subtasks to another. The mental model is a team of people collaborating on a project. For prototyping multi-agent workflows where you want to reason about roles and responsibilities, it provides a clean vocabulary.
The plain Python equivalent
An Agent in CrewAI is a function with a system prompt that includes the role, goal, and backstory. The tools dict maps names to callables. Task delegation is a list of tasks processed in order — each task calls the assigned agent function with the task description appended to the messages. Hierarchical execution is a manager agent that decides which sub-agent to call next (just another tool choice). Memory is a dict injected into the system prompt. The entire crew pattern — multiple agents, task queue, delegation — is a for-loop over tasks, where each iteration calls the right agent function. No Crew class, no process kwarg. Just functions calling functions with a shared state dict passed between them.
When to use Smolagents
Smolagents lives up to its name — it's genuinely minimal and the code-agent approach is a real innovation that reduces LLM calls by ~30%. If you want a lightweight agent library with HuggingFace ecosystem access, it's excellent. For understanding the fundamentals, the plain version is even simpler.
What Smolagents does
Smolagents takes a distinct approach: instead of having the LLM emit structured JSON tool calls, the CodeAgent has the LLM write Python code that performs the action directly. The model reasons about the task, writes code that calls available tools, and the framework executes that code in a sandboxed environment. This reduces the number of LLM calls by about 30% compared to traditional tool-calling agents, because the model can chain multiple operations in a single code block. The framework provides two agent types: CodeAgent for the code-writing approach and ToolCallingAgent for traditional structured tool calls. Sandbox options include E2B, Docker, Modal, and Pyodide for secure execution. The core library is deliberately minimal — about 1,000 lines of logic with few abstractions over raw Python.
The plain Python equivalent
A code agent is an LLM call that returns a Python code string, which you execute with exec() in a restricted namespace. You pass available tools as the namespace globals, the LLM writes code that calls them, and you capture the output. The sandbox is a Docker container or a restricted exec() with limited builtins. The agent loop is identical to every other framework: call the LLM, execute the action (code or tool call), append the result as an observation, repeat until done. Tool definitions are functions in a dict. Model support is an HTTP POST to an API endpoint. The entire code-agent pattern — including sandbox setup — fits in about 70 lines. Smolagents wraps this cleanly, but the underlying mechanic is straightforward exec() with safety guards.
Or build your own in 60 lines
Both CrewAI and Smolagents implement the same 8 patterns. An agent is a function. Tools are a dict. The loop is a while loop. The whole thing composes in ~60 lines of Python.
No framework. No dependencies. No opinions. Just the code.
Build it from scratch →