Introduction

Build agents, teams, and workflows in pure python.

Agno is a python SDK for building multi-agent systems. It gives you three primitives (agents, teams and workflows) and a large set of capabilities you attach to them.

Agent

from agno.agent import Agent
from agno.db.sqlite import SqliteDb
from agno.tools.workspace import Workspace

workbench = Agent(
    name="Workbench",
    model="openai:gpt-5.5",
    db=SqliteDb(db_file="workbench.db"),
    tools=[Workspace(".")],
    enable_agentic_memory=True,
    add_history_to_context=True,
    num_history_runs=3,
    markdown=True,
)

workbench.print_response("Inventory this folder.")

from agno.agent import Agent
from agno.team import Team
from agno.tools.yfinance import YFinanceTools

bull = Agent(
    name="Bull",
    model="openai:gpt-5.4",
    role="Make the case FOR investing.",
    tools=[YFinanceTools()],
)
bear = Agent(
    name="Bear",
    model="openai:gpt-5.4",
    role="Make the case AGAINST investing.",
    tools=[YFinanceTools()],
)

team = Team(
    name="Investment Committee",
    members=[bull, bear],
    instructions="Hear both sides, then synthesize a balanced recommendation.",
)

team.print_response("Should I invest in NVIDIA?")

from agno.agent import Agent
from agno.team import Team
from agno.tools.yfinance import YFinanceTools
from agno.workflow import Step, Workflow

researcher = Agent(
    model="openai:gpt-5.4",
    tools=[YFinanceTools()],
    instructions="Gather raw market data.",
)

bull = Agent(model="openai:gpt-5.4", role="Make the case FOR investing.")
bear = Agent(model="openai:gpt-5.4", role="Make the case AGAINST investing.")
committee = Team(
    name="Investment Committee",
    members=[bull, bear],
    instructions="Debate the position.",
)

writer = Agent(
    model="openai:gpt-5.4",
    instructions="Write a 200-word investment brief.",
)

workflow = Workflow(
    name="Stock Research",
    steps=[
        Step(name="Research", agent=researcher),
        Step(name="Debate", team=committee),
        Step(name="Report", agent=writer),
    ],
)

workflow.print_response("Analyze NVIDIA for investment.")

Three primitives

Primitive	Use it to
Agent	Autonomous programs with a model, tools, and instructions
Team	Coordinate multiple agents on a single task
Workflow	Deterministic, step-based pipelines over agents and teams

Capabilities

Model and tools

Capability	What it adds
Models	30+ providers behind one API
Tools	100+ integrations and the ability to write your own
Skills	Composable abilities you attach to agents and teams
Multimodal	Image, audio, and video input and output
Structured I/O	Type-safe input and output with Pydantic schemas

Memory and context

Capability	What it adds
Storage	Durability and persistence on any database
Sessions	Multi-turn sessions with summaries, history, and metrics
State	State your agents can read and update mid-run
Memory	Per-user and per-session memory
Knowledge	Search over documents, URLs, and databases
Learning	Agents that improve over time from feedback and outcomes
Compression	Keep long sessions inside the model’s context window
Context Providers	Inject live data from Calendar, Gmail, Drive, GitHub, Slack, MCP
Dependencies	Inject runtime values into prompts

Control and safety

Capability	What it adds
Guardrails	Validate input and output
Hooks	Pre-run and post-run callbacks
Human-in-the-Loop	Pause runs for approval, input, or external execution

Operations

Capability	What it adds
Background execution	Long-running runs that don’t block your API
Evals	Measure accuracy, performance, and reliability
Observability	OpenTelemetry tracing into your own database
Scheduler	Run agents and workflows on a recurring schedule

From SDK to platform

Agents built using the SDK need to run in a python process: a script, a notebook, a job.

When you’re ready to go live, wrap your agents in AgentOS and you get an API server, persistence, auth, tracing, scheduling, and interfaces.

Where to start

Install & Setup

Install Agno and run your first agent.

Run on AgentOS

Run your agent as a service.