agno — Fast, Production-Ready Agent Framework (Phidata Successor)
agno is the 2025 rebrand of phidata — a Python agent framework designed for low instantiation overhead, built-in memory, knowledge, teams, and a full-featured Agent UI for production observability.
Why agno
agno’s pitch centers on speed + observability. Agent instantiation runs in microseconds (benchmark published in the README), which matters when you spin up agents per-request or per-user at high throughput. The Agent UI reads the agent storage and renders a live timeline of reasoning, tool calls, and knowledge retrieval — no separate observability service to configure.
Relative to CrewAI, agno feels lighter and more modular. You compose agents, teams, memory, and knowledge from small building blocks. There’s no SOP you must buy into. For some teams this is liberating; for others CrewAI’s more opinionated structure ships faster.
Teams in agno are practical — not as powerful as LangGraph for complex control flow, but enough for the vast majority of "three specialists plus a coordinator" workflows. Combined with memory, knowledge, and a growing tool catalog, agno is one of the most feature-complete "batteries included" frameworks in 2026.
Quick Start — Single Agent with Memory + Knowledge
memory=Memory(...) persists across runs; knowledge=PDFUrlKnowledgeBase(...) + vector_db=... gives the agent RAG against your docs. enable_agentic_memory=True lets the agent decide what to remember itself (akin to Letta). add_references=True injects source attributions into replies.
# pip install -U agno openai lancedb
from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.memory.v2.memory import Memory
from agno.memory.v2.db.sqlite import SqliteMemoryDb
from agno.knowledge.pdf_url import PDFUrlKnowledgeBase
from agno.vectordb.lancedb import LanceDb, SearchType
# Persistent memory across sessions
memory = Memory(
db=SqliteMemoryDb(table_name="user_memory", db_file="tmp/agent.db"),
model=OpenAIChat(id="gpt-4o-mini"),
)
# Knowledge base from a public PDF
kb = PDFUrlKnowledgeBase(
urls=["https://arxiv.org/pdf/2310.08560"], # the MemGPT paper
vector_db=LanceDb(table_name="agent_kb", uri="tmp/lancedb", search_type=SearchType.hybrid),
)
kb.load(recreate=False) # index once
agent = Agent(
model=OpenAIChat(id="gpt-4o-mini"),
memory=memory,
knowledge=kb,
user_id="william",
enable_agentic_memory=True, # agent can write/read its own memory
add_references=True, # cite knowledge passages in replies
markdown=True,
)
agent.print_response("What does the MemGPT paper say about paged memory? Remember that I care about Python examples.",
stream=True)
# Next session the same agent remembers the "Python examples" preference,
# and answers about MemGPT using retrieved passages with citations.Key Features
Microsecond instantiation
agno is optimized for spinning up agents per request or per user. Benchmarks show ~10μs vs milliseconds in other frameworks — significant at high concurrency.
First-class memory (v2)
Short-term + long-term memory with SQLite/Postgres storage. agentic_memory mode lets the agent decide what to persist — similar pattern to Letta, with lower setup overhead.
Built-in knowledge (RAG)
PDF, URL, text, and Wikipedia knowledge sources. Pluggable vector DBs (LanceDB, PgVector, Qdrant, Chroma, Weaviate). Hybrid search and re-ranking built in.
Teams for multi-agent
Team class with coordinate / collaborate / route modes. Each member has independent instructions, tools, and model. Coordinator LLM decides flow in coordinate mode.
Massive tool catalog
80+ tools: search (DuckDuckGo, Tavily, Exa), finance (YFinance), comms (Slack, Gmail, Discord, WhatsApp), data (SQL, Python REPL, Snowflake), scraping (Firecrawl), and more. Easy to write custom @tool functions.
Agent UI
Next.js dashboard that reads agent storage and shows a real-time timeline of every run — messages, tool calls, reasoning, knowledge hits, memory updates. The headline feature that keeps phidata users on it.
Comparison
| Strength | Team Abstraction | Observability | Learning Curve | |
|---|---|---|---|---|
| agnothis | Fast + UI + batteries-included | Team (3 modes) | Agent UI | Low |
| CrewAI | Mature role abstraction | Crew + tasks | Enterprise UI (paid) | Low |
| LangGraph | Reliable control flow | Graph + supervisors | LangGraph Studio + LangSmith | Medium |
| AutoGen | Research-strong | GroupChat | Studio + trace logs | Medium |
Use Cases
01. Observable production agents
Apps where ops needs to see inside the agent. Agent UI gives a timeline of reasoning, tool calls, memory, and retrieval hits without a separate observability vendor.
02. Knowledge-heavy assistants
The integrated knowledge + memory stack handles document RAG plus user-specific facts in one library — less plumbing than wiring mem0 + Langfuse + a vector DB separately.
03. High-concurrency APIs
Per-request agent instantiation for personalized answers. agno’s microsecond overhead makes "new agent per user" viable without an in-memory cache.
Pricing & License
agno: MIT open source. Free to self-host.
agno Cloud / managed: platform offering from the Agno team at agno.com. Pay for hosting and managed Agent UI. Self-hosting remains first-class and fully supported.
Model + DB costs: LLM API plus your vector DB of choice. LanceDB is a cheap default (embedded, no service to run); Postgres + pgvector if you already run Postgres.
Related Assets on TokRepo
Agno Reasoning — Built-In Step-by-Step Tool Use
Agno Reasoning gives any Agent built-in chain-of-thought + tool use. Set reasoning=True; the agent plans, calls tools, returns answers with audit.
Agno — Lightweight AI Agent Framework for Python
Build AI agents in 5 lines of Python. Agno provides model-agnostic agents with tools, memory, knowledge bases, and team coordination at 10x less overhead.
Agno — Production AI Agent Runtime
Agno is a runtime for building and managing agentic software at scale. 39.1K+ GitHub stars. Stateful agents, FastAPI serving, 100+ integrations, tracing. Apache 2.0.
Faktory — Language-Agnostic Background Job Server
Faktory is a background job server that decouples job queuing from job execution, allowing workers in any programming language to process tasks. Created by the author of Sidekiq, it brings battle-tested job processing patterns (retries, scheduled jobs, priorities, batches) to polyglot environments.
Frequently Asked Questions
agno vs phidata — do I need to migrate?+
phidata was renamed to agno in 2025. Imports change from phi.* to agno.*; API is largely identical. Follow the migration guide in the repo — in most cases it is a find-and-replace plus a pip install -U agno.
agno vs CrewAI — when to pick which?+
agno if you value low overhead, built-in memory/knowledge, and the Agent UI. CrewAI if you want the more opinionated role/task abstraction and a larger community. Both are fast to ship with; pick based on which defaults match your project.
Does agno replace LangChain?+
No — different scope. LangChain is a broad toolkit for LLM applications (retrievers, loaders, tools, agents). agno is a focused agent framework with optional knowledge and memory. You can use LangChain components inside agno tools or run them independently.
How does agno’s Team compare to LangGraph?+
agno Teams cover the "coordinator + specialists" pattern cleanly. LangGraph covers arbitrary graphs including loops, conditionals, and HITL. Reach for LangGraph when agno’s Team modes feel constraining; most real workflows fit one of the three Team modes.
Is Agent UI self-hostable?+
Yes. The Next.js app ships in the repo and runs locally or on your own server. For production, protect it behind auth — treat it like any internal ops tool.