Agno

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

Overview

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.

Key Features

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

Architecture

Agno's architecture is organized around a layered runtime:

graph TD A[Event Streaming: PostHook / SessionSummary / RunContent] --> B[Agent: Single] A --> C[Teams: Multi-Agent Collab] A --> D[Workflows: Parallel Execution] B --> E[Knowledge / Memory Layer] C --> E D --> E E --> F[Core Memory] E --> G[Archival Memory] E --> H[Concurrent Memory]

Code Example

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)

Performance: The 5,000x Claim

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

Metric	Agno	LangGraph
Agent Instantiation	~2 microseconds	~10 milliseconds
Memory per Agent	~3.75 KiB	~187 KiB
Speedup Factor	5,000x faster	Baseline
Memory Efficiency	50x less	Baseline

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.

Recent Updates (2025-2026)

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

Table of Contents