Agno
Last reviewed
May 16, 2026
Sources
16 citations
Review status
Source-backed
Revision
v1 ยท 2,964 words
Improve this article
Add missing citations, update stale details, or suggest a clearer explanation.
Suggest edit
CtrlK
Last reviewed
May 16, 2026
Sources
16 citations
Review status
Source-backed
Revision
v1 ยท 2,964 words
Add missing citations, update stale details, or suggest a clearer explanation.
Agno is an open-source Python framework for building, running, and managing AI agents and multi-agent systems. The project began life as phidata, a developer tool released by Ashpreet Bedi for building retrieval-augmented and tool-using assistants. In January 2025 the project rebranded to Agno, marking a shift in focus from the original data-engineering and RAG framing toward a runtime designed for production multi-agent systems. The repository moved from phidatahq/phidata to agno-agi/agno, and a follow-up 2.0 release in September 2025 introduced AgentOS, a FastAPI-based runtime layer that the team positions as the production half of the framework.
The Agno SDK is distributed under the Apache 2.0 license. It supports agents that combine memory, knowledge bases, tools, reasoning, and multimodal input across text, images, audio, and video. The team claims that agent instantiation in Agno is faster and uses less memory than several other popular frameworks, with published microbenchmarks comparing it to LangGraph, CrewAI, and PydanticAI. Agno integrates with more than forty model providers, including OpenAI, Anthropic, Google, AWS Bedrock, Azure, Groq, Cohere, Mistral, DeepSeek, and local backends such as Ollama, LM Studio, vLLM, and llama.cpp.
Agno occupies a similar conceptual space to frameworks such as LangChain, LangGraph, LlamaIndex, CrewAI, AutoGen, DSPy, and Mastra. It differs in its emphasis on a lightweight, almost dependency-free Agent class on the SDK side, and a bundled production runtime (AgentOS) on the operational side. As of 2026 the GitHub repository has roughly 40,000 stars, placing it among the more visible open-source agent frameworks in the Python ecosystem.
phidata was created by Ashpreet Bedi, a former data engineer at Airbnb and Facebook who left Airbnb in 2022 and started consulting on AI products. The original phidata project surfaced as an open-source library on PyPI in 2023 and quickly pivoted around the wave of interest in retrieval-augmented generation and function calling that followed the release of GPT-3.5 and the OpenAI function-calling API in mid-2023. Early phidata releases focused on assistants and RAG pipelines: agents with attached knowledge bases, vector stores, structured outputs, and the ability to call Python functions as tools.
Throughout 2023 and 2024 the project broadened its scope. It added support for additional model providers beyond OpenAI, introduced higher-level abstractions for assistants and tool toolkits, and grew an ecosystem of integrations around vector databases, storage backends, and reasoning modes. The library gained traction with developers building internal assistants and customer-facing chatbots, accumulating tens of thousands of GitHub stars before the rebrand.
In January 2025 the project was renamed from phidata to Agno, with the GitHub organization moved to agno-agi. The founder announced the change publicly on January 31, 2025, framing it as a brand reset around "the fastest way to build multi-modal agents" and as a signal of intent toward a broader agentic AGI roadmap. The original agno-agi/phidata repository was preserved as a legacy artifact with a banner directing users to the new home.
The rebrand was more than cosmetic. Over the following months the team reorganized the library around three primary abstractions, Agents, Teams, and Workflows, with a clearer separation between the SDK and the runtime that would later be called AgentOS. The 1.x line of releases delivered most of this work incrementally, while keeping the surface API broadly compatible with phidata users who had already invested in tools and knowledge configurations.
Agno 2.0 shipped on September 9, 2025 and was the project's largest single release. It paired a rewritten core SDK with AgentOS, a FastAPI application that exposes more than fifty endpoints for runs, sessions, memory, knowledge, traces, and evaluations. The release introduced a unified storage interface so that a single database can back sessions, memories, evaluation runs, and metrics, and reworked the knowledge layer to support PDFs, CSVs, web pages, and other content types under a shared API with hybrid vector and keyword search.
The 2.0 series also moved agents, teams, and workflows toward a stateless model, where the runtime, not the Python objects themselves, owns durable state. This change was framed as a reliability improvement: stateless agents can be created and discarded freely, and AgentOS handles persistence, request isolation, and recovery. Later releases in the 2.x series, including v2.5.13 in March 2026, added features such as ReliabilityEval for evaluating agent behavior, additional session-management endpoints in AgentOS, and richer chat interface integrations across Slack, Telegram, Discord, and WhatsApp.
At the SDK level, an Agno program is a Python script that constructs an Agent (or a Team or Workflow) and calls a run method with a user message. The Agent object holds references to a model, an optional set of tools, an optional knowledge base, an optional storage backend, and configuration for memory, reasoning, and structured outputs. When the agent runs, it composes a prompt, calls the model, executes any tool calls returned by the model, optionally retrieves from its knowledge base, and either streams or returns a response.
The library is deliberately thin. The core Agent class avoids heavy graph or state-machine abstractions in favor of a procedural runtime that maps closely to what a developer would write by hand. This design is the source of much of the performance the team reports, since it minimizes the per-instance overhead of creating, destroying, and parallelizing agents.
Teams sit one level above agents. A Team is a set of named agents with a shared context, and a coordination mode that can be route (a leader picks which member handles a request), delegate (the leader splits the task and dispatches to members), or collaborate (members work together with shared scratchpad memory). Teams can be nested and can share a knowledge base, which lets a group of specialists pull from the same documents while keeping their own tool sets and personas.
Workflows are step-based agentic programs. They define a sequence of nodes, each of which can be an agent, a team, a Python function, or a control-flow primitive such as parallel, conditional, or loop. Workflows are aimed at structured processes where the order and conditions of steps matter, in contrast to teams, which are aimed at open-ended collaboration.
AgentOS wraps these primitives in a production runtime. It is shipped as a FastAPI app that you import into your own service, configure with your agents, teams, and workflows, and deploy in your own cloud. The runtime exposes endpoints for streaming runs (via server-sent events), session management, memory CRUD, knowledge ingestion and search, evaluation runs, and observability. It also includes a control plane UI for inspecting sessions, memories, knowledge, and traces, with the data remaining in the user's own database rather than being routed through a managed Agno service.
The following table summarizes the main capabilities of the Agno framework based on official documentation.
| Feature | Description |
|---|---|
| Agents | Lightweight Python class combining a model, tools, knowledge, memory, and reasoning configuration |
| Teams | Multi-agent groups with route, delegate, or collaborate coordination modes and shared context |
| Workflows | Step-based agentic programs with parallel, conditional, and loop control flow |
| Memory | Per-session and long-term user memory with pluggable storage backends |
| Knowledge / Agentic RAG | Vector-backed retrieval over PDFs, CSVs, web pages, and other formats, with hybrid search |
| Tools | More than 100 prebuilt toolkits covering web search, finance, code execution, file I/O, and APIs |
| Multimodal I/O | Native support for text, image, audio, and video inputs and outputs where the model allows |
| Reasoning | Optional reasoning loop with intermediate thought traces and self-evaluation steps |
| Structured outputs | Pydantic-based response models for typed JSON outputs |
| MCP support | Compatibility with Model Context Protocol servers as a tool source |
| Human in the loop | Approval hooks and pause-and-resume semantics for sensitive actions |
| AgentOS runtime | FastAPI app with 50+ endpoints for runs, sessions, memory, knowledge, and traces |
| Control plane UI | Browser interface for monitoring sessions, memory, knowledge, and evaluations |
| Evaluations | Built-in evaluation harness, including a ReliabilityEval mode in later 2.x releases |
| Scheduling | Cron-style scheduling of agent runs without external infrastructure |
| Auth and RBAC | JWT-based role-based access control for AgentOS endpoints |
| Chat interfaces | Adapters for Slack, Telegram, Discord, and WhatsApp |
| Observability | Tracing and logging integrations, plus per-run metrics |
The Agno team publishes microbenchmarks comparing agent instantiation cost across frameworks. The numbers below come from the project's own performance documentation and reflect creating 1,000 agents with one tool attached, measured on an Apple M4 MacBook Pro using Python's tracemalloc for memory profiling. The team is explicit that these results measure framework overhead rather than end-to-end task performance, which is dominated by model inference and harder to compare fairly.
| Framework | Instantiation time | Memory per agent |
|---|---|---|
| Agno | ~3 microseconds | ~6.6 KiB |
| PydanticAI | ~170 microseconds | ~29 KiB |
| CrewAI | ~210 microseconds | ~66 KiB |
| LangGraph | ~1,587 microseconds | ~161 KiB |
By these measurements the team reports that Agno instantiates roughly 529 times faster than LangGraph and uses about 24 times less memory per agent. The project's docs also note that this gap matters most for workloads that create and destroy many short-lived agents, such as serverless endpoints, high-fanout teams, or batch evaluation runs, and matters less for long-running single-agent services where most of the latency is in model calls.
Agno's documentation is careful to flag two caveats. First, accuracy and reliability matter more than instantiation speed for most production use cases, and the team encourages users to benchmark against their own task suites rather than relying on framework-level numbers. Second, runtime performance during a single agent run is dominated by inference latency and tool call latency, which Agno cannot make faster on its own; the framework focuses instead on minimizing its own overhead and on parallelizing tool calls where the model emits more than one in a turn. The cookbook in the repository includes the scripts used to produce the benchmark numbers so that users can reproduce them.
The agent framework space is crowded, and Agno positions itself by a combination of API surface, runtime, and performance. The comparison below is based on each project's public documentation. It is not an endorsement of any particular framework, since the right choice depends heavily on the use case.
| Framework | Language | Primary abstraction | Runtime included | License |
|---|---|---|---|---|
| Agno | Python | Agent, Team, Workflow | Yes (AgentOS, FastAPI) | Apache 2.0 |
| LangChain | Python, TypeScript | Chain, Agent, Runnable | No (LangServe optional) | MIT |
| LangGraph | Python, TypeScript | StateGraph nodes and edges | Optional (LangGraph Platform) | MIT |
| LlamaIndex | Python, TypeScript | Index, Query Engine, Agent | No | MIT |
| CrewAI | Python | Crew of role-based Agents | No (CrewAI Enterprise optional) | MIT |
| AutoGen | Python, .NET | Conversable Agents | No | MIT |
| DSPy | Python | Module, Signature, Optimizer | No | MIT |
| Mastra | TypeScript | Agent, Workflow | Yes | Apache 2.0 |
Against LangChain, Agno typically presents itself as a more opinionated, narrower API with fewer layers between the developer and the model call. Against LangGraph, the comparison the Agno team most often draws, the contrast is between LangGraph's explicit state-machine graphs and Agno's lighter agent objects, with the performance benchmarks above used as the headline argument. Against LlamaIndex, the difference is largely one of emphasis: LlamaIndex started from retrieval and indexing and grew agents on top, while Agno started from agents and grew retrieval as one of several capabilities.
CrewAI and AutoGen overlap heavily with Agno's Team abstraction, and the practical choice often comes down to ergonomics, ecosystem integrations, and the degree to which a project wants role-based personas (CrewAI), conversational agent loops (AutoGen), or a flatter agent class that can be composed into teams (Agno). DSPy occupies a different niche, optimizing prompts and pipelines rather than orchestrating long-lived agents, although it can be paired with any of the others. Mastra is the closest analogue in the TypeScript world, with a comparable framework-plus-runtime split and a similar Apache 2.0 license.
Agno is explicitly model-agnostic. The model providers documented in the Agno model index include OpenAI, Anthropic, Google (Gemini and Vertex), AWS Bedrock, Azure OpenAI and Azure AI Foundry, Cohere, DeepSeek, Mistral, Meta, Groq, Together AI, Perplexity, Vercel AI, xAI, Fireworks, OpenRouter, Hugging Face Inference, Ollama, LM Studio, vLLM, and llama.cpp. The total count cited by the team is more than forty models across more than twenty providers, with new entries added regularly as new model families ship.
On the data side, Agno integrates with more than twenty vector databases for its knowledge layer, including pgvector, Pinecone, Weaviate, Qdrant, Chroma, LanceDB, Milvus, MongoDB Atlas, Cassandra, and SingleStore. Storage backends for sessions and memory include SQLite, PostgreSQL, MongoDB, Redis, and DynamoDB. On the tools side, the prebuilt toolkit catalog includes web search (DuckDuckGo, Tavily, SerpAPI, Exa, Brave), code execution (Python, shell, sandbox), browsing and scraping, file I/O, financial data (YFinance, Polygon), email, calendars, GitHub, Jira, Linear, Notion, and many others, with first-class support for Model Context Protocol servers as an external tool source.
By mid-2026 the agno-agi/agno repository has accumulated around 40,000 stars on GitHub, with the predecessor agno-agi/phidata repository contributing tens of thousands more from its phidata era. The project ships a steady cadence of point releases, with 2.5.x releases landing throughout late 2025 and early 2026 and v2.5.13 published on March 31, 2026 according to the project's release history.
The team's public materials cite use in production at "hundreds of agentic systems" handling millions of requests, and the framework appears in tutorials and integrations from infrastructure vendors such as Groq, DigitalOcean, and several model providers. Specific named adopters are sparse in primary sources, and this article does not list them. Community projects on GitHub include sample multi-agent systems, vertical templates (finance, research, customer support), and integrations with surrounding tools such as evaluation harnesses and orchestration platforms.
The Agno organization on GitHub also hosts a documentation repository and a cookbook with runnable examples, including the performance benchmark scripts referenced above. The project maintains a Discord community and publishes a monthly community roundup on its blog summarizing user-built projects, integrations, and notable contributions.
The Agno SDK is released under the Apache 2.0 license. The license permits commercial use, modification, redistribution, and sublicensing, with the standard Apache requirements around attribution and patent grants. AgentOS, as part of the same repository, is also covered by the Apache 2.0 license. The team's commercial strategy, where described in public materials, centers on offerings that complement the open-source runtime rather than gating the core framework behind a paid tier; specific paid products and pricing are out of scope for this article since they are not consistently documented in primary sources.
The rebrand from phidata to Agno preserved license continuity. Code originally contributed to phidata under Apache 2.0 carried the same terms forward into Agno, and the legacy agno-agi/phidata repository remains available for historical reference.
Reception within the AI engineering community has been broadly positive, with most public commentary focused on three points. The first is the performance gap that the team's benchmarks claim against LangGraph and other frameworks, which has been picked up by several independent comparison articles and tutorial posts. The second is the API ergonomics: reviewers frequently note that an Agno agent fits on a screen and reads close to a normal Python script, which lowers the barrier for new users compared with graph-based frameworks. The third is the AgentOS runtime, which is sometimes praised for shortening the path from a working notebook to a deployed service, and sometimes critiqued for bundling opinions about authentication, storage, and observability that not every project wants.
Common criticisms in community discussion include the rapid pace of API churn during the 1.x to 2.x transition, occasional gaps in documentation for newer features, and the usual tradeoffs that come with any opinionated framework: integrations that are tightly coupled to Agno's abstractions can be hard to reuse outside them. The 2.0 rewrite addressed several of the earlier complaints around state management and storage, but also required users to migrate code, which produced its own friction.
In the broader landscape of agent frameworks, Agno's position is closer to a full-stack offering than a pure library. That positioning resonates with teams that want a single project to handle the SDK, the runtime, and the control plane, and it can feel heavier to teams that prefer to compose smaller pieces from different vendors. Both stances are well represented in public discussion, and the choice between Agno and its alternatives mostly comes down to that preference rather than to any single technical limitation.