The Agent Client Protocol (ACP) is doing for AI coding agents what LSP did for language servers. Before LSP, every editor needed a custom integration for every language — Go support for VS Code, Go support for Sublime, Go support for Vim, all separate. LSP standardized the protocol, and suddenly one Go language server worked everywhere. ACP does the same thing for AI agents.
ANT speaks ACP natively. This means any editor that supports the Agent Client Protocol — Zed, JetBrains IDEs, Kiro, and more — can use Antbase as its AI backend. One configuration, 20,000+ models, intelligent routing. No per-editor integration needed.
What is ACP?
The Agent Client Protocol (agentclientprotocol.com) standardizes how code editors communicate with AI coding agents. It uses JSON-RPC over stdio (for local agents) or HTTP (for remote agents like ANT). Editors send prompts — "refactor this function", "explain this code", "write tests" — and agents stream responses back in real time.
The key insight: ACP separates the editor from the AI. Your editor doesn't need to know which model is running. It just sends a prompt via ACP, and the agent handles the rest. When the agent is ANT, "the rest" means classifying the prompt, scoring 20,000 models, selecting the optimal one, streaming the response, and failing over to another provider if needed.
Why ANT + ACP Changes Everything
Today, most ACP agents hardcode a single model — Claude, GPT-4, or whatever the developer configured. Every request goes to that model regardless of complexity. A simple docstring generation costs the same as a full module refactor.
When you point an ACP agent at ANT instead, every request gets classified and routed to the optimal model automatically. Inline completions go to fast, cheap models. Complex refactoring goes to Claude Opus. Experimentation uses free open-source models. You stop paying frontier-model prices for every keystroke.
- •Simple completion → ant:fast routes to fastest model, ~200ms, fractions of a cent
- •Code generation → ant:coder routes to best code model (Claude, GPT, DeepSeek Coder)
- •Architecture review → ant:reasoning activates chain-of-thought thinking
- •Learning/experimenting → ant:free uses Llama, Gemma, Qwen at zero cost
- •Critical code review → ant:best uses the absolute best model regardless of cost
Which Editors Support ACP?
- •Zed — Native ACP support built into the editor
- •JetBrains — IntelliJ, PyCharm, WebStorm, GoLand, all IDEs have ACP integration
- •Kiro — AWS-backed AI IDE with full ACP agent support
- •VS Code — Via ACP-compatible extensions (Cline, Continue, and others)
- •Neovim — Community ACP plugins available
- •Any future editor — ACP is an open standard, adoption is growing
Setting It Up
ANT's OpenAI-compatible API works with any ACP agent that uses the OpenAI SDK — which is the vast majority. Point your agent's base URL at Antbase and select a virtual model:
{
"provider": "openai-compatible",
"baseUrl": "https://antbase.ai/v1",
"apiKey": "your-ant-api-key",
"model": "ant:coder"
}That's it. Your ACP agent now has access to 20,000+ models across 30+ providers with intelligent routing, automatic failover, and cost optimization. Switch between ant:coder, ant:fast, ant:free, or ant:auto depending on your workflow.
The Bigger Picture
ACP solves the editor fragmentation problem — write one agent, run it everywhere. ANT solves the model fragmentation problem — one API, every model, intelligent selection. Together, they create a future where every developer has access to the best AI for every coding task, in every editor, without managing model configurations, provider accounts, or failover logic.
The AI coding landscape is converging on open protocols. MCP for tool access, ACP for editor-agent communication, and intelligent routing (ANT) for model selection. We're building toward a world where the developer just writes code — and the infrastructure handles everything else.
