AIToolScan

Kilo Code — the open-source AI coding agent for IDE, CLI and cloud.

Kilo Code is a model-agnostic agentic engineering platform: one open-source coding agent that lives in your VS Code, your JetBrains IDE, your terminal, a desktop app, a browser tab, a Slack channel and a cloud runner. The GitHub repository sits at roughly 27,700 stars and 3,300 forks under the MIT license, and the company behind it — founded by Scott Breitenother and GitLab co-founder Sid Sijbrandij — was acquired by Anaconda on July 15, 2026. Anaconda’s stated reason is enterprise control: one place to see what every agent in the organisation is doing, on which budget, and over which data.

The pitch in one line: 500+ models from 60+ providers, zero inference markup, bring your own keys, run local models, and read the agent’s own source code. This is not a chat box with an agent bolted on. It is a real agent runtime with Plan, Code, Debug and Ask modes, sub-agents, parallel isolated git worktrees, MCP servers, skills, slash commands, granular per-tool permissions, and a hosted cloud tier — all driven by the same client code.

Where it actually runs

Everything shares the same configuration model: kilo.json for settings, .kilo/ for project commands, agents and skills, AGENTS.md for durable instructions, and MCP servers for external tools. The CLI package lives under packages/opencode in the same repository, so the OpenCode lineage is visible in the source tree.

The agent model — and what makes it different

