Agno

Agno AI Framework Skill

Expert assistance for building production-ready multi-agent AI systems using Agno - an incredibly fast multi-agent framework with runtime and control plane.

When to Use This Skill

This skill should be used when:

• Building AI agents or multi-agent systems
• Implementing RAG (Retrieval-Augmented Generation) solutions
• Creating autonomous AI workflows and pipelines
• Deploying agents to production with AgentOS
• Working with LLM-powered applications
• Questions about Agno framework, agents, teams, or workflows
• Implementing tools, memory, knowledge bases, or storage for agents
• Integrating with various LLM providers (Anthropic, OpenAI, Google, etc.)
• Debugging or optimizing Agno-based applications
• Setting up production deployment with authentication and monitoring

Overview

Agno is an open-source framework for building, deploying, and managing multi-agent AI systems that emphasizes:

• Performance: 529× faster than LangGraph, 57× faster than PydanticAI
• Production-Ready: Complete runtime (AgentOS) and control plane for deployment
• Security-First: Runs entirely in your cloud infrastructure
• Model-Agnostic: Supports all major LLM providers (OpenAI, Anthropic, Google, etc.)

Core Components

1. Agents - AI programs where the language model controls execution flow

from agno.agent import Agent
from agno.models.anthropic import Claude

agent = Agent(
    id="my-agent",
    model=Claude(id="claude-sonnet-4"),
    instructions="You are a helpful assistant.",
    markdown=True,
)

# Run synchronously
agent.run("Hello, how can you help?")

# Run asynchronously
await agent.arun("Hello, how can you help?")

Key Agent Features:

• Tools: Enable agents to take actions and interact with external systems
• Memory: Store and recall information from previous interactions
• Knowledge: Vector database integration for RAG patterns
• Storage: Save session history and state in a database
• Reasoning: Analyze action results before responding

2. Teams - Collections of agents working together

from agno.team import Team

team = Team(
    id="research-team",
    agents=[researcher, writer, editor],
    instructions="Collaborate to create research articles.",
)

# Agents can delegate work to each other
team.run("Research AI trends and write an article")

3. Workflows - Orchestrated sequences of agents and logic

from agno.workflow import Workflow, RunResponse

workflow = Workflow(
    id="content-workflow",
    steps=[
        {"agent": researcher, "message": "Research topic"},
        {"agent": writer, "message": "Write draft"},
        {"agent": editor, "message": "Edit and polish"},
    ]
)

workflow.run("Create content about AI agents")

4. AgentOS - Production runtime for deployment

from agno.os import AgentOS
from agno.db.postgres import PostgresDb

# Setup database
db = PostgresDb(
    id="production-db",
    db_url="postgresql+psycopg://user:pass@localhost:5432/agno"
)

# Create AgentOS instance
agent_os = AgentOS(
    description="Production Multi-Agent System",
    agents=[agent1, agent2],
    teams=[team1],
    workflows=[workflow1],
    db=db,
)

# Get FastAPI app
app = agent_os.get_app()

# Serve with uvicorn
if __name__ == "__main__":
    agent_os.serve(app="main:app", reload=True, port=7777)

Quick Start Guide

Installation

pip install agno

Create Your First Agent

from agno.agent import Agent
from agno.models.anthropic import Claude
from agno.tools.duckduckgo import DuckDuckGoTools

# Create an agent with web search capability
agent = Agent(
    id="web-search-agent",
    model=Claude(id="claude-sonnet-4"),
    tools=[DuckDuckGoTools()],
    instructions="Search the web and provide accurate information.",
    show_tool_calls=True,
    markdown=True,
)

# Run the agent
response = agent.run("What are the latest AI trends?")
print(response.content)

Add Memory and Storage

from agno.agent import Agent
from agno.db.postgres import PostgresDb
from agno.memory import AgentMemory

# Setup database for persistence
db = PostgresDb(
    id="agent-db",
    db_url="postgresql+psycopg://ai:ai@localhost:5532/ai"
)

# Create agent with memory
agent = Agent(
    id="memory-agent",
    model=Claude(id="claude-sonnet-4"),
    db=db,
    memory=AgentMemory(create_user_memories=True),
    storage={"messages": True, "sessions": True},
    instructions="Remember user preferences and context.",
)

# Conversations persist across sessions
agent.run("My name is John", session_id="session_123")
agent.run("What's my name?", session_id="session_123")  # Remembers "John"

Build a RAG Agent with Knowledge

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

# Setup vector database
vector_db = PgVector(
    db_url="postgresql+psycopg://ai:ai@localhost:5532/ai",
    table_name="agno_knowledge"
)

# Create knowledge base from PDFs
knowledge = PDFKnowledgeBase(
    path="docs/",
    vector_db=vector_db,
)

# Load documents into vector database
knowledge.load(recreate=False)

# Create RAG agent
rag_agent = Agent(
    id="rag-agent",
    model=Claude(id="claude-sonnet-4"),
    knowledge=knowledge,
    search_knowledge=True,
    instructions="Answer questions using the knowledge base. Cite sources.",
)

# Agent searches knowledge base before responding
rag_agent.run("What does our documentation say about agents?")

