Comparisons / Agno vs AutoGen
Agno vs AutoGen: Which Agent Framework to Use?
Agno agno (formerly phidata) is a lightweight python framework for building agents. AutoGen autogen by microsoft models agents as conversableagents that chat with each other. 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)
AutoGen
56.7k
8.5k
Python
CC-BY-4.0
2023-08-18
Microsoft Research
GitHub stats as of April 2026. Stars indicate community interest, not necessarily quality or fit for your use case.
| Concept | Agno | AutoGen | Plain Python |
|---|---|---|---|
| Agent | Agent(model=OpenAIChat(), instructions=[...]) class with run() method | ConversableAgent with system_message, llm_config | 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.) | register_for_llm() and register_for_execution() | A dict of callables: tools = {"search": search_web, "sql": run_query} |
| Agent Loop | Agent.run() handles tool dispatch internally, configurable via show_tool_calls | — | 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 |
| Conversation | — | Two-agent chat with initiate_chat(), message history | A messages array that grows with each turn |
| Multi-Agent | — | GroupChat with GroupChatManager, speaker selection | Multiple agent functions called in sequence on shared messages |
| Nested Chats | — | register_nested_chats() for sub-task handling | A task queue (BFS) — agent schedules follow-ups via a tool |
| Termination | — | is_termination_msg callback, max_consecutive_auto_reply | The while loop exits when no tool_calls or max_turns reached |
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 AutoGen 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 AutoGen
AutoGen excels at complex multi-agent workflows where agents need to debate or collaborate. For single-agent use cases or simple tool-calling agents, the plain Python version is significantly simpler.
What AutoGen does
AutoGen's core abstraction is the ConversableAgent — an agent that can send and receive messages. Two agents chat by alternating turns on a shared message history. GroupChat extends this to N agents, with a GroupChatManager that selects the next speaker (round-robin, random, or LLM-based selection). Nested chats allow an agent to spin up a sub-conversation to handle a complex subtask before returning to the main thread. AutoGen also provides code execution sandboxes, letting agents write and run code as part of their conversation. The framework thinks in terms of conversations, not chains or graphs. This makes it natural for workflows where agents need to debate, critique, or iteratively refine outputs together.
The plain Python equivalent
A ConversableAgent is a function that takes a messages array, calls the LLM with a system prompt, and returns the assistant message. Two-agent chat is a while loop where you alternate between calling agent_a(messages) and agent_b(messages), appending each response. GroupChat is the same loop but with a speaker selection step — either rotate through a list or ask the LLM "who should speak next?" and call that agent function. Nested chats are a function call within the loop: pause the main conversation, run a sub-loop with different agents, and inject the result back. Tool registration is adding functions to a tools dict with their JSON schemas. The conversation-as-primitive model is just messages arrays passed between functions.
Or build your own in 60 lines
Both Agno and AutoGen 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 →