Agno is an open-source Python framework for building, running, and managing AI agents and multi-agent systems. It is model-agnostic, working with more than 30 model providers behind a single interface, and it ships with built-in support for memory, knowledge, tools, reasoning, and multimodal input across text, images, audio, and video. [1][2][7] Agno was previously named phidata; the project rebranded to Agno in January 2025 and now pairs a lightweight SDK with AgentOS, a high-performance FastAPI runtime for production multi-agent systems. [6][9] The official site describes Agno as an "Agent Framework and High-Performance Runtime for Multi-Agent Systems." [1]

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. [9] 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. [6]

The Agno SDK is distributed under the Apache 2.0 license. [7] 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. [3] Agno integrates with more than forty model families across more than twenty providers, including OpenAI, Anthropic, Google, AWS Bedrock, Azure, Groq, Cohere, Mistral, DeepSeek, and local backends such as Ollama, LM Studio, vLLM, and llama.cpp. [4]

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 AI agent frameworks in the Python ecosystem. [7]

What is Agno?

Agno is a full-stack, open-source framework for building agentic AI systems in Python, spanning a single agent up to teams of coordinated agents running in production. [1][2] An Agno agent is a large language model wrapped with optional tools, a knowledge base, persistent memory, and a reasoning loop, all configured in a single Python class. The framework is deliberately thin: the agent object maps closely to what a developer would write by hand, which is the source of much of the low-overhead performance the team reports. [3]

The project organizes around three primary SDK abstractions, Agents, Teams, and Workflows, and a runtime, AgentOS, that owns durable state and exposes the system over HTTP. Agno's documentation summarizes the design goal succinctly, describing the framework as the way to "build, run, and manage agent platforms" in your own cloud rather than a managed service. [2][7] Because it is model-agnostic, the same agent code can be pointed at OpenAI, Anthropic, Google, or a locally hosted model by swapping a single model object, with no rewrite of the agent logic. [4]

Background

phidata origins

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.

Why was phidata renamed to Agno?

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 goal of "the fastest way to build multi-modal agents" and as a signal of intent toward a broader agentic AGI roadmap. [9] The original agno-agi/phidata repository was preserved as a legacy artifact with a banner directing users to the new home. [8]

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.

When did AgentOS and Agno 2.0 ship?

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. [6] 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. [6]

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. [10]

How does Agno work?

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. [3]

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. [5] 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. [5]

What can Agno do?

The following table summarizes the main capabilities of the Agno framework based on official documentation. [2]

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

How fast is Agno? Performance and benchmarks

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. [3][12] 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. [3]

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. [3] (An earlier phidata-era benchmark put the figure even higher, at roughly 10,000 times faster than LangGraph; the Apple M4 numbers above are the more recent and more conservative measurement the project now cites.) [3] 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. [3]

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. [12]

How is Agno different from LangChain and LangGraph?

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. [13] 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.

Which models and integrations does Agno support?

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. [4] 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; the project's marketing summarizes this as "30+ providers behind one surface." [1][4]

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. [2]

Is Agno open source? Adoption and ecosystem

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. [7][8] 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. [10]

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. [14][16] 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. [12] The project maintains a Discord community and publishes a monthly community roundup on its blog summarizing user-built projects, integrations, and notable contributions. [11]

Licensing

The Agno SDK is released under the Apache 2.0 license. [7] 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. [8]

Reception

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. [13][15] 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. [15] 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. Some commenters on Hacker News also questioned the original 10,000x benchmark, observing that the LangGraph comparison code eagerly initialized network and TLS machinery that inflated its startup cost, a point that informs the more conservative figures the project cites today. [3]

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.

ELI5

Imagine you want to build a little robot helper that can read, look at pictures, listen, search the web, and remember things you told it. Agno is a free toolkit that lets you build that helper in just a few lines of Python code. You can build one helper, or a whole team of helpers that talk to each other and split up the work. Agno is famous for being very fast and very light: it can make a new helper in about three millionths of a second, so you can spin up thousands of them at once without your computer running out of memory. It works with almost any AI brain (OpenAI, Google, Anthropic, and many more), so you are never stuck with just one. Agno used to be called phidata before it got its new name in 2025.

References

Agno official website, https://www.agno.com/
Agno documentation, https://docs.agno.com/
Agno performance benchmarks, https://docs.agno.com/introduction/performance
Agno model index, https://docs.agno.com/models/providers/model-index
Agno AgentOS overview, https://docs.agno.com/agent-os/introduction
Introducing Agno 2.0 (blog post), https://www.agno.com/blog/introducing-agno-v2
Agno GitHub repository, https://github.com/agno-agi/agno
Legacy phidata GitHub repository, https://github.com/agno-agi/phidata
Ashpreet Bedi, "Phidata is now Agno" announcement, January 31, 2025, https://www.linkedin.com/posts/ashpreetbedi_phidata-is-now-agno-announcing-our-new-activity-7290750031312179200-mGAd
Agno releases page, https://github.com/agno-agi/agno/releases
Agno community roundup blog, https://www.agno.com/blog/community-roundup-november-2025
Agno performance benchmark cookbook, https://github.com/agno-agi/agno/tree/main/cookbook/evals/performance
ZenML comparison, "Agno vs LangGraph", https://www.zenml.io/blog/agno-vs-langgraph
DigitalOcean, "Understanding Agno: A Fast, Scalable Multi-Agent Framework", https://www.digitalocean.com/community/conceptual-articles/agno-fast-scalable-multi-agent-framework
Analytics Vidhya, "Agno Framework: A Lightweight Library for Building Multimodal Agents", https://www.analyticsvidhya.com/blog/2025/03/agno-framework/
Groq documentation, "Agno + Groq", https://console.groq.com/docs/agno

Editing: Agno