Common Patterns

1. Structured Output with Pydantic

from pydantic import BaseModel, Field
from agno.agent import Agent

class MovieReview(BaseModel):
    title: str = Field(..., description="Movie title")
    rating: float = Field(..., ge=0, le=10)
    summary: str = Field(..., description="Brief summary")
    pros: list[str]
    cons: list[str]

agent = Agent(
    model=Claude(id="claude-sonnet-4"),
    output_model=MovieReview,
    structured_output=True,
)

response = agent.run("Review the movie Inception")
review: MovieReview = response.output  # Type-safe structured output

2. Human-in-the-Loop (HITL)

from agno.agent import Agent
from agno.tools import tool

@tool
def execute_trade(stock: str, amount: int) -> str:
    """Execute a stock trade (requires approval)."""
    return f"Executed trade: {amount} shares of {stock}"

agent = Agent(
    model=Claude(id="claude-sonnet-4"),
    tools=[execute_trade],
    require_approval_for_tools=True,  # Requires human approval
)

# Agent will pause and wait for approval before executing trade
agent.run("Buy 100 shares of AAPL")

3. Multi-Agent Collaboration

from agno.team import Team

# Define specialized agents
researcher = Agent(
    id="researcher",
    role="Research specialist",
    tools=[DuckDuckGoTools()],
    instructions="Find accurate information on topics.",
)

writer = Agent(
    id="writer",
    role="Content writer",
    instructions="Write engaging, well-structured content.",
)

editor = Agent(
    id="editor",
    role="Editor",
    instructions="Review and improve content quality.",
)

# Create team
content_team = Team(
    id="content-team",
    agents=[researcher, writer, editor],
    leader=researcher,  # Lead agent coordinates
    instructions="""
    1. Researcher finds information
    2. Writer creates content
    3. Editor reviews and finalizes
    """,
)

# Team collaborates automatically
content_team.run("Create an article about quantum computing")

4. Context Injection and Dependencies

# Pass dynamic context to agents
agent.run(
    "Write a story about {character}",
    dependencies={"character": "a brave robot named Anna"}
)

# Pass runtime metadata
agent.run(
    "Generate report",
    metadata={"user_id": "123", "department": "engineering"}
)

# Manage session state
agent.run(
    "Continue our conversation",
    session_id="user_123",
    session_state={"preferences": {"theme": "dark"}}
)

5. Streaming Responses

# Stream agent responses
for chunk in agent.run_stream("Tell me a story"):
    if chunk.content:
        print(chunk.content, end="", flush=True)

# Async streaming
async for chunk in agent.arun_stream("Tell me a story"):
    if chunk.content:
        print(chunk.content, end="", flush=True)

AgentOS API Deployment

Run Agents via REST API

# Start AgentOS server
python main.py

# Run agent via API
curl --location 'http://localhost:7777/agents/my-agent/runs' \
    --header 'Content-Type: application/x-www-form-urlencoded' \
    --data-urlencode 'message=Tell me about Agno' \
    --data-urlencode 'stream=True' \
    --data-urlencode 'user_id=user@example.com' \
    --data-urlencode 'session_id=session_123'

# Pass dependencies via API
curl --location 'http://localhost:7777/agents/my-agent/runs' \
    --data-urlencode 'message=Write a story' \
    --data-urlencode 'dependencies={"character_name": "Anna"}'

# Pass structured output schema
curl --location 'http://localhost:7777/agents/my-agent/runs' \
    --data-urlencode 'message=Generate data' \
    --data-urlencode 'output_schema={"type":"object","properties":{"name":{"type":"string"}}}'

Authentication

# Secure AgentOS with API keys
agent_os = AgentOS(
    agents=[agent],
    security_key="your-secret-key",
)

# Client requests
curl --location 'http://localhost:7777/agents/my-agent/runs' \
    --header 'Authorization: Bearer your-secret-key' \
    --data-urlencode 'message=Hello'

Advanced Features

Hooks and Background Tasks

from agno.hooks import hook

# Pre-run hook
@hook
def validate_input(run_input, agent):
    """Validate input before agent runs."""
    if "forbidden" in run_input.message:
        raise ValueError("Forbidden content detected")
    return run_input

# Post-run hook (background)
@hook(run_in_background=True)
async def log_response(run_output, agent):
    """Log responses without blocking."""
    await analytics_service.log(run_output)

agent = Agent(
    model=Claude(id="claude-sonnet-4"),
    pre_run_hooks=[validate_input],
    post_run_hooks=[log_response],
)

# Enable background hooks globally in AgentOS
agent_os = AgentOS(
    agents=[agent],
    run_hooks_in_background=True,
)

Reasoning and Model Controls

# Enable reasoning
agent = Agent(
    model=Claude(id="claude-sonnet-4"),
    reasoning=True,  # Agent thinks before responding
    instructions="Think carefully about each question.",
)

# Control model parameters
agent = Agent(
    model=Claude(
        id="claude-sonnet-4",
        temperature=0.7,
        max_tokens=2000,
    ),
)

Context Management

