# Agent SDK (/features/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.

<Step title="Set up your virtual environment">
  <CodeBlockTabs defaultValue="Mac">
    <CodeBlockTabsList>
      <CodeBlockTabsTrigger value="Mac">
        Mac
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="Windows">
        Windows
      </CodeBlockTabsTrigger>
    </CodeBlockTabsList>

    <CodeBlockTab value="Mac">
      ```bash
      uv venv --python 3.12
      source .venv/bin/activate
      ```
    </CodeBlockTab>

    <CodeBlockTab value="Windows">
      ```bash
      uv venv --python 3.12
      .venv\Scripts\activate
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</Step>

```bash
uv pip install -U agno openai sqlalchemy yfinance
```

<CodeBlockTabs defaultValue="Mac/Linux">
  <CodeBlockTabsList>
    <CodeBlockTabsTrigger value="Mac/Linux">
      Mac/Linux
    </CodeBlockTabsTrigger>

    <CodeBlockTabsTrigger value="Windows">
      Windows
    </CodeBlockTabsTrigger>
  </CodeBlockTabsList>

  <CodeBlockTab value="Mac/Linux">
    ```bash
    export OPENAI_API_KEY="your_openai_api_key_here"
    ```
  </CodeBlockTab>

  <CodeBlockTab value="Windows">
    ```powershell
    $Env:OPENAI_API_KEY="your_openai_api_key_here"
    ```
  </CodeBlockTab>
</CodeBlockTabs>

{/* Adjacent tab fences merge into one tab set; this keeps the two groups apart. */}

<CodeBlockTabs defaultValue="Agent">
  <CodeBlockTabsList>
    <CodeBlockTabsTrigger value="Agent">
      Agent
    </CodeBlockTabsTrigger>

    <CodeBlockTabsTrigger value="Team">
      Team
    </CodeBlockTabsTrigger>

    <CodeBlockTabsTrigger value="Workflow">
      Workflow
    </CodeBlockTabsTrigger>
  </CodeBlockTabsList>

  <CodeBlockTab value="Agent">
    ```python
    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.")
    ```
  </CodeBlockTab>

  <CodeBlockTab value="Team">
    ```python
    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?")
    ```
  </CodeBlockTab>

  <CodeBlockTab value="Workflow">
    ```python
    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.")
    ```
  </CodeBlockTab>
</CodeBlockTabs>

## Primitives [#primitives]

| Primitive                       | Description                                                                                             |
| ------------------------------- | ------------------------------------------------------------------------------------------------------- |
| [Agent](/agents/overview)       | Model-driven programs with tools and instructions                                                       |
| [Team](/teams/overview)         | Multiple agents working together as a team                                                              |
| [Workflow](/workflows/overview) | Orchestration across agents, teams, and functions with linear steps, loops, branches, and parallel work |

## Capabilities [#capabilities]

### Model and tools [#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 can 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 [#memory-and-context]

| Capability                                       | What it adds                                                             |
| ------------------------------------------------ | ------------------------------------------------------------------------ |
| [Storage](/database/overview)                    | Durability and persistence with supported database backends              |
| [Sessions](/sessions/overview)                   | Multi-turn session management with summaries, history, and metrics       |
| [State](/state/overview)                         | Session and agentic state agents can read and update mid-run             |
| [Memory](/memory/overview)                       | Store facts about each user and recall them in later conversations       |
| [Knowledge](/knowledge/overview)                 | Search over documents, URLs, and databases                               |
| [Learning](/learning/overview)                   | Agents that improve over time with learned behavior and decisions        |
| [Compression](/compression/overview)             | Compress tool call results to save context space                         |
| [Context Providers](/context-providers/overview) | Inject live data from Calendar, Gmail, Drive, Slack, Wiki, MCP, and more |

### Control and safety [#control-and-safety]

| Capability                          | What it adds                                                  |
| ----------------------------------- | ------------------------------------------------------------- |
| [Guardrails](/guardrails/overview)  | Input validation, PII detection, and prompt injection defense |
| [Hooks](/hooks/overview)            | Lifecycle hooks for input, output, and state                  |
| [Human-in-the-Loop](/hitl/overview) | Pause runs for approval, input, or external execution         |

### Operations [#operations]

| Capability                                             | What it adds                                                                  |
| ------------------------------------------------------ | ----------------------------------------------------------------------------- |
| [Background execution](/background-execution/overview) | Continue long-running work after the initial API request returns              |
| [Evals](/evals/overview)                               | Measure accuracy, performance, and reliability; agent-as-judge                |
| [Observability](/observability/overview)               | Tracing with Langfuse, Logfire, Arize, The Context Company, and 12+ providers |
| [Scheduler](/scheduler/overview)                       | Run agents, teams, and workflows on recurring schedules                       |

## Components [#components]

Agents, teams, and workflows become runnable **components** once you add their models, tools, state, and configuration. Code-defined components stay in Python. Components created in Studio or through the `/components` API use draft and published versions, with a `current` version that you can promote or roll back.

### Versioned components [#versioned-components]

When components are created via the API, they carry a versioned configuration. Published versions are immutable, and run requests accept a `version` parameter so you can pin clients to a specific version. A `current` pointer decides which version your production API serves: set it to a newer version to promote, or an earlier one to roll back.

Tune a component's instructions, model, or tools and publish the change as a new version. Promote the new version or roll back to an earlier version based on its results.

## Learn more [#learn-more]

<CardGroup cols="3">
  <Card title="SDK Introduction" icon="rocket" href="/sdk/introduction">
    Agents, teams, and workflows in pure Python.
  </Card>

  <Card title="Build Agents" icon="users" href="/agents/overview">
    Create agents with models, tools, and instructions.
  </Card>

  <Card title="Build Agent Platform" icon="layer-group" href="/agent-platform/overview">
    Assemble a full platform on the AgentOS runtime.
  </Card>
</CardGroup>