# LiteLLM Agent Control Plane LiteLLM Agent Control Plane is an [[Open Source]], self-hosted service that sits on top of existing agent runtimes and gives a team one place to create, run and schedule [[AI Agents]]. Their pitch: "1 place to call all your agents". You pick a runtime, create an agent, and everyone uses the same UI and API, whatever runs underneath. The docs call it **LiteLLM Agent Platform** (LAP); the repository is named "agent control plane". Same thing. It comes from **LiteLLM Labs**, a GitHub organization that describes itself as "experimental projects from the creators of [[LiteLLM]]". That word, experimental, matters a lot here (more on that below). ## Why it exists Agent runtimes multiplied in 2026: [[Claude Managed Agents]], [[OpenCode]], [[Hermes Agent]], [[OpenClaw]], Cursor's Agents API, LangChain's Deep Agents... Each has its own API, its own credentials and its own console. LAP applies the [[AI Gateway]] idea one level up. LiteLLM already sits between your code and 100+ model providers; LAP sits between your team and the agent runtimes. The README lists what it manages: - **One API across runtimes**: create and run agents the same way, whatever the runtime - **Access**: developers run agents without Bedrock or Anthropic console access; provider keys stay encrypted in the platform and are injected per request - **Sessions**: persistent agent sessions across runs - **CRON schedules**: run agents on a schedule - **Memory**: agents keep context across sessions ## Supported runtimes and channels - **Runtimes**: Claude Managed Agents (built in), Cursor Agents API, OpenCode, OpenClaw, Deep Agents, Hermes Agent. The docs add [[Google Antigravity|Gemini Antigravity]], Pydantic Deep Agents and Elastic Agent Builder - **Channels**: the web UI, the REST API, webhooks, Slack, Microsoft Teams and Google Chat - **Tools**: you attach tools and skills to an agent in the UI; MCP servers go through a built-in [[Model Context Protocol (MCP)]] proxy The interesting design choice: Anthropic's Managed Agents API is the common contract. Sessions stream events in the Managed Agents SSE shape (`session.status_running`, `agent.message`, `agent.tool_use`, `session.status_idle`...), and third-party runtimes such as Pydantic Deep Agents are registered as "Anthropic Managed Agents-compatible" runtimes. So LAP is, in effect, a Managed Agents-style API you host yourself, with adapters for the other runtimes. ## Architecture It's deliberately small: **one service plus [[PostgreSQL]]**. - A single [[Docker]] image runs the `lite` service: a [[Rust]] binary (the crate is called `litellm-rust`) plus a [[Next.js]] dashboard - `lite` serves the UI, the REST API, the LiteLLM-compatible gateway routes (`/v1/messages`, `/v1/responses`, `/v1/models`), the MCP proxy, the Slack callbacks and the session event streams, all from one process - Postgres stores agents, sessions, credentials, runtime harnesses, schedules, memory and settings - Template runtimes (OpenCode, OpenClaw, Deep Agents, Hermes) are optional Docker Compose profiles for local use The request flow is simple: browser, API client or Slack hits `lite`, `lite` reads or writes Postgres, then calls the model provider, MCP server or agent runtime, and streams the events back. ## How it relates to LiteLLM It is NOT the Python LiteLLM proxy with an agent tab bolted on. It's a separate Rust reimplementation that borrows LiteLLM's conventions: - the same `config.yaml` shape (`model_list`, `general_settings`, `os.environ/NAME` references) - the same `LITELLM_MASTER_KEY` master key, plus per-user virtual keys with budgets, model restrictions and expiry - MCP servers declared in "the same dict-keyed format as LiteLLM" The docs are upfront about the gaps compared to the real thing. Only Anthropic was in the database credential catalog when the deployment guide was written. The router accepts exactly one `provider/*` wildcard route. The MCP proxy lacks multi-server aggregation, OAuth2 and AWS SigV4 auth, and the SSE and stdio transports (HTTP only). And if no master key is configured, auth is simply disabled. Meanwhile, mainline LiteLLM (BerriAI/litellm) moved in the same direction. Its README now says "Rust core with Python SDK", and it ships `litellm.agent()`, which runs [[Claude Code]], Codex, OpenCode or Deep Agents against any model routed through your gateway, plus an A2A agent gateway. My reading is that LiteLLM Labs is where these ideas get prototyped before the useful parts land in the main project, but no source says so explicitly. ## Install You need Docker Desktop. ```bash docker compose --profile opencode up ``` Then open `http://localhost:4000` and sign in with the master key (`sk-local` by default). Compose starts LAP, Postgres and the OpenCode template runtime, and registers `local-opencode` in the UI. `docker compose up` starts only LAP and Postgres; other profiles are `deepagents`, `hermes` and `openclaw`. Add your provider keys in **Settings** before running an agent against a hosted model. You can also build from source (`cargo run --release -- serve --config config.yaml`) or deploy the image on Render; the repo has a guide for that. ## License and maturity - **License**: [[MIT License|MIT]] (copyright 2026 LiteLLM Labs) - **Created**: May 7, 2026, first as `BerriAI/litellm-agent-platform` (the old URL now redirects) - **Versioning**: crate version 0.1.0, no releases, no tags - **Activity**: 1,359 commits in total, 1,247 of them in May 2026. About 98% come from two BerriAI accounts. The last commit landed on June 20, 2026. Community pull requests opened in August and September (Codex and Devin runtimes, MCP fixes, new providers) are still unmerged So, a burst of six weeks, then silence. The repository isn't archived, but I'd treat it as a reference implementation and a source of ideas rather than something to run in production. Since then, LiteLLM Labs' most active project has been `litellm-relay` (routing Claude Desktop, Claude Code, Codex and "shadow AI" tools through a LiteLLM gateway). Community discussion is thin. The May 2026 Hacker News submission got 3 points and no comments. In an August "What are you working on?" thread, one commenter pointed to "LiteLLM's play" as a sign that agent runtime platforms had become the hot space, and argued that the winning angle would be self-hosting and provenance. ## Alternatives - **[[Claude Managed Agents]] directly**: if Claude is your only runtime, LAP adds a layer for little benefit - **`litellm.agent()` in mainline LiteLLM**: an SDK call rather than a platform, but maintained, and it routes agent traffic through the gateway you may already run (see [[LiteLLM Proxy Configuration]]) - **[[Paperclip (AI Agent Orchestration)]]** and **[[Multica]]**: also self-hosted and also bring-your-own-agent, but they organize agents around goals, tickets and org charts instead of exposing a runtime-neutral API - **The runtimes' own consoles**: fine for one team on one runtime; this whole category only pays off once you juggle several I like the core idea a lot. Treating agent runtimes the way LiteLLM treats model providers (one API, keys held centrally, budgets per user) is the obvious next layer for teams. But a v0.1.0 that stopped receiving commits in June isn't something I'd build on. Watch where the ideas land in mainline LiteLLM instead. ## References - GitHub repository and README: https://github.com/LiteLLM-Labs/litellm-agent-control-plane - Repository metadata via the GitHub API (license, dates, commit history, open issues and PRs), retrieved 2026-10-03 - Documentation: https://docs.litellm-agent-platform.ai (index: https://docs.litellm-agent-platform.ai/llms.txt) - Architecture: https://docs.litellm-agent-platform.ai/learn/architecture - Authentication: https://docs.litellm-agent-platform.ai/learn/auth - MCP support and limitations: https://docs.litellm-agent-platform.ai/learn/mcp - Quick start: https://docs.litellm-agent-platform.ai/quickstart - Claude Managed Agents runtime: https://docs.litellm-agent-platform.ai/runtimes/claude-managed-agents - OpenCode runtime: https://docs.litellm-agent-platform.ai/runtimes/opencode - Deployment guide (repo): https://github.com/LiteLLM-Labs/litellm-agent-control-plane/blob/main/deployment.md - Source layout (repo): https://github.com/LiteLLM-Labs/litellm-agent-control-plane/blob/main/src/README.md - License: https://github.com/LiteLLM-Labs/litellm-agent-control-plane/blob/main/LICENSE - LiteLLM Labs organization: https://github.com/LiteLLM-Labs - Mainline LiteLLM README (agent harnesses, A2A): https://github.com/BerriAI/litellm - LiteLLM agent harness docs: https://docs.litellm.ai/docs/harness - Hacker News submission (May 2026, as LiteLLM Agent Platform): https://news.ycombinator.com/item?id=48155595 - Hacker News "Ask HN: What are you working on? (August 2026)" comment on agent runtime platforms, found via the HN Algolia API: https://hn.algolia.com/api/v1/search?query=litellm%20agent&tags=comment ## Related - [[LiteLLM]] - [[AI Gateway]] - [[Claude Managed Agents]] - [[AI Agent Orchestration]] - [[AI Agent Harness]] - [[OpenCode]] - [[Hermes Agent]] - [[OpenClaw]] - [[Paperclip (AI Agent Orchestration)]] - [[Multica]] - [[Self-hosting]]