Kilo Code is an open source AI programming agent that supports VS Code, JetBrains, CLI and other contexts. It provides 500+ model selection, zero markup reasoning, multi-agent mode MCP integration and independent CI/CD capabilities.

KiloCode

Kilo Code’s core parameters and statistics

Kilo Code is an open source AI Coding Agent positioned as an "Agentic Engineering Platform". It is not a code completion plug-in in the traditional sense, but an AI programming assistant that can understand context, edit across files, run commands autonomously, and even control the browser. According to the tool classification rules, the main delivery form of Kilo Code belongs to Type A (Agent / MCP / Automation Tool) . Its core is to complete programming tasks through a large model-driven agent (Agent), and natively supports MCP (Model Context Protocol) protocol extensions.

Projects	Public Information
Product Positioning	Open Source AI Programming Agent and Agent Engineering Platform
Core capabilities	Multi-agent programming 500+ model access, zero-price reasoning MCP expansion
Technical roadmap	LLM Agent + MCP protocol + multi-model routing + IDE deep integration
Open Source License	MIT
Supported platforms	VS Code, JetBrains, CLI, Cloud Agents, Slack
Place of Belonging	NL (Amsterdam, Netherlands)
GitHub Stars	26,400+
GitHub Contributors	1,100+
GitHub releases	461+
Community Users	3 million+ Kilo Coders
Cumulative Token Processing	40 Trillion+
Latest version	v7.4.11 (2026-07-17)

Brief comment in one sentence: Kilo Code is not another replacement for Copilot - it is the product of the trinity of "open source version Cursor + own model gateway + programmable Agent framework". The core difference is that it does not lock the model supplier, does not add reasoning profits, and all Agent behaviors are transparent to developers.

Users and market recognition of Kilo Code

Kilo Code is one of the fastest growing open source AI programming applications today. Officially disclosed data shows that it has served 3 million+ developers, processed a total of 40 trillion+ Token, and received a large number of five-star reviews on the VS Code Marketplace.

Key market signals:

• Product Hunt Monthly No. 1 Open Source Product: Kilo Code was named the best open source product of the month and received wide and natural spread in the developer community.
• Enterprise Customer Endorsement: The official website shows that teams from well-known technology companies such as Meta, Amazon, Airbnb, PayPal, Square, and Red Hat are using Kilo Code.
• GitHub community activity: 26,400+ Stars, 2,900+ Forks, 1,100+ contributors, 461+ releases, Monorepo (TypeScript 84% + Kotlin 12.4%) is frequently iterated by the community.
• Acquired by Anaconda (July 2026): Anaconda announced the acquisition of Kilo Code as a complementary AI programming capability in the data science ecosystem. The deal marks a new stage in the commercialization of open source AI programming tools. After the acquisition, Kilo Code continues to maintain MIT open source and independent operations.

Compared with competing products, Kilo Code's differentiation lies in "model freedom" - developers can switch between different models in the same task (such as switching from GPT-5.5 to Claude Opus 4.7 and then to local Qwen3) without being locked into any one model supplier.

Cost Advantages of Kilo Code

Kilo Code's pricing strategy is unique in the entire AI programming tool market: open source free + zero markup for inference. It splits AI programming tools into two layers: "tool itself" and "AI inference". The former is completely free, and the latter is settled based on the actual model cost.

Cost structure comparison

Cost Hierarchy	Kilo Code	Cursor (Competitor)	GitHub Copilot (Competitor)
C client/individual	IDE extension is free and open source; inference is by volume or BYOK	Pro $20/month (including inference)	Individual $10/month (including inference)
Team/Enterprise	Teams $15/user/month (management functions); Enterprise customization	Business $40/user/month	Business $19/user/month
API/Developer	Gateway pay-as-you-go (zero markup); Kilo Pass $19-199/month	Not available separately	Not available separately
Private Deployment	MIT open source self-hosted; KiloClaw $55/month hosting	Not available	Not available
Inference flexibility	BYOK (bring your own key) + local model + free model routing	Cursor built-in models only	OpenAI models only

