> ## Documentation Index
> Fetch the complete documentation index at: https://phidatainc.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Agno SDK

> Build your agent platform using the Agno SDK.

Agno is a Python SDK for building agent platforms. It gives you three primitives (agents, teams and workflows) and a large set of capabilities you can attach to them.

<CodeGroup>
  ```python Agent theme={null}
  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.")
  ```

  ```python Team theme={null}
  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?")
  ```

  ```python Workflow theme={null}
  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.")
  ```
</CodeGroup>

## Choose the right primitive

| Primitive                       | Use it when                                                           | What Agno handles                                                  |
| ------------------------------- | --------------------------------------------------------------------- | ------------------------------------------------------------------ |
| [Agent](/agents/overview)       | One model-driven program can own the task                             | Context, tool calls, sessions, memory, knowledge, and guardrails   |
| [Team](/teams/overview)         | The task benefits from specialist roles or dynamic delegation         | Coordination, routing, broadcast, task lists, and nested teams     |
| [Workflow](/workflows/overview) | The process needs repeatable steps, branches, loops, or parallel work | Control flow across agents, teams, functions, and nested workflows |

## Add what your use case needs

### Model and tools

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

### Memory and context

| Capability                                       | What it adds                                                     |
| ------------------------------------------------ | ---------------------------------------------------------------- |
| [Storage](/database/overview)                    | Session and application data in a supported database             |
| [Sessions](/sessions/overview)                   | Multi-turn sessions with summaries, history, and metrics         |
| [State](/state/overview)                         | State your agents can read and update mid-run                    |
| [Memory](/memory/overview)                       | Persistent user facts and preferences                            |
| [Knowledge](/knowledge/overview)                 | Search over documents, URLs, and databases                       |
| [Learning](/learning/overview)                   | Agents that improve over time from feedback and outcomes         |
| [Compression](/compression/overview)             | Keep long sessions inside the model's context window             |
| [Context Providers](/context-providers/overview) | Inject live data from Calendar, Gmail, Drive, GitHub, Slack, MCP |
| [Dependencies](/dependencies/overview)           | Inject runtime values into prompts                               |

### Control and safety

| Capability                          | What it adds                                          |
| ----------------------------------- | ----------------------------------------------------- |
| [Guardrails](/guardrails/overview)  | Validate input and output                             |
| [Hooks](/hooks/overview)            | Pre-run and post-run callbacks                        |
| [Human-in-the-Loop](/hitl/overview) | Pause runs for approval, input, or external execution |

### Operations

| Capability                                             | What it adds                                     |
| ------------------------------------------------------ | ------------------------------------------------ |
| [Background execution](/background-execution/overview) | Long-running runs that don't block your API      |
| [Evals](/evals/overview)                               | Measure accuracy, performance, and reliability   |
| [Observability](/observability/overview)               | OpenTelemetry tracing into your own database     |
| [Scheduler](/scheduler/overview)                       | Run agents and workflows on a recurring schedule |

## From SDK to platform

Register the same agents, teams, and workflows with AgentOS to run them behind a FastAPI application. AgentOS provides REST APIs and runtime support for persistence, authorization, tracing, background execution, scheduling, and interfaces.

## Where to start

<CardGroup cols={2}>
  <Card title="Build your first agent" icon="rocket" iconType="duotone" href="/sdk/setup">
    Install Agno, configure a model, and run an agent locally.
  </Card>

  <Card title="Run on AgentOS" icon="server" iconType="duotone" href="/agent-os/introduction">
    Serve your agents, teams, and workflows through an API.
  </Card>
</CardGroup>