Agno (formerly Phidata) is a high-performance runtime for building, deploying, and managing agentic software at scale. With approximately 39K GitHub stars, Agno claims 5,000x faster agent instantiation and 50x less memory than LangGraph, positioning itself as the performance leader among agent frameworks.

framework python agents multi-agent performance runtime

Agno was rebranded from Phidata in January 2025, shifting from a data engineering tool to a dedicated agentic AI runtime. The framework treats multi-agent orchestration, streaming, and production deployment as native platform concerns rather than bolted-on features. Its core pitch is performance: agent creation in approximately 2 microseconds using just 3.75 KiB of memory per agent, enabling thousands of concurrent sessions on modest hardware. Agno provides AgentOS as an operating system abstraction for agents, with built-in support for teams, workflows, and multi-modal capabilities.

• AgentOS — Operating system abstraction for centralized knowledge management and agent lifecycle
• Agent Teams — Multi-agent collaboration with async streaming via AsyncIterator returns
• Workflows — Parallel execution with queue-based real-time event streaming
• Multi-Modal Support — Native support for Gemini 2.5+, Claude, and reasoning models with thinking capabilities
• Performance — ~2us agent instantiation (5,000x faster than LangGraph), ~3.75 KiB per agent (50x less memory)
• Concurrent Memory — Automatic memory initialization on dedicated threads for improved startup
• Toolkit Ecosystem — Gmail, Google Calendar, Jira, SurrealDb, OCR (DeepSeek-OCR), and more
• Culture (Experimental) — Shared cognitive spaces for emergent multi-agent learning

Agno's architecture is organized around a layered runtime:

Building a multi-agent team with Agno:

from agno.agent import Agent
from agno.team import Team
from agno.tools.duckduckgo import DuckDuckGoTools
from agno.tools.newspaper4k import Newspaper4kTools
from agno.models.openai import OpenAIChat
 
# Create specialized agents
researcher = Agent(
    name="Researcher",
    model=OpenAIChat(id="gpt-4o"),
    tools=[DuckDuckGoTools()],
    instructions="Search the web for current information.",
)
 
writer = Agent(
    name="Writer",
    model=OpenAIChat(id="gpt-4o"),
    tools=[Newspaper4kTools()],
    instructions="Write clear, engaging content from research.",
)
 
# Combine into a team
team = Team(
    name="Research Team",
    agents=[researcher, writer],
    instructions="Research topics and produce well-written summaries.",
)
 
# Run the team
result = team.run("Latest breakthroughs in quantum computing")
print(result.content)

Agno's performance claims are based on agent instantiation benchmarks:

These benchmarks focus on instantiation overhead, not end-to-end inference (which is dominated by LLM API latency). Agno achieves this through a stateless, horizontally scalable runtime with minimal abstractions. LangGraph's higher overhead stems from its graph-based state machine architecture with built-in persistence.

• Concurrent memory creation on dedicated threads
• arun() returns AsyncIterator for real-time team streaming
• Graph-based workflows with queue-based parallel event streaming
• Culture feature (experimental) for emergent multi-agent learning
• Knowledge search API, health endpoint with instantiation time metrics
• Bigtable toolset, OAuth flows, embedding model selection

• GitHub Repository
• Documentation
• Official Website
• Agent UI

• LangChain — The leading LLM framework (comparison target)
• PydanticAI — Type-safe agent framework
• Letta — Stateful agents with persistent memory