# Automatic context compression
agent = Agent(
    model=Claude(id="claude-sonnet-4"),
    compress_context=True,  # Automatically compress long contexts
    max_context_length=100000,
)

Model Provider Support

Agno supports all major LLM providers:

# Anthropic Claude
from agno.models.anthropic import Claude
model = Claude(id="claude-sonnet-4")

# OpenAI
from agno.models.openai import OpenAIChat
model = OpenAIChat(id="gpt-4o")

# Google Gemini
from agno.models.google import Gemini
model = Gemini(id="gemini-2.0-flash-exp")

# AWS Bedrock
from agno.models.bedrock import Bedrock
model = Bedrock(id="anthropic.claude-3-5-sonnet-20241022-v2:0")

# Azure OpenAI
from agno.models.azure import AzureOpenAIChat
model = AzureOpenAIChat(id="gpt-4o")

Built-in Tools and Integrations

Agno includes 100+ pre-built tool integrations:

# Web Search
from agno.tools.duckduckgo import DuckDuckGoTools
from agno.tools.tavily import TavilyTools

# File Operations
from agno.tools.file import FileTools

# APIs
from agno.tools.github import GitHubTools
from agno.tools.slack import SlackTools

# Data Analysis
from agno.tools.pandas import PandasTools
from agno.tools.sql import SQLTools

# Web Scraping
from agno.tools.newspaper import NewspaperToolkit
from agno.tools.beautifulsoup import BeautifulSoupTools

# And many more...

Create Custom Tools

from agno.tools import tool

@tool
def calculate_roi(investment: float, return_value: float) -> dict:
    """
    Calculate return on investment.

    Args:
        investment: Initial investment amount
        return_value: Final return value

    Returns:
        Dictionary with ROI percentage and profit
    """
    profit = return_value - investment
    roi_percentage = (profit / investment) * 100

    return {
        "profit": profit,
        "roi_percentage": roi_percentage,
        "investment": investment,
        "return": return_value,
    }

# Use in agent
agent = Agent(
    model=Claude(id="claude-sonnet-4"),
    tools=[calculate_roi],
    show_tool_calls=True,
)

Best Practices

1. Use Structured Instructions

agent = Agent(
    instructions="""
    You are a customer support agent. Follow these rules:
    1. Always greet users warmly
    2. Ask clarifying questions if needed
    3. Provide step-by-step solutions
    4. Verify customer satisfaction before closing
    5. Escalate complex issues to human agents
    """,
)

2. Implement Proper Error Handling

try:
    response = agent.run(user_input)
except Exception as e:
    logger.error(f"Agent error: {e}")
    # Implement fallback logic

3. Use Session Management

# Maintain conversation context
agent.run(message, session_id=f"user_{user_id}")

4. Monitor and Evaluate

# Use hooks for monitoring
@hook
def track_usage(run_output, agent):
    """Track agent usage and performance."""
    metrics.record({
        "agent_id": agent.id,
        "response_time": run_output.metrics.time_to_first_token,
        "tokens_used": run_output.metrics.output_tokens,
    })

5. Optimize for Production

# Use database for persistence
db = PostgresDb(db_url=os.getenv("DATABASE_URL"))

# Enable caching
agent = Agent(
    db=db,
    storage={"messages": True, "sessions": True},
)

# Deploy with AgentOS
agent_os = AgentOS(
    agents=[agent],
    db=db,
    security_key=os.getenv("API_SECRET_KEY"),
)

Performance Benchmarks

Agno is optimized for production use:

• Agent instantiation: ~3 microseconds
• Memory per agent: ~6.6 KiB
• Throughput: 529× faster than LangGraph, 57× faster than PydanticAI

Reference Files

This skill includes comprehensive documentation in references/:

• llms-full.md - Complete Agno documentation (4.8MB)
• llms-txt.md - Condensed documentation (3.1MB)
• llms.md - Quick reference (203KB)
• index.md - Documentation index

Use Cases and Examples

1. Documentation Assistant (RAG)

Build an AI assistant that answers questions from your knowledge base using vector search.

2. Competitor Analysis

Automated competitive intelligence through web search and content analysis.

3. Research Agent

Create research articles with web search, fact-checking, and writing capabilities.

4. Web Data Extraction

Transform unstructured web content into organized, structured data.

5. Content Generation Pipeline

Multi-agent workflow for researching, writing, and editing content.

Common Issues and Solutions

Issue: Agent not using tools

Solution: Ensure show_tool_calls=True and verify tool descriptions are clear.

Issue: Context too long

Solution: Enable compress_context=True or implement context summarization.

Issue: Slow responses

Solution: Use streaming (run_stream()) and optimize tool execution.

Issue: Lost conversation context

Solution: Implement proper session management with session_id and database storage.

Resources

• Documentation: https://docs.agno.com
• GitHub: https://github.com/agno-agi/agno
• Community: https://community.agno.com
• Discord: Join the Agno Discord community
• Examples: https://github.com/agno-agi/agno/tree/main/cookbook

License

Apache-2.0

Note: This skill was generated from official Agno documentation. For the most up-to-date information, always refer to the official docs at https://docs.agno.com