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

# Next Steps

> Go beyond agents: teams, workflows, scheduled tasks, and Slack interfaces.

You have a deployed agent platform with two reference agents, evals, and JWT auth. The sections below cover the moves that turn it into a real product: teams and workflows, scheduled tasks, and connecting to Slack.

## Going beyond agents

Rule of thumb: **agents for open questions, teams for routing, workflows for processes.** Most of your platform will be agents. A few will be teams or workflows.

| Pattern      | Use it when                                                                | Reference                                 |
| ------------ | -------------------------------------------------------------------------- | ----------------------------------------- |
| **Agent**    | A single LLM with tools and instructions can handle the request.           | [Agents overview](/agents/overview)       |
| **Team**     | The right specialist isn't known up front. A leader routes or coordinates. | [Teams overview](/teams/overview)         |
| **Workflow** | The process needs to run the same way every time. Determinism matters.     | [Workflows overview](/workflows/overview) |

Teams come in three modes:

| Mode           | Behavior                                                           |
| -------------- | ------------------------------------------------------------------ |
| **Coordinate** | A leader plans the work, calls the right specialists, synthesizes. |
| **Route**      | A router picks one specialist to handle the request.               |
| **Broadcast**  | Every specialist runs in parallel; you aggregate.                  |

## Scheduled tasks

The scheduler is on by default in `app/main.py`:

```python theme={null}
agent_os = AgentOS(
    name="AgentOS",
    scheduler=True,
    ...
)
```

Schedule any agent or workflow on a cron. Common patterns:

| Use case              | Example                                                            |
| --------------------- | ------------------------------------------------------------------ |
| **Maintenance**       | Purge sessions older than 90 days. Vacuum Postgres tables.         |
| **Proactive runs**    | Every weekday morning, summarize overnight news and post to Slack. |
| **Catch regressions** | Run `python -m evals` weekly against production agents.            |

See [scheduling](/features/scheduling) for the cron API.

## Connect to interfaces

Your agents should be available where your users are. Slack threads. Discord channels. Telegram for the field team. Or a custom UI inside your product.

The pattern is the same for each. Expose the agent via an interface in `app/main.py`:

```python theme={null}
from agno.os.interfaces.slack import Slack

interfaces: list = []
if SLACK_BOT_TOKEN and SLACK_SIGNING_SECRET:
    interfaces.append(
        Slack(
            agent=code_search,
            streaming=True,
            token=SLACK_BOT_TOKEN,
            signing_secret=SLACK_SIGNING_SECRET,
            resolve_user_identity=True,
        )
    )

agent_os = AgentOS(
    ...
    interfaces=interfaces,
)
```

`resolve_user_identity=True` ties the Slack user to the same `user_id` they have in the AgentOS UI, so sessions follow the person across surfaces.

| Interface         | Reference                                                        |
| ----------------- | ---------------------------------------------------------------- |
| Slack             | [Slack interface](/agent-os/interfaces/slack/introduction)       |
| Telegram          | [Telegram interface](/agent-os/interfaces/telegram/introduction) |
| WhatsApp          | [WhatsApp interface](/agent-os/interfaces/whatsapp/introduction) |
| Custom UI / AG-UI | [AG-UI interface](/agent-os/interfaces/ag-ui/introduction)       |
| Agent-to-agent    | [A2A interface](/agent-os/interfaces/a2a/introduction)           |
| All interfaces    | [Interfaces overview](/agent-os/interfaces/overview)             |

## Add tools to an agent

Agno ships 100+ toolkit integrations. See the [full toolkit reference](/tools/toolkits/overview).

```python theme={null}
from agno.tools.slack import SlackTools
from agno.tools.googlesheets import GoogleSheetsTools

my_agent = Agent(
    ...
    tools=[
        SlackTools(),
        GoogleSheetsTools(),
    ],
)
```

Each toolkit reads its credentials from environment variables. Add them to `.env` for local and to `.env.production` for Railway, then `./scripts/railway/env-sync.sh`.

## Swap model providers

Switch from OpenAI to Anthropic:

1. Set `ANTHROPIC_API_KEY` in `.env` and `.env.production`.
2. Add `anthropic` to `pyproject.toml`.
3. Update the agent's `model=`.
4. Run `./scripts/generate_requirements.sh && docker compose up -d --build`.

```python theme={null}
from agno.models.anthropic import Claude

my_agent = Agent(
    ...
    model=Claude(id="claude-sonnet-4-5"),
)
```

The same pattern works for Google (`google-genai`), Mistral (`mistralai`), and the other [supported providers](/models/overview).

## Keep the repo coherent

As you ship more agents, configuration drifts, env vars rot, and new agents miss imports. The template repo ships a fourth Claude Code prompt for the recurring sweep:

```
Run docs/review-and-improve.md
```

It auto-fixes mechanical drift (stale paths, missing `example.env` entries, agents on disk not registered in `app/main.py`) and surfaces the rest as a punch list. Run it before public releases and periodically during active development.

## Going deeper

| To learn                            | See                                                                                                    |
| ----------------------------------- | ------------------------------------------------------------------------------------------------------ |
| The full AgentOS feature set        | [Demo OS](/demo-os/overview)                                                                           |
| How knowledge and Agentic RAG work  | [Knowledge](/knowledge/concepts/overview)                                                              |
| How MCP integrates with Agno        | [MCP](/agent-os/mcp/mcp)                                                                               |
| Comparable templates                | [Scout](/tutorials/scout/overview), [Dash](/tutorials/dash/overview), [Coda](/tutorials/coda/overview) |
| Building a fully custom AgentOS app | [AgentOS Runtime](/features/runtime)                                                                   |