C-side/Personal: Kilo Code’s IDE extension itself is completely free and open source (MIT license). AI inference costs are flexibly borne through the following methods:

• Auto Free: Use free models from Kilo Gateway without paying.
• BYOK (Bring Your Own Key): Bring your own API Keys such as Anthropic, OpenAI, Google, Azure, etc., pay the original price of the model supplier, and Kilo has zero markup.
• Local Model: Run local open source models through Ollama or LM Studio, absolutely free.
• Kilo Gateway pay-as-you-go: Zero monthly fee, pay according to actual usage when recharging, no subscription binding.

Kilo Pass Subscription: For users who need to use the paid model frequently, Kilo Pass provides monthly credit limit recharge, with three levels of $19/Pro $49/Expert $199 per month. The recharge limit comes with up to 50% bonus points. Points are transferable between Kilo Code and KiloClaw.

Hidden Costs:

• Cognitive cost of model switching: The freedom to choose 500+ models also means "choice paralysis" - if the team does not have a clear model selection strategy, frequent model switching may bring inconsistent coding experience and debugging costs.
• BYOK Management Cost: In the scenario of bringing your own keys, enterprises need to manage the quota monitoring, frequency control and bill aggregation of multi-vendor API Keys by themselves. Although Kilo has the Shared BYOK function, it still requires initial configuration.
• Token consumption in autonomous mode: In kilo run --auto mode, the agent executes without restrictions. If the task is not designed properly (for example, the dead loop needs to be repaired), the Token consumption may far exceed expectations. It is recommended to use it with max_steps and timeout control.

Kilo Code’s main features

• Multi-agent mode: Built-in five agent modes: Code (coding), Plan (architecture design), Ask (code Q&A), Debug (debug tracking), and Review (code review). Developers can switch as needed during tasks without changing tools.
• Free switching of 500+ models: Supports 500+ models (including GPT-5.5, Claude Opus 4.7, Sonnet 4.6, Gemini 3.1 Pro, etc.). Models can be switched at any time during tasks to match the delay, cost and reasoning requirements of different tasks.
• Auto Model Intelligent Routing: Four preset levels (Efficient/Frontier/Balanced/Free/Free) automatically route tasks to the most appropriate model, balancing cost and capability.
• MCP Protocol and Market: Native support for the Model Context Protocol, various extension tools (database operations, file system API calls, etc.) can be installed through the MCP Marketplace, extending the Agent's capability boundary from code to system operations.
• Inline Autocomplete (Autocomplete): Provides Ghost Text style code completion in VS Code and JetBrains, and the Tab key accepts suggestions.
• Terminal and browser control: Agent can execute terminal commands and operate the browser to realize the "write code → run → verify" operation.
• Autonomous CI/CD mode: kilo run --auto supports fully autonomous operation in the CI/CD pipeline without manual confirmation, and is suitable for automated scenarios such as test repair and batch reconstruction.
• Cloud Agents and Sessions: Agents can continue to run in the cloud after the IDE is closed; Sessions support seamless relay across devices (such as starting on a mobile phone and continuing on the desktop).
• Code Reviewer: Agent automatically reviews PR changes and gives feedback from dimensions such as performance, security, style, and test coverage.
• Parallel Agents: Agent Manager supports multiple agents working in parallel (such as one writing code, one writing testing, and one doing review), each running in an independent workspace.

[Expert Viewpoint]: Kilo Code's "Multi-Model Switching" and "MCP Extension" form a hidden linkage. Conventional usage is "changing models to save costs", but advanced usage is to use MCP to access database Schema reading, one-click deployment scripts, code base indexing and other tools, allowing the Agent to upgrade from "writing code snippets" to "operating the entire project life cycle". Cooperate with the Plan Agent to come up with the design plan first and the Code Agent to perform the Review Agent review to form a complete AI-driven development pipeline.

