> ## 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.
# AgentOS on Azure Container Apps
> Run AgentOS locally using Docker and deploy to production on Azure Container Apps.
AgentOS is a secure, scalable platform for running agents. The [agentos-azure](https://github.com/agno-agi/agentos-azure) codebase runs AgentOS locally using Docker and deploys to production on Azure Container Apps. It comes with:
* **2 platform agents** that build and run the platform for you. **Agent Builder** creates agents, teams, and workflows. **Platform Manager** monitors and manages the platform.
* **5 [skills](/deploy/templates/improve-agents)** that let coding agents build, test, and improve the platform for you.
Because the trace data, agent code, evals, and system logs all live in one place, the platform can inspect and improve itself automatically.
Everything runs in your own Azure subscription, and one script provisions the network, database, registry, and app into a single resource group.
## Get started
The fastest way to get started is using a coding agent. Copy the prompt below into Claude Code, Cursor or Codex and it'll take you from zero to a running platform.
Prefer to drive yourself? Follow the manual steps below.
## Manual setup
**Prerequisites:** [Docker](https://www.docker.com/get-started/) installed and running. An [OpenAI API key](https://platform.openai.com).
```bash theme={null}
git clone https://github.com/agno-agi/agentos-azure.git agentos
cd agentos
cp example.env .env
```
Edit `.env` and set `OPENAI_API_KEY`.
```bash theme={null}
docker compose up -d --build
```
The first build takes a few minutes. Confirm the API is available at [localhost:8000/docs](http://localhost:8000/docs).
```bash theme={null}
./scripts/mcp_check.sh
```
Prints `MCP OK` with the tool count and a real agent answer through the MCP endpoint.
1. Open [os.agno.com](https://os.agno.com) and sign in.
2. Click **Connect OS**, enter `http://localhost:8000`, and name it **Local AgentOS**.
1. Chat with **Agent Builder**: "Build an agent that tracks AI news and writes a daily brief". Go through the agent development process.
2. Once created, click **Refresh** on the top right, pick the new agent from the **Agents** dropdown, and ask: "What's new with Anthropic?"
3. Ask **Platform Manager**: "How healthy is the platform?" It answers from eval history, deployment checks, schedules, and the agent you just built.
At this point, your AgentOS is running locally.
## Connect your frontends
| Frontend | How |
| --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| MCP clients on your machine | `uvx agno connect` auto-detects Claude Code, Claude Desktop, Codex, and Cursor and registers `http://localhost:8000/mcp`. Verify from the app: "can you access my agentos mcp?" |
| AgentOS UI | [os.agno.com](https://os.agno.com) → **Connect OS** → `http://localhost:8000`. |
| claude.ai and ChatGPT | Hosted sessions can't reach localhost. Deploy to production first, then add `https:///mcp` as a custom connector and approve the consent page with the `MCP_CONNECT_SECRET` that `up.sh` generates. |
| Slack | Set `SLACK_BOT_TOKEN` and `SLACK_SIGNING_SECRET`. See [Slack setup](/deploy/interfaces/slack/overview). |
| Your product | Call the AgentOS REST API with 80+ endpoints. Browse them at `/docs`. |
## Deploy to production
**Prerequisites:** [Azure CLI](https://learn.microsoft.com/cli/azure/install-azure-cli) installed and `az login` completed. Docker running; the image is built locally.
```bash theme={null}
cp .env .env.production
```
Edit `.env.production` with production values: a different OpenAI key, production-only credentials, a different Slack workspace.
```bash theme={null}
./scripts/azure/up.sh
```
The first run takes 15-20 minutes (Postgres Flexible Server is the long pole) and creates everything inside one dedicated resource group, `agentos` by default: a VNet with private DNS, a container registry with the locally built image, PostgreSQL 17 Flexible Server with private access and pgvector allowlisted, the Container Apps environment, and the `agent-os` app pinned to exactly one replica so the in-process scheduler never runs twice. The app URL is only known after create. Once the app is up, the script writes `AGENTOS_URL` back to your env file so scheduled jobs reach the platform. It also generates `MCP_CONNECT_SECRET`, the OAuth consent secret for connecting chat apps, into the same file.
The script pauses for a `JWT_VERIFICATION_KEY`. Token-Based Authorization is on by default and without a verification key or a `JWT_JWKS_FILE`, the platform refuses to serve production traffic.
1. Open [os.agno.com](https://os.agno.com), click **Connect OS** → **Live**, enter your Container Apps URL, and name it **Live AgentOS**.
2. Go to **Settings** → **OS & Security** and turn on **Token-Based Authorization (JWT)**.
3. Copy the public key and paste the full PEM into the `up.sh` prompt. The script saves it to your env file, stores it as a Container Apps secret, and applies it together with `AGENTOS_URL` in a single second revision.
If your env file already sets `JWT_JWKS_FILE`, the script skips the pause and applies it in the same revision. If you skip the prompt, add `JWT_VERIFICATION_KEY` or `JWT_JWKS_FILE` to `.env.production` later and run `./scripts/azure/env-sync.sh`.
Live AgentOS connections are a paid feature. Use code `PLATFORM30` for one month off.
Re-run `uvx agno connect`, this time pointed at your deployed domain:
```bash theme={null}
uvx agno connect --url https://
```
For claude.ai and ChatGPT on the web: add `https:///mcp` as a custom connector in the chat app's connector settings. Leave the form's optional OAuth fields (client ID / client secret) empty. Click **Connect** and, on the consent page, enter the `MCP_CONNECT_SECRET` that `up.sh` generated during deploy (saved in `.env.production`).
```bash theme={null}
az containerapp logs show -g agentos -n agent-os --follow
```
The script prints your app URL. Give the revision a couple of minutes to converge, then open `https:///docs` to confirm the API is serving.
Your AgentOS is live on Azure Container Apps.
### Redeploy after code changes
```bash theme={null}
./scripts/azure/redeploy.sh
```
### Sync environment variables
```bash theme={null}
./scripts/azure/env-sync.sh
```
### Tear down
```bash theme={null}
./scripts/azure/down.sh
```
Deletes the entire resource group, `agentos` by default: the `agent-os` app, the Container Apps environment, the Postgres server and all its data, the container registry, the VNet, and the private DNS zone. The script lists the group's resources and asks you to type the group name before deleting. It also comments out the stale `AGENTOS_URL` in your env files so a future `up.sh` derives a fresh domain; custom domains are left alone.
## Next steps
Skills to create → improve → evaluate your platform using coding agents.
Commands, environment variables, troubleshooting.