Comparisons / Agno vs CrewAI
Agno vs CrewAI: Which Agent Framework to Use?
Agno agno (formerly phidata) is a lightweight python framework for building agents. CrewAI crewai organizes work into agents, tasks, and crews. Here is how they compare — and what the same patterns look like in plain Python.
By the numbers
Agno
39.2k
5.2k
Python
Apache-2.0
2022-05-04
Agno (formerly Phidata)
CrewAI
48.0k
6.5k
Python
MIT
2023-10-27
João Moura
GitHub stats as of April 2026. Stars indicate community interest, not necessarily quality or fit for your use case.
| Concept | Agno | CrewAI | Plain Python |
|---|---|---|---|
| Agent | Agent(model=OpenAIChat(), instructions=[...]) class with run() method | Agent(role, goal, backstory, tools, llm) | A function that POSTs to /chat/completions and returns the response |
| Tools | Function tools via @tool decorator or built-in toolkits (web search, SQL, etc.) | Tool registration with @tool decorator, custom Tool classes | A dict of callables: tools = {"search": search_web, "sql": run_query} |
| Agent Loop | Agent.run() handles tool dispatch internally, configurable via show_tool_calls | Internal to Agent execution, hidden from user | A while loop: call LLM, check for tool_calls, execute, repeat |
| Memory / Knowledge | Knowledge bases (PDF, URL, vector DB) injected via knowledge param + built-in memory | — | A list of relevant chunks injected into the system prompt via a retrieval function |
| Multi-Agent (Teams) | Team class with agents list, mode (sequential, parallel, coordinate), and shared memory | — | A function that calls agent functions in sequence or parallel, passing results between them |
| Storage | SqlAgentStorage, PostgresAgentStorage for persisting sessions and state | — | json.dump() / json.load() to a file, or a simple DB insert |
| 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 |
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 Agno and CrewAI 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 Agno
Agno adds value when you want a batteries-included agent with minimal boilerplate — especially for multi-modal agents or team orchestration. But each of its abstractions maps to a small piece of plain Python. If your agent is straightforward, writing it directly gives you full control with zero framework overhead.
What Agno does
Agno gives you a single Agent class that wires together an LLM, tools, instructions, knowledge bases, and storage. You configure an agent declaratively — pass in a model, a list of tools, and optional knowledge sources — and call agent.run(). It handles the tool-calling loop, injects knowledge into context, and persists conversation state. Agno also supports multi-modal agents (vision, audio) and team-based orchestration where multiple agents coordinate on tasks. The framework ships with built-in toolkits for common tasks: web search, SQL queries, file operations. Compared to LangChain, it's lighter — fewer abstractions, less indirection. The tradeoff is a smaller ecosystem and fewer third-party integrations.
The plain Python equivalent
Every Agno abstraction maps to plain Python. The Agent class is a function that POSTs to the LLM API, checks for tool_calls, dispatches them from a dict, and loops. Knowledge bases are a retrieval function that fetches relevant chunks and injects them into the system prompt. Memory is a messages list. Storage is json.dump(). Teams are a function that calls multiple agent functions and combines their outputs. The entire agent — with tools, knowledge retrieval, memory, and multi-agent coordination — fits in about 60 lines. No base classes, no decorators. When something breaks, you debug your function, not a framework's internals.
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.
Or build your own in 60 lines
Both Agno and CrewAI 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 →