Kilo Code’s model and version evolution

Kilo Code has iterated extremely quickly since its inception in March 2025, and has released 461+ versions as of July 2026. Here are the key milestones:

Mainline release

Version	Date	Core Changes
v1.0.0 (Launch)	~2025-09	Product initial launch, VS Code extension + CLI
v6.0.0	2026-05-01	Auto Model routing engine Kilo Pass subscription MCP Marketplace is online
v7.0.0	2026-06-15	Cloud Agents, Sessions, and architecture major upgrade
v7.4.0	2026-07-10	Parallel Agents, Agent Manager
v7.4.11 (Latest)	2026-07-17	Repairs and performance optimization, the latest stable version

Candidate Verification

• v6.x series (May-June 2026): Rapidly iterate the model routing strategy of Auto Model, and introduce the Gateway pay-as-you-go and Kilo Pass subscription systems.
• v7.x series (June-July 2026): Upgraded from "IDE plug-in" to "Agent Engineering Platform", adding new functions such as Cloud Agents (cloud agents), Sessions (cross-device sessions), Code Reviewer (automatic review), Autocomplete (inline completion), Voice Prompt (voice programming) and other functions.
• v7.4.x (July 2026): Parallel agent mode, allowing multiple agents in the same project to perform different tasks in independent workspaces at the same time.

Ecological and community version

Kilo Code adopts Monorepo (monorepo) structure, and the core package includes:

• packages/kilo-vscode: VS Code extension
• packages/kilo-jetbrains: JetBrains plugin (Kotlin)
• packages/kilo-cli: CLI tool
• packages/kilo-core: public Agent engine

Each package is released independently, and the version number is synchronized with Git Tag (such as v7.4.11). The release frequency is about 3-5 versions per week, and there are more than 1,100 community contributors.

Technical advantages of Kilo Code

Kilo Code's technical architecture is designed around "model supplier independence + transparent agent + extensible tools", which is essentially different from closed-source competing products such as Cursor.

Architecture link

Developer IDE (VS Code/JetBrains/CLI)
        │
        ▼
Kilo Code Agent Engine (Open Source Core)
        │
        ├─ Auto Model Router → 500+ models (GPT/Claude/Gemini/open source/local)
        │ └─ Grade selection: Frontier / Balanced / Efficient / Free
        │
        ├─ MCP Client → MCP Server (file system/database/browser/API)
        │
        ├─ Tool call (terminal/browser/file editing/code search)
        │
        └─ Context Manager (Full Code Base Index/Session Context/Conversation History)

Dismantling of the core mechanism

1. Model-independent Agent engine: Kilo Code’s Agent core is decoupled from specific models. The same task (such as "implementing the user authentication module") can be executed by different models successively to compare the effects. The bottom layer adapts to the API differences of different vendors through a unified LLM interface layer, including OpenAI, Anthropic, Google, AWS Bedrock, Azure, etc. The effect of this design is that developers are no longer locked into a single model and can dynamically select models based on task complexity and budget.

2. Auto Model routing mechanism: Auto Model is not just a "select model" function, but a real-time routing engine based on task classification. It makes dynamic trade-offs between latency, cost and capability by analyzing task characteristics (code generation, Q&A, debugging, review) and historical consumption data. For example, "simple variable renaming" is routed to the Free file, and "complex architecture review" is routed to the Frontier file.

3. Transparent Agent (MIT open source): Unlike Cursor/Copilot’s black box Agent, Kilo Code’s Agent decision-making process is completely transparent to developers—Prompt content, context windows, and model selection can all be audited. Agent logic can be forked and modified on GitHub, and self-hosting is supported.

4. MCP protocol extension: Through MCP (Model Context Protocol), Agent can call external tools such as file systems, databases, and browser API gateways. MCP Marketplace provides pre-built Server repositories, and developers can also customize MCP Server to expose private tools.

