Kilo Code: An Open Source Coding Agent That Spans VS Code, JetBrains, and the CLI
Project brief: Kilo is the all-in-one agentic engineering platform. Build, ship, and iterate faster with the most popular open source coding agent.
At a glance
- What is it?
- Kilo Code is a TypeScript-based agentic engineering platform with a MIT license, offering a VS Code extension, JetBrains plugin, and CLI. It supports 500+ models with mid-task switching and zero markup, but its autonomous mode demands caution.
- Who is it for?
- Adopt Kilo Code if you want a vendor-neutral coding agent that works across VS Code, JetBrains, and CLI, with the freedom to switch models mid-task and pay provider rates directly. Avoid it if you need a fully offline tool or if your team cannot tolerate the security risks of autonomous mode.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository received new commits within the last day.
- What is it written in?
- Mainly TypeScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The Problem: Fragmented AI Coding Tools
Developers face a fragmented landscape of AI coding assistants. Some tools lock you into a single model provider. Others work only in one editor. Kilo Code addresses this by offering a unified agentic platform across VS Code, JetBrains, and a CLI. The README claims it is 'the open source coding agent for building with AI in VS Code, JetBrains, or the CLI.' The target user is a developer who wants one tool that follows them across their preferred environment, without being tied to a specific model. The platform supports 500+ models, including GPT-5.5, Claude Opus 4.7, and Gemini 3.1 Pro Preview, all at provider pricing. This breadth is the core value proposition: you pick the model that fits the task, and you pay the provider's rate with zero markup.
Architecture: A Fork of OpenCode with Editor Integration
The repository is primarily TypeScript, and the README reveals a key architectural fact: the CLI is a fork of OpenCode, enhanced to work within the Kilo platform. This means the CLI inherits OpenCode's terminal-based agent design, but Kilo adds its own layers. The platform includes a VS Code extension, a JetBrains plugin, and a web-based Cloud Agent. The codebase is organized into packages, including a dedicated `packages/kilo-jetbrains` directory for the JetBrains plugin. The extension likely communicates with the CLI or a shared agent core, though the README does not specify the exact data flow. What is clear is that the platform is modular: different agents (Code, Plan, Ask, Debug, Review) are switchable, and users can build custom agents. This modularity is a deliberate design choice, allowing users to tailor the agent's behavior to specific tasks.
Installation: Multiple Paths, One Command
Getting Kilo running is straightforward, with options for every environment. For VS Code, install the extension from the Marketplace or use the `vscode:extension/kilocode.kilo-code` link. For JetBrains, search 'Kilo Code' in `Settings → Plugins`. The CLI offers the most flexibility: you can install via npm (`npm install -g @kilocode/cli`), curl (`curl -fsSL https://kilo.ai/cli/install | bash`), pnpm, bun, Homebrew (`brew install Kilo-Org/tap/kilo`), or Arch Linux AUR (`paru -S kilo-bin`). After installation, simply run `kilo` in any project directory. The README also lists binary downloads for Windows, macOS, Linux, with notes about `x64-baseline` for older CPUs and `musl` for Alpine. This granularity shows attention to deployment diversity, but it also means you must choose the right asset for your system.
Agents: Specialized Roles for Different Tasks
Kilo ships with five built-in agents, each designed for a specific workflow. The Code agent is the default, implementing edits from natural language. The Plan agent designs architecture and writes implementation plans before any code is written, which is useful for complex tasks. The Ask agent answers questions about your codebase without touching files, ideal for exploration. The Debug agent troubleshoots issues, and the Review agent surfaces problems across performance, security, style, and test coverage. This separation of concerns is a practical approach: you do not need a single monolithic agent to do everything. Instead, you switch roles based on the task. The README mentions custom agents, but the details are in the docs, which are not provided. Based on this, the agent system is a strength, but the lack of detail on custom agent creation is a gap for advanced users.
Autonomous Mode: A Double-Edged Sword
The README highlights `kilo run --auto` for CI/CD pipelines. This mode disables all permission prompts, letting the agent execute any action without confirmation. The example command is `kilo run --auto "run tests and fix any failures"`. This is powerful for automation, but it is also a security risk. The README explicitly warns: 'Only use it in trusted environments.' This is a genuine limitation: if you run this in an untrusted environment, the agent could execute arbitrary commands. The self-checking feature, where the agent reviews and corrects its own work, mitigates some errors, but it does not protect against malicious inputs or unintended side effects. For teams considering autonomous mode, the trade-off is clear: speed versus control. You must have strict CI/CD safeguards in place before enabling `--auto`.
Model Flexibility and Cost
A central feature is the ability to pick from 500+ models and switch between them mid-task. This is a differentiator. Most coding assistants are tied to a single provider. Kilo lets you match latency, cost, and reasoning to the job. For example, you might start with a fast model for simple edits and switch to a reasoning-heavy model for complex debugging. The README states 'no API keys required to start,' which lowers the barrier to entry. However, the zero-markup pricing model means you pay the provider's rate directly, so costs can escalate if you use expensive models. The README does not specify how the platform handles rate limits or billing across providers. This is a point to verify before adoption, especially for teams with strict budget controls.
Maintenance and License Implications
The project is MIT licensed, which is permissive for commercial use, modification, and distribution, provided you keep attribution notices. This is a low-friction license for enterprises. The repository shows active maintenance: the last push is August 2026, with recent releases including v7.5.6 and JetBrains v7.1.1. The release process is documented in RELEASING.md files, indicating a structured approach. However, the rapid release cadence (multiple versions in a single month) could mean frequent updates and potential breaking changes. The README notes that the CLI is a fork of OpenCode, which means it may inherit upstream changes but also diverge. For maintenance, you should monitor the release notes for each version, especially for the CLI and JetBrains plugin, as they have separate release tracks.
Alternatives: OpenCode and the Editor-Native Tools
The most direct alternative is OpenCode, the project from which Kilo CLI is forked. OpenCode is a terminal-based AI agent that focuses on a minimal, hackable experience. The difference is that Kilo adds a platform layer: VS Code extension, JetBrains plugin, cloud agent, and code review integration. If you only need a CLI and prefer a leaner tool, OpenCode might suffice. Other alternatives include editor-native assistants like GitHub Copilot or Cursor, but those are often closed-source and tied to specific models. Kilo's advantage is model neutrality and multi-editor support. The trade-off is complexity: Kilo has more moving parts (extension, plugin, CLI, cloud) than a single-purpose tool. For a team that wants a unified agent across environments, Kilo is a stronger fit; for a solo developer who lives in the terminal, OpenCode may be simpler.
Editorial conclusion
Adopt Kilo Code if you want a vendor-neutral coding agent that works across VS Code, JetBrains, and CLI, with the freedom to switch models mid-task and pay provider rates directly. Avoid it if you need a fully offline tool or if your team cannot tolerate the security risks of autonomous mode. Before adopting, verify that your preferred models are available in the 500+ list, confirm the CLI's fork from OpenCode meets your stability expectations, and test the JetBrains plugin on your specific IDE version. The project's rapid release cycle (v7.5.6 in August 2026) suggests active maintenance, but always check the latest release notes for breaking changes.
Community notes