• Four first-class modes, not one chat box.Ask answers questions about the codebase, Plan produces a structured plan before a single line is written, Code executes, and Debug reads the error, traces the cause and proposes the fix. You can also write your own agents as Markdown with YAML frontmatter, giving each one its own model, prompt, tool allowlist and colour. Mode switching is a single keystroke, so context changes do not require switching tools.
• Sub-agent delegation. Code, Plan and Debug can hand isolated pieces of work to Explore (read-only codebase search), General (multi-step execution) or a custom sub-agent, and collect the results back. Each sub-agent gets its own context window, so a large refactor does not have to fit in one thread.
• Agent Manager and parallel worktrees. Inside VS Code, the Agent Manager coordinates several sessions in parallel, each in its own git worktree on its own branch, with setup and run scripts, a Run button for dev servers, and native pull-request support including live PR status. This is the piece that makes “run three agents on three branches at once” a first-class workflow rather than a collection of terminal tabs.
• MCP, skills and slash commands. MCP servers are configured per project or globally, with their own per-tool permission rules, so a GitHub MCP server can be set to ask on writes and allow on reads. Skills are Markdown files with frontmatter that load specialist instructions on demand. Slash commands become reusable prompts, and @file plus shell substitution pull context straight into a prompt.
• Permissions as a first-class config. read, edit, bash, webfetch, task and friends each take allow, ask or deny, and edit permissions can be scoped by glob pattern — src/** allowed while *.lock is denied. A sandboxed read-only run stays read-only, which is the part most “autonomous” agents get wrong.
• Auto Model routing. Instead of picking a model per task, you pick a tier — Free, Efficient or Frontier — and Kilo routes underneath using live session classification. Efficient is session-aware, Frontier routes to the newest and most capable paid models, Free picks the best free and experimental options currently available. No silent model switching: what was chosen is visible.

Model freedom — the actual differentiator

Almost every other commercial coding agent is also a subscription to one vendor’s opinion of which models you should be allowed to use. Kilo is built the other way round.

• Kilo Gateway. Hosted inference across 500+ models from 60+ providers at exact provider rates with zero markup. The Gateway also routes Auto Model, and credits are topped up only when needed.
• Bring your own keys. Anthropic, OpenAI, Google, Azure, AWS Bedrock and others can be configured directly, and BYOK works across the agent workflows rather than only in chat.
• Local models. Ollama and LM Studio are supported, and Kilo Desktop ships a managed local model server you can import GGUF files into. Local inference keeps prompts away from hosted providers — although the documentation is explicit that this does not make the whole application offline or air-gapped.
• Kilo Pass. An optional credit subscription from $19/month (Starter $19, Pro $49, Expert $199) that adds up to 50% bonus credits, so the effective cost of a model falls below list price.
• Free models, ranked in public. Kilo publishes a leaderboard, an inference leaderboard, a token race and KiloBench, so you can see which model is actually cheapest and fastest per token rather than guessing.

And because the VS Code extension, the JetBrains plugin and the CLI are all MIT-licensed source you can read, fork and self-host, the prompt, the context assembly and the tool routing are inspectable. The Gateway and Cloud backend are source-available under a separate repository licence, with security and abuse-protection code deliberately excluded — a boundary Kilo states plainly instead of claiming the whole platform is open.

How it compares with the other coding agents

All rows below are drawn from the vendors’ own current pricing and feature documentation, cross-checked against Kilo’s published comparison pages (reviewed October 19, 2026). Where a product does not document a capability, that is written as “not documented” rather than “no” — the difference matters.

Against Cursor. Cursor is the better editor. Tab is editor-native and excellent, the local/cloud delegation is cohesive, and the desktop app is a genuine full IDE. Kilo is the better agent layer: it starts as a plugin in the editor you already chose, 500+ models are available instead of a Grok-and-Composer pool with third-party billing on top, local models are supported, and the client is MIT source you can read. If you want an agent-first editor and do not care which model runs it, Cursor wins. If you want to choose the model per task and keep the editor you like, Kilo wins.

Against Devin Desktop (formerly Windsurf). Renamed on June 2, 2026. Devin Desktop keeps the full Windsurf-derived IDE plus an Agent Command Center, first-party parallel delegation with managed Devins and Arena, and a local-to-cloud handoff. Kilo trades that polished IDE for an open client, a documented provider catalogue, local inference, and a much lower team seat. Worth noting: Devin Local runs the agent against your local files — that is local execution, not local inference.

Against GitHub Copilot. Copilot is deeply wired into issues, pull requests, Actions, security alerts and policy, and covers a much wider IDE matrix including Visual Studio, Eclipse, Xcode and Neovim. That integration is not something Kilo can or wants to match. But Copilot is also a fixed-fee subscription migrating to usage-based AI Credits, its model catalogue is GitHub-curated, and its current CLI licence restricts modification. If your organisation already runs GitHub Enterprise Cloud and Actions as the control plane, Copilot is the natural choice. If the constraint is “do not let one vendor decide my model and my bill”, Kilo is cheaper and more open.

Against Claude Code. Claude Code has the deepest Anthropic-native ecosystem — subagents, hooks, plugins, skills, MCP packaging and the Agent SDK — and a subscription that is bundled with Claude Pro and Max. Kilo covers the same functional surface (custom agents, subagent delegation, plugins, hooks, skills, MCP) but lets you use any model family, adds local inference, and its clients are open source. Claude Code is the better choice if you have standardised on Claude; Kilo is the better choice if you want to benchmark Claude against other models on your own tasks and switch per task.

Against Cline and the open-source agent family. This is where the lineage is clearest. Cline, Roo Code and Kilo all come from the same VS Code extension tradition, and the differences now are about who is still shipping. Roo Code was discontinued on May 15, 2026 and its repository is archived read-only. Cline remains available. Kilo is the option in that family that has a company behind it, a maintained JetBrains plugin, a terminal client, a cloud tier and a commercial entity with an enterprise product. If you are on Cline, Kilo is the migration path that adds surfaces rather than taking features away; note that Roo’s exported settings can contain plaintext API keys, so rotate anything you carry across.

Against Tabnine and Continue. These are the enterprise-governance and self-hosting ends of the market. Tabnine is a managed platform with an enterprise security posture and a narrower model set; Continue is a self-hostable open-source assistant with a BYOK-first philosophy. Both are narrower than Kilo on agent autonomy. Continue in particular is the closer ideological sibling — open client, your own keys — where Kilo adds the hosted 500-model catalogue, the cloud agent tier and the parallel worktree manager. Replit and Antigravity sit in a different category entirely: an AI-native app-building environment and a Google-built agentic IDE, not a general coding-agent client.

What it genuinely does better

• Model choice is the product, not a settings page. 500+ hosted models at provider rates with zero markup, BYOK across every agent workflow, local models through Ollama or LM Studio, and Auto Model routing by cost tier. Cursor and Claude Code both restrict the model pool; Copilot curates one. Kilo is the only one of the group where the model is a first-class, continuously variable choice.
• You can read the agent. The VS Code extension, the JetBrains plugin and the CLI are MIT-licensed and on GitHub at ~27.7k stars. The prompt, the context window and the tool decisions are inspectable, and there is no silent model switching. For a tool that writes your code, that is a materially different trust posture from a proprietary product.
• The cheapest seat in the group. Individual platform access is free, Teams is $15/user/month, and Gateway inference is billed at the provider rate with no platform markup. The nearest rivals start at $19–$20 per seat and add third-party model surcharges on top ($0.25 per million tokens on Cursor Teams and Enterprise, for example). Cloud compute is billed separately and honestly: Code Review $0.33/hour, Cloud Agent $0.60–$1.20/hour, charged per second with no minimum.
• A real editor-agnostic agent. Kilo works in VS Code, in JetBrains, in a plain terminal, in a browser, in Slack, and on a phone, with the same configuration and the same agent. Cursor, Copilot and Devin Desktop all make you adopt their surface. You can keep your editor and keep your terminal, and hand work between them.
• Parallel work that is actually isolated. One git worktree per agent session, with setup and run scripts, a Run button, and native PR creation and status. Most “parallel agents” in other tools are parallel chats that share one working directory and corrupt each other; worktree-per-session is the part that actually holds up.
• Desktop for code and data. Kilo Desktop is the only offering in this group that puts the agent next to interactive Python notebooks, managed conda environments and a built-in local model server in one window. It is also the reason Anaconda bought the company — the Python and data-science side is where their distribution already lived.
• An actual enterprise product. SSO, OIDC and SCIM, audit logs, model and provider allowlists, agent sandboxing, sub-organisation budgets, EU inference and compute, AWS Marketplace, and SLA commitments. The Copilot and Cursor comparison pages both point out that the equivalent controls sit in a different tier of their own pricing ladders.

Honest limits

• Desktop is beta, and it is not an IDE. Kilo Desktop is an agent workspace that runs the CLI engine — chat, files, git, terminals, notebooks, conda, local inference. It is not a replacement for a full editor, and its local model server, notebooks and conda environments all require a signed-in Kilo account. macOS requires Apple Silicon.
• Local inference is not offline operation. The documentation states plainly that local inference keeps prompts away from hosted model providers but does not make the application air-gapped; hosted features and connected tools have their own data flows.
• The cloud agent has a 15-minute message limit. Long jobs have to be broken into steps, and webhook and scheduled triggers are still in beta. Local tools and MCP support should not be assumed to behave identically in the hosted environment.
• BYOK does not remove cloud compute charges. If you use Cloud Agents or hosted Code Review, you pay the compute fee on top of your own provider bill. A 5% processing fee also applies to card purchases of credits, including Kilo Pass top-ups — seat subscriptions are excluded.
• “Open” is component-scoped. The three clients are MIT. The Gateway and Cloud backend are source-available under a separate licence with security and abuse-protection code excluded, and Desktop’s own licence is not separately verified as MIT. You can self-host the client; you cannot self-host the whole hosted platform as though it were one package.
• Model capability is uneven. A 500-model catalogue does not mean every model can do every thing. Tool-calling, tool support and context limits vary by model, and a large catalogue also means you have to do the evaluation yourself — which is exactly what the leaderboard, the token race and KiloBench exist for, but they are not a substitute for testing on your own repository.
• Local model quality depends on your hardware. Desktop’s local server imports GGUF files, but which models are usable, and whether they can drive tool calls at all, is a function of VRAM and of the model’s own tool-use training. Expect to use local inference for cheap classification and autocomplete far more than for hard refactors.
• Everything is still moving. The product shipped Kilo Autocomplete, Parallel Agents, Kilo Sessions, Cloud Agents, Code Review, Voice Prompting and the Team AI Dashboard in a single six-week window, and Desktop is labelled beta. Plan and Debug agents, hooks and plugin manifests are documented, but plugin and manifest formats are not portable one-for-one from Cline or Roo, so migration means re-creating and reviewing configuration rather than importing it.

Who should pick it

Pick Kilo if you want one agent that works in every surface you use, if model choice and cost control matter to you, if you need to read or fork the client, or if you need parallel agents that do not step on each other. Pick Cursor if you want a single polished editor and accept its model pool. Pick GitHub Copilot if GitHub Enterprise and Actions are already your governance plane. Pick Claude Code if your organisation has standardised on Claude and values its plugin ecosystem. Pick Cline if you want a single-client VS Code agent with no account and no hosted tier. Pick Tabnine for managed enterprise governance over a narrower model set, and Continue for a self-hosted BYOK assistant.

There is also a straightforward migration path into the open-source agent family: Roo Code was discontinued in May 2026, its settings export can contain plaintext API keys, and Kilo documents a reviewed conversion from .roo/ rules and .roomodes into .kilo/ configuration rather than a blind import.

Links

• Website: https://kilo.ai
• Source code (MIT): https://github.com/Kilo-Org/kilocode
• Documentation: https://kilo.ai/docs
• Pricing: https://kilo.ai/pricing
• Component licences and open-source scope: https://kilo.ai/open
• Install (VS Code, JetBrains, CLI, Desktop): https://kilo.ai/install
• CLI: https://kilo.ai/cli
• Kilo Gateway (500+ models, zero markup): https://kilo.ai/gateway
• Auto Model routing: https://kilo.ai/auto-model
• Model leaderboard and KiloBench: https://kilo.ai/leaderboard
• Cloud Agents: https://kilo.ai/cloud
• Enterprise: https://kilo.ai/enterprise
• Blog: https://blog.kilo.ai
• Anaconda acquisition announcement (July 15, 2026): https://www.anaconda.com/press/anaconda-acquires-kilo-code