Engineering Pitfall Guide

Pitfall 1: Deadly loop and Token inflation control. In Auto mode or complex repair tasks, the Agent may fall into an infinite loop of "modify code → report errors → change again → report errors again", leading to an explosion in Token consumption. Solution: Use the max_steps parameter to set the maximum number of execution steps (such as --max-steps 25), and cooperate with Kilo's timeout automatic termination mechanism; complex tasks are first split into implementation plans through Plan Agent and then handed over to Code Agent for execution, reducing trial and error cycles.

Pitfall 2: DOM/Context Overload. When the Agent processes long output (such as large log files, complex web page DOM) through MCP Browser or terminal commands, the context window may be burst, causing the model's attention to be diluted. Solution: Prioritize using the extract tool to intercept key areas rather than reading in full; enable Kilo's automatic summary truncation for overly long output; explicitly limit the Agent's search scope in the Prompt (such as "only check the src/auth directory").

Pitfall 3: Security and ultra vires governance. The kilo run --auto mode turns off all confirmation prompts by default, and the Agent can execute any terminal command and write files. Solution: Be sure to review the security boundary of the --auto parameter before using it in a non-trusted context; set a human-in-the-loop for irreversible operations (database writing, production deployment, file deletion), or use the Kilo Sandbox function to let the operating system rather than the model determine the system resources that the Agent can access.

How to use Kilo Code

Quick installation

# VS Code extension
# Search "Kilo Code" in VS Code to install, or visit the VS Code Marketplace

# CLI global installation (npm)
npm install -g @kilocode/cli

# Or use Homebrew (macOS/Linux)
brew install Kilo-Org/tap/kilo

# Or use curl one-click script
curl -fsSL https://kilo.ai/cli/install | bash

#ArchLinux
paru -S kilo-bin

Once VS Code is installed, create an account to access 500+ models and use free model routing without paying.

Entrance comparison

Entrance	Suitable scene	Startup method
VS Code extension	Daily IDE development	Search "Kilo Code" installation
JetBrains plug-ins	IntelliJ/PyCharm/WebStorm, etc. JetBrains IDE	Plug-in market installation
CLI	Terminal/CI/CD/SSH remote development	npm install -g @kilocode/cli
Cloud Agents	The cloud continues to run after the IDE is closed	Web app.kilo.ai
Slack	Code Q&A in team collaboration	Kilo Slack integration

Typical usage steps

1. Install and log in: Install the extension in the IDE and create a free account through kilo.ai.
2. Select model strategy: Select Frontier (strongest capability), Balanced (cost-effective), Efficient (low cost) or Free (free) in Auto Model, or manually specify a specific model.
3. Select Agent Mode: Code, Plan, Ask, Debug or Review.
4. Enter natural language instructions: For example, "Add JWT authentication for user modules, including refresh token mechanism."
5. Agent execution and iteration: Agent automatically analyzes the code base, generates code, and runs terminal commands. Developers can propose modifications for multiple rounds of interaction.
6. Review and Merge: Use Review Agent to review the changes and merge them when satisfied.

Autonomous CI/CD model

# Fully autonomous repair of test failures in CI pipeline
kilo run --auto "run tests and fix any failures"

The --auto flag disables all confirmation prompts and applies to quarantined CI contexts. Note: It is recommended to verify the predictability of Agent behavior in a non-production environment before first use.

Product Pricing for Kilo Code

Kilo Code's pricing adopts a two-tier structure of "free tools + flexible payment for inference", which is relatively rare in the AI programming tool market.

Kilo Code Plan

Plan	Price	Core Benefits
Free & Open Source	$0	IDE extension open source free; AI inference by volume or BYOK
Teams	$15/user/month	Use analytics AI adoption dashboard, shared Agent mode, centralized settlement Shared BYOK, team management, data privacy control, priority support
Enterprise	Customization	Customization SSO/OIDC/SCIM, Audit Log SLA, Restricted Models/Vendors, Shared Private Gateway BYOK, Dedicated Support Channel

