Agno is a Python framework for building AI agents whose main selling point is performance: it creates each agent in about two microseconds and barely uses any memory. It was formerly called Phidata and, in January 2025, was renamed to Agno. In this guide you will see what Agno is, how it organises work into agents, teams and workflows, why it boasts such low memory use, a worked tools example and how it differs from CrewAI. The same explanation is available in Spanish.

Key takeaways

  • Agno is an open-source agent framework (Apache-2.0 licence) written in Python; it has over 41,200 stars on GitHub and is on version v2.7.3, released on 14 July 2026.
  • It was formerly called Phidata: the project was renamed to Agno in January 2025 and the GitHub organisation moved to agno-agi, so many older tutorials still cite the old name.
  • Its flagship trait is performance: it instantiates an agent in about 2 microseconds and uses roughly 3.75 KiB of memory, figures the team measures with tracemalloc over one thousand runs.
  • It organises work into three pieces: individual agents, teams of several agents that collaborate and deterministic step-based workflows, all served by its AgentOS runtime.
  • It is model-agnostic: it works with more than twenty providers (OpenAI, Anthropic, Gemini, DeepSeek, Mistral, Groq, Bedrock and models you run on your own machine with Ollama) and requires Python 3.9 or higher.

What is Agno (formerly Phidata)?

Agno is a framework and a runtime for AI agent platforms. It started life as Phidata, a more data-oriented tool, and in January 2025 was renamed to Agno; the GitHub organisation moved to agno-agi and the PyPI package became agno. The change is not just cosmetic: version 2 rewrote the core with an obsession for cutting framework overhead to the minimum.

The project is free software under the Apache-2.0 licence and has had an enormous reception: it holds more than 41,200 stars on GitHub and is on version v2.7.3, released on 14 July 2026. It needs Python 3.9 or higher and installs with a single command:

pip install agno

# Usually paired with the client for the provider you use, e.g. OpenAI
pip install openai

The official documentation describes it as "a framework and runtime for agent platforms": you not only write agents, you also deploy them as a service and manage them from a web interface. That product-minded ambition sets it apart from other libraries that stop at the code layer.

Agents, teams and workflows

Agno organises work into three abstractions worth understanding from the start. An agent is the basic unit: a model with instructions, tools and, optionally, memory and knowledge. It is what you use for one-off tasks.

When a problem calls for several specialities, you assemble a team (Team): several agents that collaborate and split the work, an approach similar to the one popularised by CrewAI with its agent crews. And when you need a repeatable, predictable process, you define a workflow (Workflow): a sequence of steps where each step’s output feeds the next, with state persisted between runs. Unlike an agent, which decides on the fly, a workflow is deterministic and easy to audit.

Above the three sits AgentOS, the runtime that serves agents, teams and workflows as production APIs. It is stateless and horizontally scalable: state (the sessions) is stored in a database you control, not in the process. It also ships a web interface to observe and manage the platform. If you come from the state graphs of LangGraph, you will recognise the idea of separating agent logic from deployment.

Performance and low memory use

Here is why Agno gets noticed. Its headline figures are striking: it instantiates an agent in about 2 microseconds, and that agent uses around 3.75 KiB of memory. The team measures this with Python’s tracemalloc library: it computes baseline memory with an empty function, creates the agent one thousand times and measures the difference to isolate the real framework cost.

Compared with LangGraph, Agno claims to be around 10,000 times faster at creating the agent and to use around 50 times less memory. It is worth understanding exactly what those figures measure: the framework overhead, that is, the time and memory it costs to set up the agent before calling the model. In a real request, latency is dominated by the language-model call, which takes hundreds of milliseconds or more. So what is all that saving for?

The answer is concurrency. If your service spins up thousands of agents per second (one per user request, say), a startup cost of microseconds and a few KiB per agent make the difference between a comfortable server and one that chokes. For an agent you run occasionally, the difference is imperceptible; for a large-scale multi-tenant platform, it is exactly what you need.

A worked tools example

A useful agent needs to act on the world, and in Agno you do that by passing it tools: Python functions, or ready-made kits from its catalogue of over one hundred integrations. The following example creates an agent with an OpenAI model and a web-search tool, and asks it for a summary with sources:

from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.duckduckgo import DuckDuckGoTools

agent = Agent(
    model=OpenAIChat(id="gpt-4o"),
    tools=[DuckDuckGoTools()],
    instructions="Always cite your sources.",
    markdown=True,
)

agent.print_response(
    "Summarise the news about the Agno framework in 2026",
    stream=True,
)

The model decides for itself when to invoke the search tool; you just offer it. Switching provider is just as direct: you replace OpenAIChat with Claude, Gemini or Ollama without touching the rest of the code, because Agno abstracts away the difference between the twenty-plus providers it supports. To give an agent several capabilities, you simply add more entries to the tools list.

Agno versus CrewAI

The natural comparison is with CrewAI, another Python framework focused on agent teams. The difference in approach is clear. CrewAI is built around the "crew" metaphor: you define roles, tasks and a crew that collaborates, with a very guided experience. Agno is more generalist and puts performance and production deployment at the centre: it covers everything from the single agent to the deterministic workflow, and tops it off with AgentOS to deploy it as a service.

If your case is a multi-agent system with well-defined roles and you want a gentle learning curve, CrewAI fits very well. If you care about massive concurrency, low memory use and having a production runtime from day one, Agno has the edge. They are not mutually exclusive: both are model-agnostic and you can prototype in one and migrate if your needs change. For lighter, code-focused tasks, it is also worth looking at Hugging Face smolagents, which bets on a minimal surface.

Frequently asked questions

Is Agno the same as Phidata?

Yes, it is the same project under a new name. Phidata was renamed to Agno in January 2025 and its GitHub organisation moved to agno-agi. If you find tutorials or dependencies mentioning phidata, they refer to the old version; active development is in the agno package, which is on version v2.7.3. It is worth migrating, because version 2 rewrote the core to cut overhead.

Is it really 10,000 times faster than LangGraph?

That figure measures only the framework overhead when creating the agent, not the speed of the answers. In a real request, latency is dominated by the language-model call, which takes hundreds of milliseconds, so you will not see answers 10,000 times faster. Where it does matter is concurrency: if you spin up thousands of agents at once, that microsecond startup and those 3.75 KiB per agent save you a lot of memory and CPU.

Which models does Agno work with?

With more than twenty providers through the same API: OpenAI, Anthropic, Google Gemini, DeepSeek, Mistral, Groq, Amazon Bedrock, Azure OpenAI and the LiteLLM gateway, among others, plus models you run on your own machine with Ollama. Switching from one to another is a matter of replacing the model class, without rewriting the agent logic.

Conclusion

Agno brings an unusual obsession to the world of AI agents: efficiency. With a microsecond startup, a few KiB per agent and three clear abstractions (agents, teams and workflows) served by AgentOS, it fits beautifully when you need to scale to heavy concurrency without giving up on going to production. Remember that its famous "10,000 times faster" measures framework overhead, not real latency. The next step is to install it with pip install agno, write your first agent with a tool and compare it with CrewAI to decide which fits your project best.

Sources: [1] Official Agno documentation[1], [2] Agno on GitHub[2], [3] agno package on PyPI[3], [4] Independent Agno review at ChatForest[4].

Visitas: 0

Sources

  1. Official Agno documentation
  2. Agno on GitHub
  3. agno package on PyPI
  4. Independent Agno review at ChatForest

Route: Frameworks to Build AI Agents