Problem Addressed

Agno

Overview

Agno is a Python framework for building multi-agent systems that learn and improve with every interaction. Unlike stateless agents that forget after each session, Agno agents persist user profiles across sessions, accumulate knowledge across conversations, and transfer learned insights across users. The framework provides model-agnostic support for 40+ providers, built-in toolkits, vector store integrations, and a production runtime called AgentOS.

Problem Addressed

Key Statistics

Key Features

Learning System

• User profiles: Persist across sessions, accumulate user-specific context
• User memories: Store insights and facts about users across conversations
• Learned knowledge: Transfers across users, improving system globally
• Learning modes: Always-on or agentic (agent decides when to learn)
• Decision logging: Track and analyze agent decisions for improvement

Core Framework

• Model-agnostic: 40+ providers (OpenAI, Anthropic, Google, Llama, Mistral, DeepSeek, Groq, Ollama, vLLM)
• Type-safe I/O: input_schema and output_schema for structured data
• Async-first: Built for long-running tasks and concurrent execution
• Natively multimodal: Text, images, audio, video, files
• Guardrails: Validation and security constraints for agent behavior

Multi-Agent Orchestration

• Teams: Coordinate multiple agents with shared memory and distributed RAG
• Workflows: Chain agents, teams, and functions into automated pipelines
• Human-in-the-loop: Confirmations, approvals, overrides at decision points
• A2A protocol: Agent-to-agent communication standard support
• MCP support: First-class Model Context Protocol integration

Knowledge and RAG

• Agentic RAG: Intelligent retrieval with agent-guided search
• 20+ vector stores: Comprehensive vector database support
• Hybrid search: Combine dense and sparse retrieval
• Reranking: Improve retrieval quality with reranking models
• Multiple sources: URLs, S3, GCS, YouTube, PDFs, and more

Reasoning Capabilities

• Reasoning models: Support for o1, o3, and other reasoning-trained models
• Reasoning tools: Give agents tools that enable reasoning (think, analyze)
• Reasoning harness: reasoning=True for chain-of-thought with tool use

Storage

• Session history: Persistent conversation storage
• State management: Agent state persistence across sessions
• Supported backends: Postgres, SQLite, DynamoDB, Firestore, MongoDB, Redis, SingleStore, SurrealDB

Production Infrastructure

• AgentOS runtime: Ready-to-use FastAPI-based deployment
• Control plane UI: Monitor and manage agents via https://os.agno.com
• Evals: Accuracy (LLM-as-judge), performance (latency, memory), reliability metrics
• 100+ toolkits: Web search, SQL, email, APIs, Discord, Slack, Docker, custom tools

Technical Architecture

Stack Components

Agent Abstraction Layers

Workflows (complex orchestration)
    |
Teams (multi-agent coordination)
    |
Agents (single agent with tools, knowledge, learning)
    |
Models (40+ provider implementations)

Data Flow

1. User input received by agent
2. Agent retrieves relevant knowledge (RAG)
3. Agent reasons with model and available tools
4. Learning system captures insights (if enabled)
5. Response generated with structured output
6. Session state persisted to storage
7. Metrics logged for evals

Installation and Usage

Installation

# Using pip
pip install agno

# Using uv (recommended)
uv pip install agno

Basic Agent (with Learning)

from agno.agent import Agent
from agno.db.sqlite import SqliteDb
from agno.models.openai import OpenAIResponses

agent = Agent(
    model=OpenAIResponses(id="gpt-4o"),
    db=SqliteDb(db_file="tmp/agents.db"),
    learning=True,  # Enable learning across sessions
)

# Agent now remembers users and improves over time
response = agent.run("What can you help me with?")

Agent with Tools

from agno.agent import Agent
from agno.models.anthropic import Claude
from agno.tools.web_search import WebSearchTools

agent = Agent(
    model=Claude(id="claude-sonnet-4-20250514"),
    tools=[WebSearchTools()],
    instructions="You are a helpful research assistant.",
)

Multi-Agent Team

from agno.agent import Agent
from agno.team import Team

researcher = Agent(name="researcher", role="Research topics")
writer = Agent(name="writer", role="Write content")

team = Team(
    agents=[researcher, writer],
    workflow="sequential",  # or "parallel", "routing"
)

Agent with Knowledge (RAG)

from agno.agent import Agent
from agno.knowledge.pdf import PDFKnowledge
from agno.vectordb.pgvector import PgVector

knowledge = PDFKnowledge(
    path="./documents/",
    vector_db=PgVector(table_name="documents"),
)

agent = Agent(
    knowledge=knowledge,
    search_knowledge=True,
)

Cookbook Examples

The cookbook provides hundreds of examples:

Relevance to Claude Code Development

Direct Applications

1. Multi-Agent Orchestration Patterns: Teams and workflows abstractions provide reference architecture for coordinating Claude Code sub-agents.

2. Learning System Design: User profile persistence and knowledge transfer patterns could inform session-aware skill development.

3. MCP Integration Patterns: First-class MCP support demonstrates integration approaches for Model Context Protocol tools.

4. Tool Architecture: 100+ built-in toolkits show patterns for tool organization and discoverability.

5. RAG Implementation: Agentic RAG with hybrid search provides reference for knowledge-augmented agent design.

Patterns Worth Adopting

1. Learning Modes: "Always" vs "agentic" learning modes allow agents to decide when knowledge capture is valuable.

2. Type-Safe I/O: input_schema and output_schema ensure structured data contracts between agents.

3. Reasoning Harness: reasoning=True flag for enabling chain-of-thought is a clean abstraction.

4. Human-in-the-Loop: Explicit confirmation/approval points in workflows prevent autonomous runaway.

5. Eval Categories: Separating accuracy, performance, and reliability metrics provides clear measurement framework.

Integration Opportunities

1. MCP Server: Agno agents could be exposed as MCP tools for Claude Code workflows.

2. A2A Protocol: Agent-to-agent communication standard could enable Agno-Claude Code interop.

3. Tool Reuse: 100+ toolkits could inspire or directly inform Claude Code tool implementations.

4. Knowledge Pipeline: Document loading from URLs, S3, GCS patterns applicable to skill reference ingestion.

5. Eval Framework: Agno's eval patterns could inform Claude Code skill testing approaches.

Comparison with Claude Code

References

Research Method: Information gathered from official GitHub repository README, GitHub API (stars, forks, issues, releases), PyPI statistics API, and cookbook README. Statistics verified via direct API calls.

Freshness Tracking

Review Triggers:

• Major version release (v3.x)
• Significant new feature (new learning modes, orchestration patterns)
• GitHub stars milestone (40K, 50K)
• PyPI downloads milestone (2M monthly)
• New production runtime capabilities
• Breaking changes to Teams/Workflows API
• New model provider integrations of note