AI reasoning solution

Plan	Price	Description
Auto Free / BYOK / Local Model	$0/month	Use the free model; bring your own API Key and pay the original price of the supplier; run locally with zero cost
Kilo Gateway Pay-As-You-Go	$0/month + usage	500+ models are billed according to the original price of the supplier without any increase, please recharge before use
Kilo Pass Starter	$19/month	Monthly credit, up to 50% bonus points
Kilo Pass Pro	$49/month	Larger limit + bonus points
Kilo Pass Expert	$199/month	Maximum amount + maximum reward ratio

KiloClaw (hosted OpenClaw)

Plan	Price	Description
Standard	$55/month	Hosted OpenClaw context, AI inference extra; 1-day free trial

Kilo Pass credits are transferable between Kilo Code and KiloClaw, and can be purchased in the Kilo Marketplace for partner coding/inference plans (such as MiniMax).

Application scenarios of Kilo Code

• Daily Coding and Code Generation: Generate cross-file function implementation from natural language description. For example, "Implementing a user rating API with Redis cache", Agent automatically creates routes, service layers, cache middleware and tests. Quantitative deduction for cost reduction and efficiency improvement: Traditional manual implementation takes 40-60 minutes (coding + debugging + testing), Kilo Code's Code Agent can complete the first version in 5-10 minutes, and developers only need to review and fine-tune. It saves about 70-85% of coding time, but code quality and exception boundaries still need to be controlled by developers.

• Legacy code understanding and reconstruction: Use Ask Agent to quickly understand unfamiliar code bases ("What is the flow logic of this order state machine?"), and then use Plan + Code Agent combination to complete reconstruction. Key points of verification: Whether the Agent has a complete understanding of the business logic and whether the original behavior remains unchanged after reconstruction.

• CI/CD automation and batch repair: Use kilo run --auto in the CI pipeline to automatically repair test failures, batch migration API calls, and unify code styles. For example, replace all axios calls in the project with fetch and adjust the error handling logic. Key points of verification: Changes in --auto mode must be reviewed by Review Agent or manually before they can be merged into the trunk.

• Code Review and Quality Gating: Integrate Review Agent into the PR process to automatically detect performance issues, security vulnerabilities, style violations, and test coverage gaps. Quantitative deduction for cost reduction and efficiency improvement: Traditional manual code review takes about 20-30 minutes for a medium-sized PR (500-1000 lines of changes). Review Agent can complete the first scan within 1-2 minutes. Developers only need to focus on high-risk items marked by Agent. However, Agent may miss business semantic errors and cannot completely replace manual review.

• Architecture design and technical solution review: Use Plan Agent to describe the requirements and generate an architectural design solution including technology selection, module division, and data flow diagram for team review. Key points for verification: Whether the technical rationality of the plan and the consideration of existing system constraints are sufficient.

Who is Kilo Code suitable for?

• Individual developers and independent developers: Free and open source IDE extensions + flexible inference payment allow individual developers to obtain AI programming capabilities at a very low cost. It is especially suitable for developers who need to switch between multiple models freely and do not want to be locked into a single supplier. Unfit Boundary: If you only need basic code completion (Tabnine level), Kilo Code's Agent mode may be too complex; it is recommended to use its Autocomplete function instead of the full Agent.

• Technical Teams and Engineering Managers: The Teams plan ($15/user/month) provides the use of analytical dashboards for AI adoption, centralized billing, and BYOK management. It is suitable for engineering teams who want to quantify AI programming ROI and uniformly manage model suppliers. Not fitting boundaries: If the team has no requirements for model selection (accepts a single default model), GitHub Copilot's $19/user/month may be more cost-effective to manage.

