Agno — Summary

Agno (formerly Phidata) is a full-stack Python SDK for building and deploying production agent platforms, with 40k+ GitHub stars and backed by Y Combinator. It provides an Agent dataclass and a Team class that expose four coordination modes (coordinate, route, broadcast, tasks), enabling hierarchical multi-agent systems where teams can contain other teams. The framework ships 100+ pre-built tool integrations, pluggable vector/relational database adapters for persistent memory, MCP client support via context providers, and a production REST API runtime with SSE/WebSocket streaming, JWT-based RBAC, multi-tenant isolation, and cron scheduling — all of which can be hosted on any Docker-compatible cloud. Observability is first-class via OpenTelemetry tracing, audit logs, and a managed dashboard at app.agno.com (optional). The Agent dataclass supports fallback model chains (fallback_models, fallback_config), agentic state tools, session-state persistence, human approval gates, and an auto-improving learning machine (LearningMachine) that evolves with usage. Compared to seeds, Agno most closely resembles claude-flow in ambition (full-stack SDK, multi-agent, external memory), but differs by shipping a full production API runtime rather than just a CLI tool and MCP server.

Agno — Overview

Origin

Originally shipped as "Phidata" by Ashpreet Bedi (YC). Renamed to Agno in 2025 and repositioned from a tool-augmented LLM library to a full "agent platform SDK." The current README positions it as "Build, run, and manage agent platforms" — a pivot toward infra/runtime rather than just agent programming.

Philosophy

From the README:

"Build agents using any agent framework. Run them as production services with tracing, scheduling, and RBAC. Manage using a single control plane."

"Agno allows you to own your agent stack. Maintain control of your data, context, tools, permissions, memory and human-review loops."

The core philosophy: agents should be first-class production services with the same operational guarantees (auth, multi-tenancy, audit, scheduling) as any microservice.

Design pillars

1. Framework-agnostic composition: Agent and Team classes accept model: Model objects from any provider (Anthropic, OpenAI, Google, Mistral, etc.) through a unified Model protocol.
2. Team modes: coordinate (supervisor picks member, crafts task, synthesizes response), route (delegate to specialist and return directly), broadcast (parallel fan-out to all members), tasks (autonomous task-list decomposition until completion).
3. Production runtime: 50+ REST endpoints, SSE + WebSocket, JWT RBAC, multi-user/multi-tenant isolation.
4. Pluggable memory: session state in any supported DB; knowledge base via vector stores; user memory via MemoryManager.
5. Context providers: live data from Slack, Google Drive, wikis, MCP servers, custom sources.
6. LearningMachine: agents observe their own runs and evolve cultural knowledge (CulturalKnowledge), stored as db.schemas.culture rows.

Target audience

Teams moving AI agents from prototype to production who want a unified SDK + runtime + control-plane rather than assembling those three separately.

Agno — Architecture

Distribution

• Type: pip-package (core SDK) + optional managed cloud service
• PyPI name: agno
• Install: pip install agno
• Required runtime: Python ≥ 3.10
• License: Apache-2.0

Repository layout

libs/
  agno/agno/         # Core framework
    agent/           # Agent dataclass + run modules
    team/            # Team dataclass + TeamMode enum
    tools/           # 100+ tool integrations
    models/          # Model protocol + provider adapters
    memory/          # MemoryManager
    knowledge/       # KnowledgeProtocol
    vectordb/        # Vector store adapters
    db/              # Relational DB adapters
    session/         # AgentSession, TeamSession, WorkflowSession
    skills/          # Skills container
    hooks/           # Lifecycle hooks
    scheduler/       # Cron scheduling
    approval/        # Human approval gates
    guardrails/      # BaseGuardrail
    eval/            # BaseEval
    tracing/         # OpenTelemetry
    learn/           # LearningMachine
    workflow/        # Workflow engine
  agno_infra/        # Infrastructure helpers
cookbook/            # 500+ examples (organized by topic)

Key classes (from agent/agent.py)

• Agent — main dataclass; fields include: model, fallback_models, fallback_config, name, id, user_id, session_id, session_state, memory, knowledge, tools, guardrails, evals, skills, hooks, approval
• Team — wraps List[Union[Agent, Team]]; mode: TeamMode; can nest teams recursively

Team modes

class TeamMode(str, Enum):
    coordinate = "coordinate"   # supervisor pattern
    route = "route"             # router pattern
    broadcast = "broadcast"     # parallel fan-out
    tasks = "tasks"             # autonomous task decomposition

Tool ecosystem

100+ pre-built toolkit classes in agno/tools/: arxiv.py, bravesearch.py, docker.py, confluence.py, crawl4ai.py, discord.py, github.py, gmail.py, jira.py, postgres.py, slack.py, stripe.py, etc.

Memory backends

• File-based (default)
• PostgreSQL with pgvector
• SQLite
• LanceDB
• Pinecone
• Qdrant
• ChromaDB
• Neo4j

Target AI tools

Any provider via the Model protocol. Explicit adapters for: Anthropic, OpenAI, Google, Mistral, Cohere, Groq, Ollama, Amazon Bedrock, Together AI, DeepSeek, and more.

Agno — Components

Core framework primitives

Tool categories (partial — 100+ total)

No commands, hooks, or shipped MCP servers

Agno does not ship slash-commands, Claude Code hooks, or bundled MCP servers. MCP is consumed as a ContextProvider.

Production API endpoints (runtime)

50+ REST endpoints for agent invocation, session management, memory CRUD, scheduling, RBAC — documented at docs.agno.com/runtime/serve-as-api.

Agno — Uniqueness

Differs from seeds

Most similar to claude-flow in scope (both are full-stack SDK + runtime + multi-agent), but with three decisive differences: (1) Agno targets any LLM provider via a typed Model protocol while claude-flow is strongly Claude-oriented; (2) Agno ships a production REST API runtime with JWT RBAC and multi-tenancy as first-class features — claude-flow is a CLI tool + MCP server without a production API layer; (3) Agno's team modes include a broadcast (parallel fan-out to all members simultaneously) that has no equivalent in the seeds. Compared to BMAD-METHOD, which also does multi-agent via persona-md files and LangGraph, Agno uses code-class definitions (Agent/Team dataclasses) not markdown personas. The LearningMachine + CultureManager auto-improvement loop has no equivalent in any seed.

Positioning

Agno targets the gap between "LangChain experiment" and "production microservice." It aims to be the runtime layer that makes an agent deployable, observable, and multi-tenant — a position no seed occupies explicitly.

Distinctive features

1. Four team modes — the only framework in this batch with a typed enum of multi-agent coordination patterns
2. LearningMachine — agents observe their own runs and store cultural knowledge; future runs are influenced by past behavior
3. 50+ REST API endpoints — more than any seed or peer in this batch
4. Fallback model routing — fallback_config allows error-type-specific model fallback (e.g., switch to Gemini on Anthropic rate limit)
5. Human approval gates — built-in pause-and-resume for tool calls requiring approval

Observable failure modes

1. Complexity overhead: 40+ constructor fields on Agent — production configuration requires careful management
2. Cloud dependency for full observability: the monitoring dashboard is managed, not self-hosted
3. No isolation: no container or worktree per agent run — all agents share the host filesystem
4. Token cost: context providers + knowledge base + session history can result in very large system prompts
5. Rename churn: formerly Phidata; some cookbook examples and community posts reference old package name