> ## Documentation Index
> Fetch the complete documentation index at: https://agno-v2-docs-align-with-readme.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Welcome to Agno

> Build, run, and manage agent platforms.

**Agno provides software for building, running, and managing agent platforms.**

* Build agents using any agent framework.
* Run them as production services with session management, tracing, scheduling, and RBAC.
* Manage your platform using a single control plane.

Agno has a 3-layer architecture. Everything except the control plane is free and open-source.

| Layer             | Use it to | What it does                                                      |
| ----------------- | --------- | ----------------------------------------------------------------- |
| **SDK**           | Build     | Build agents, multi-agent teams, and agentic workflows.           |
| **Runtime**       | Run       | Run your agents, teams, and workflows as a service.               |
| **Control Plane** | Manage    | Manage your platform using the [AgentOS UI](https://os.agno.com). |

<CodeGroup>
  ```python Agno SDK theme={null}
  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,
  )

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

  ```python Claude Agent SDK theme={null}
  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],
      tracing=True,
      db=SqliteDb(db_file="tmp/agentos.db"),
  )
  app = agent_os.get_app()
  ```

  ```python LangGraph theme={null}
  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")
  compiled = graph.compile()

  agent = LangGraphAgent(
      name="LangGraph Chatbot",
      graph=compiled,
  )

  agent_os = AgentOS(
      agents=[agent],
      tracing=True,
      db=SqliteDb(db_file="tmp/agentos.db"),
  )
  app = agent_os.get_app()
  ```

  ```python DSPy theme={null}
  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],
      tracing=True,
      db=SqliteDb(db_file="tmp/agentos.db"),
  )
  app = agent_os.get_app()
  ```
</CodeGroup>

20 lines of code and you have a FastAPI backend with 50+ endpoints, persisted sessions, tracing, scheduling and RBAC. Interact using the AgentOS UI, Slack, Discord or build a product on top.

Run native Agno agents next to Claude Code, LangGraph and DSPy agents in the same AgentOS.

## Agno features

* [**Production API.**](/runtime/serve-as-api) 50+ endpoints with SSE and websockets make it easy to build a product on top of your agent platform.
* [**Storage.**](/runtime/storage) Store sessions, memory, knowledge, and traces in your own database. Use postgres for quick read/write data like sessions and memory. Use clickhouse for OLAP data like traces.
* [**100+ integrations.**](/tools/toolkits/overview) Integrate with 100+ tools using pre-built toolkits.
* [**Context Providers.**](/runtime/context) Use strategies like context providers to access live data stored in Slack, Drive, wikis, MCP, and custom sources.
* [**Human approval.**](/runtime/human-approval) Built in mechanisms for pausing runs for user confirmation up to blocking tools that require admin approval.
* [**Observability.**](/runtime/observability) Get monitoring via OpenTelemetry tracing, run history, and audit logs out of the box.
* [**Security.**](/runtime/security-and-auth) Get JWT-based RBAC and multi-user, multi-tenant isolation out of the box.
* [**Interfaces.**](/runtime/interfaces) Expose your agents via Slack, Telegram, WhatsApp, Discord, AG-UI, A2A.
* [**Scheduling.**](/runtime/scheduling) Cron-based scheduling and background jobs with no external infrastructure.
* [**Deploy anywhere.**](/runtime/deploy) Run on any cloud platform that can run a containerized image.

## Pick a path

<CardGroup cols={1}>
  <Card title="Build your first agent" icon="bolt" iconType="duotone" href="/first-agent">
    A model, tools, and instructions in 20 lines of code.
  </Card>

  <Card title="Build an agent platform" icon="layer-group" iconType="duotone" href="/tutorials/agent-platform/overview">
    The full tutorial: clone the template, ship your first agent with Claude Code, deploy to Railway.
  </Card>

  <Card title="Start from a template" icon="rocket-launch" iconType="duotone" href="/tutorials/pick-a-template">
    Production templates (Scout, Dash, Coda) you can clone and deploy.
  </Card>

  <Card title="Use Agno with your coding agent" icon="terminal" iconType="duotone" href="/coding-agents">
    Wire up agno documentation with your favorite coding agent.
  </Card>
</CardGroup>