• Enterprise/Party A Technology Department: The Enterprise plan provides SSO, audit log SLA and private Gateway deployment, suitable for enterprises with compliance requirements. The MIT open source license allows for self-hosting and deep customization. Unsuitable Boundary: In industries with strong compliance (finance, medical, government affairs), there is no clear legal framework for copyright ownership and compliance traceability of AI-generated code. It is recommended to conduct team-wide promotion after confirmation by the legal department.

• AI tool integrators and platform developers: The MCP protocol and open source Agent engine allow Kilo Code's capabilities to be embedded into your own platform or workflow. Prerequisite: You need to understand the development mode of MCP Server and the Agent calling API of Kilo Code.

Summary of unsuitable boundaries: Kilo Code is not suitable for organizations that require a completely closed, non-open source compliance environment; it is not suitable for light users who only need basic code completion without Agent capabilities; nor is it suitable for individuals who are extremely sensitive to the cost of AI inference and cannot accept the complexity of BYOK management (in this case, local models or Free files are preferred).

Summary and outlook of Kilo Code

Kilo Code has embarked on a differentiated path in the competition of AI programming tools in 2025-2026: Open source transparency + model freedom + zero markup reasoning. It is not a simple copy of Cursor or Copilot, but fundamentally changes the business model of AI programming tools - the tools themselves are free, and inference fees are transparently settled based on actual costs.

Core Competencies:

• MIT Open Source License + The community vitality of 1100+ contributors ensures the long-term sustainability and auditability of the product.
• Neutral access to 500+ models, developers are not locked into any one model supplier.
• Auto Model intelligent routing + multi-Agent mode form a full-link AI development pipeline from design to deployment.
• Anaconda’s resource injection after the acquisition may accelerate penetration in the data science and Python ecosystem.

Current Limitations and Uncertainties:

• Active paid conversion rate among 3 million+ users is undisclosed, and the depth of penetration of the Teams/Enterprise program remains to be seen.
• The product roadmap and community governance model may be adjusted after the Anaconda acquisition. The independence of the open source community is a signal that requires continued attention.
• The "freedom of choice" of 500+ models may translate into "management burden" when the actual team implements it, and best practice documents for model selection need to be supplemented.
• Although the --auto mode of CI/CD is powerful, the security boundary in the production environment still needs to be maturely verified by industry standards.
• The ecological richness of MCP Marketplace is still in its early stages, and there is a clear gap between it and mature integration platforms such as n8n/Zapier.

Procurement/Adoption Risk Assessment: It is recommended that individual developers start with the free version and use 1-2 weeks of real project experience to test the Agent's answer quality and understanding of the project structure. The technical team can first use the Teams free trial period (14 days) to conduct a small-scale PoC, focusing on verifying the cost control effect of the Auto Model and the actual impact of the multi-agent model on the team process. Enterprises need to confirm before purchasing: whether the data isolation solution in the self-hosted scenario meets compliance requirements; the API Key security management process in BYOK mode; and Anaconda’s commitment to the product support cycle after the acquisition. High-risk scenarios (production database operations, financial trading system code) must disable --auto mode and set manual confirmation points in the process. Overall Rating (Reference): Functional Completeness ★★★★★, Cost Flexibility ★★★★★, Security Governance ★★★☆☆, Ecological Maturity ★★★☆☆. ", "explanation": "Rewrite Kilo tool document body from AI search to AI coding agent with 11 sections, comparison table, ~10000 chars"}

Related tools: GitHub Copilot, Cursor

Version Info

• release ：The latest stable release contains many fixes and performance optimizations. （2026-07-17）
• release ：Introducing parallel agent and Agent Manager functionality. （2026-07-10）
• release ：Major architectural upgrade to support Cloud Agents and Sessions. （2026-06-15）
• release ：Auto Model routing Kilo Pass subscription MCP Marketplace is online. （2026-05-01）
• launch ：The product is initially launched. There is no official precise date yet. （~2025-09）