README

</picture>

Build agents in any framework. Run as a service. Ship to real users.

What is Agno

Agno is the runtime for agentic software. Use it to serve agents as production services.

Build agents using the Agno SDK, Claude Agent SDK, LangGraph, DSPy, or your own framework. Run them as production services with sessions, tracing, scheduling, and RBAC. Manage them from a single control plane.

Quick Start

Wrap a coding agent and serve it as a production API. Same shape across every framework.

With the Agno SDK

Save as workbench.py:

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

workbench = Agent(
    name="Workbench",
    model="openai:gpt-5.4",
    tools=[Workspace(".",
        allowed=["read", "list", "search"],
        confirm=["write", "edit", "delete", "shell"],
    )],
    enable_agentic_memory=True,
    add_history_to_context=True,
    num_history_runs=3,
)

# Serve via AgentOS → streaming, auth, session isolation, API endpoints
agent_os = AgentOS(agents=[workbench], tracing=True, db=SqliteDb(db_file="agno.db"))
app = agent_os.get_app()

Workspace(".") scopes the agent to the current directory. read, list, and search run freely; write, edit, move, delete, and shell require human approval.

With the Claude Agent SDK

from agno.agents.claude import ClaudeAgent
from agno.db.sqlite import SqliteDb
from agno.os import AgentOS

agent = ClaudeAgent(
    name="Claude Agent",
    model="claude-opus-4-7",
    allowed_tools=["Read", "Bash"],
    permission_mode="acceptEdits",
)

agent_os = AgentOS(agents=[agent], db=SqliteDb(db_file="agno.db"), tracing=True)
app = agent_os.get_app()

The same wrapping pattern works for LangGraph and DSPy.

from agno.agents.langgraph import LangGraphAgent
from agno.db.sqlite import SqliteDb
from agno.os import AgentOS
from langchain_openai import ChatOpenAI
from langgraph.graph import MessagesState, StateGraph

def chatbot(state: MessagesState):
    return {"messages": [ChatOpenAI(model="gpt-5.4").invoke(state["messages"])]}

graph = StateGraph(MessagesState)
graph.add_node("chatbot", chatbot)
graph.set_entry_point("chatbot")

agent = LangGraphAgent(name="LangGraph Chatbot", graph=graph.compile())
agent_os = AgentOS(agents=[agent], db=SqliteDb(db_file="agno.db"), tracing=True)
app = agent_os.get_app()

import dspy
from agno.agents.dspy import DSPyAgent
from agno.db.sqlite import SqliteDb
from agno.os import AgentOS

dspy.configure(lm=dspy.LM("openai/gpt-5.4"))

agent = DSPyAgent(
    name="DSPy Assistant",
    program=dspy.ChainOfThought("question -> answer"),
)

agent_os = AgentOS(agents=[agent], db=SqliteDb(db_file="agno.db"), tracing=True)
app = agent_os.get_app()

Run it

uv pip install -U 'agno[os]' openai

export OPENAI_API_KEY=sk-***

fastapi dev workbench.py

In ~20 lines, you get:

• A FastAPI backend with 50+ endpoints
• Streaming responses, persistent sessions, per-user isolation
• Native OpenTelemetry tracing
• Cron scheduling, human approval flows, and RBAC ready to enable

API at http://localhost:8000. OpenAPI spec at http://localhost:8000/docs.

Connect to the AgentOS UI

The AgentOS UI is your control plane. Use it to chat with your agents, inspect runs, view traces, manage sessions, and operate the system.

1. Open os.agno.com and sign in.
2. Click "Connect OS"
3. Select "Local" to connect to a local AgentOS.
4. Enter your endpoint URL (default: http://localhost:8000).
5. Name it "Local AgentOS" and click "Connect".

Open Chat, select your agent, and ask:

Tell me more about the project and the key files

The agent reads your workspace and answers grounded in what it actually finds. Try a follow-up like "create a NOTES.md with three key takeaways". The run pauses for your approval before the file is written, since write_file is a confirm-required tool by default.

https://github.com/user-attachments/assets/adb38f55-1d9d-463e-8ca9-966bb6bdc37a

What AgentOS gives you

• Production API. 50+ endpoints with SSE and websockets to build your product on.
• Storage. Sessions, memory, knowledge, and traces in your own database.
• Context. Live context across Slack, Drive, wikis, MCP, and custom sources.
• Human approval. Pause runs for user confirmation, admin approval, or external execution.
• Observability. OpenTelemetry tracing, run history, and audit logs out of the box.
• Security & auth. JWT-based RBAC and multi-user, multi-tenant isolation.
• Interfaces. Slack, Telegram, WhatsApp, Discord, AG-UI, A2A, or roll your own.
• Scheduling. Cron-based scheduling and background jobs with no external infrastructure.
• Deploy. Docker, Railway, AWS, GCP. Any container host works.

What you can build

Three reference agents, all open source, all built on the same primitives:

• Coda → A Slack-native coding agent that ships PRs from your team chat.
• Dash → A self-learning data agent grounded in six layers of context.
• Scout → A self-learning context agent that manages enterprise knowledge.

Get started

1. Read the docs
2. Build your first agent
3. Explore the cookbook

IDE integration

Add Agno docs as a source in your coding tools:

Cursor: Settings → Indexing & Docs → Add https://docs.agno.com/llms-full.txt

Also works with VSCode, Windsurf, and similar tools.

Contributing

See the contributing guide.

Telemetry

Agno logs which model providers are used to prioritize updates. Disable with AGNO_TELEMETRY=false.