Kilo Code Review

What Kilo Code is

Kilo Code, also called Kilo, is an agent that reads project context and uses tools to help write, change and review code. It is the software around the language model, not a model itself. Its open-source clients give you ways to work in Visual Studio Code, JetBrains integrated development environments (IDEs) and the terminal; its hosted services add Cloud Agents, pull-request reviews and a gateway for model access. The distinction matters: you can inspect the agent's source without owning the infrastructure or model serving a hosted request. The advertised model catalog is a choice of engines, not proof that every engine will handle your repository equally well.

Verified against Kilo's live product pages, documentation and pricing on 31 October 2026. Alternative-product claims were checked against their makers' pages on the same date. This is a public-documentation evaluation, with proposed workflows and calculated examples, not a signed-in performance test. The verdict turns on workflow continuity, model control, billing clarity and review boundaries.

Who should pick Kilo, and who should skip it?

Kilo makes the strongest case for a developer or small team that wants to keep its editor while choosing models and connecting local work to hosted execution. It is less compelling when you already have a reliable agent and cannot name a task that Kilo would handle more conveniently.

The comparison is about what you gain by switching. A long feature checklist does not establish better patches, and this review does not claim that Kilo beats either alternative on your code.

Kilo Code vs Cline

Cline is an open-source agent with editor and terminal interfaces, model-provider choice, local-model support, and a Plan/Act workflow that separates discussing a change from executing it. Its current site also documents skills, integrations and multi-agent work. Those capabilities are not exclusive reasons to choose Kilo. Cline's current capabilities.

Pick Kilo if you specifically want its Cloud Agents, model routing, hosted reviews and shared billing to form one working setup. A small agency maintaining several repositories could use an editor for interactive fixes, a cloud task for a scoped cleanup, and repository-owned review instructions before a human merges the result.

Pick Cline if its existing provider configuration, approvals and project rules already suit your work. Replacing a functioning local workflow just to gain another model picker has little payoff. Cline also deserves consideration when you want to build around its agent runtime rather than adopt Kilo's hosted services.

For a closer look at the two alternative workflows, see Cline vs Claude Code. One qualification for JetBrains buyers: Cline's current pricing page places its JetBrains extension in Enterprise; do not assume its individual offer has the same editor coverage as Kilo's.

Kilo Code vs Claude Code

Claude Code is Anthropic's coding agent, available in the terminal, IDEs, desktop and browser. Its terminal and editor integrations also support documented third-party provider arrangements, so the difference is not that Claude Code exists only in a terminal or can only bill a personal subscription. Claude Code overview.

Pick Claude Code if you want a Claude-centered workflow and your existing subscription allowance comfortably covers the work. You have less reason to introduce another gateway merely to reach a model you already use. Its limitation for this decision is the shared subscription allowance: interactive Claude use and Claude Code compete for the same pool.

Pick Kilo if switching between model families, using your own provider keys, or combining local and hosted Kilo workflows is part of your normal week. It can also sit beside Claude Code: reserve Kilo for the work that needs a different route or environment, then compare the resulting patch and total effort before moving more work across. Using a Claude model inside Kilo does not make the client Claude Code.

Kilo Code vs Cursor

Cursor is an integrated coding environment with agent, terminal and cloud workflows. Keep it if the editor itself is what you value and you do not want to manage a separate agent configuration. Choose Kilo when preserving your preferred editor and controlling the agent's model route matter more. Kilo's installation page also lists Cursor as an extension host, so adding Kilo does not necessarily mean abandoning Cursor immediately. Cursor, Kilo installation options.

Kilo Code vs OpenCode

OpenCode is an open-source coding agent with terminal, editor and desktop interfaces and provider choice. Kilo's current CLI and rebuilt VS Code extension use OpenCode as their foundation. Pick OpenCode when its own workflow already fits; pick Kilo when Kilo's surrounding services are the reason you are shopping. Sharing a foundation does not establish identical behavior, release cadence or hosted features. OpenCode, Kilo CLI foundation.

Kilo Code vs Roo Code

Roo Code should not be treated as an equivalent maintained product on a new shortlist. Its official repository is archived and its README says the extension shut down. Existing users evaluating Kilo should treat the move as a migration of instructions and workflows, not assume old settings transfer unchanged. Roo Code repository.

The broader Claude Code alternatives shortlist is useful if none of these working arrangements fits.

Work in your editor and terminal without changing the agent

Kilo's first useful capability is keeping the agent close to the code while letting you separate tasks into reviewable changes. The current editor story includes parallel sessions, worktrees and diff review, not just a chat panel that suggests snippets.

VS Code: separate the patch from the investigation

Kilo's VS Code extension shares a portable core with its CLI and supports parallel agents, worktrees and line-level feedback on diffs. A worktree is another checkout of the repository on its own branch. It lets a task change files without immediately disturbing your main working copy. The extension can also send your review comments back into the agent's conversation. Kilo for VS Code.

Consider a refund bug in a small commerce application. One task investigates where refund status changes; another produces a bounded patch with a test that reproduces the bug. Give the writing task its own worktree. Ask the investigation task to explain the relevant behavior before either agent broadens the change.

Your acceptance criteria should describe the outcome: a repeated webhook, an incoming event notification, must not create a second refund, the existing successful path must still work, and unrelated payment code must stay untouched. That is a more useful starting point than asking the agent to improve the payment system.

When the patch arrives, read the changed files, inspect the test's assertion, and send specific feedback against the line that needs revision. Parallelism is useful only when it reduces waiting without increasing the time you spend reconciling incompatible changes. Two agents writing the same checkout can still interfere with each other.

JetBrains: native support, with worktree details to check

Kilo provides a native JetBrains plugin for IDEs including IntelliJ IDEA, PyCharm and WebStorm, without requiring Node.js. Install it through Settings → Plugins → Marketplace, then configure it under Settings → Tools → Kilo Code. Shared agent settings use kilo.jsonc, while IDE-specific settings remain in the plugin. JetBrains documentation.

For a backend developer, the practical test is whether the agent can work inside the project structure and build setup you already depend on. Ask it to trace a controller through its service and persistence layer, propose a narrow change, then use your normal IDE inspection and test workflow to assess the result.

There are specific integration boundaries. Agent worktrees are excluded from the containing project's index by default, which can leave files without normal code resolution or inspections. Open the worktree as its own project when you need full indexing. Also, a worktree setup script can start without the agent waiting for it to finish. Wait for dependencies and generated files before asking the agent to use them. These are workflow constraints, not evidence that the model failed to understand the code.

CLI: a useful option for terminal work

Kilo's command-line interface lets you use the agent from a project directory and choose a Kilo account or your own provider keys. Its documented npm installation is: Kilo CLI.

npm install -g @kilocode/cli
kilo

Run the second command from the repository you intend to work on. For an initial task, ask for an explanation of the failing test and a proposed fix before approving edits. A short, inspectable repair tells you more than a broad request to modernize a repository.

Kilo also documents /sandbox, which confines tool execution at the operating-system level. The advertised controls include workspace-limited writes, read-only Git metadata and optional network restrictions. Permissions govern whether an action runs; sandbox rules govern what that action can reach. Configure both around the task instead of treating automatic approval as a substitute for boundaries.

Kilo Code models: choose the route as well as the model

Kilo's model flexibility is useful when you distinguish the engine from the service carrying the request. The gateway gives you hosted access; bringing your own key (BYOK) lets a provider account supply inference, the model processing your request; local-model support lets you use software such as Ollama or LM Studio to serve a model on your own machine. A provider key is a credential for API access, not a general-purpose transfer of another app's subscription. Kilo's inference options, Gateway.

There are two decisions here: which model should attempt the task, and which account and infrastructure should process it. Keeping those decisions explicit makes later cost comparisons meaningful.

Kilo Auto Model offers Efficient, Frontier and Free routes. Efficient classifies the work and selects a model strategy for its difficulty; Frontier uses paid models aimed at demanding work; Free routes through available free models. You can choose a specific model instead. Auto Model.

For routine test scaffolding, try a cost-conscious route with a precise expected behavior. For a failure involving several services, give the agent the relevant traces and ask for competing explanations before authorizing a patch. Judge whether the response identifies the right code and proposes a way to falsify its hypothesis. A more expensive model is worthwhile only if it reduces the total work needed to reach an acceptable result.

Auto routing is a convenience, not a frozen experimental setting. Kilo's docs say the underlying models can change server-side, and the expanded picker shows the selected models and cost. If you are comparing tools on the same task, record the actual model and route, not just the word Auto. Auto Model documentation.

Kilo Code skills: make repeated work explicit

Kilo supports skills, folders containing a SKILL.md file that packages instructions for a repeatable task. Current project skills live under .kilo/skills/; the agent discovers their metadata and loads the relevant instructions when needed. This is a way to give the agent a documented procedure, not a guarantee that every instruction will be executed correctly. Skills documentation.

For the refund example, a project skill could explain where payment fixtures live, which test command covers retries, and how to distinguish a duplicate webhook from a legitimate second refund. Keep the description specific enough that the agent can identify when it applies. Put the procedure under version control so the next developer can inspect it too.

The payoff is less repeated briefing. The limit is that instructions still depend on a working environment and human review. A beautifully written test procedure cannot compensate for a cloud checkout that never installed its dependencies.

Cloud Agents: hand off a reproducible task

Kilo Cloud Agents are useful when a task can run in a hosted environment without depending on your laptop. Kilo documents repository connections, a remote Linux environment, branch/worktree creation and reusable environment profiles. Those profiles hold setup commands, environment variables and secrets. Cloud Agents.

A suitable first handoff is a narrow refactor with an executable acceptance check, such as replacing a deprecated helper in a specified module while preserving its tests. A poor handoff is a task that depends on undocumented local services and credentials that exist only in your shell history.

The portability wall is concrete: Cloud Agents do not automatically discover and execute .kilo/setup-script. If that script prepares the repository, invoke it explicitly from the cloud profile's Setup Commands. Project skills can travel with the repository; user-global skills in your home directory do not. Cloud Agent documentation.

There is also a difference between separate conversations and separate execution environments. Cloud chats share a container, and chats in the same worktree see each other's edits. Separate worktrees help keep changes apart; they do not imply independent machines. That distinction matters if your jobs install different dependencies, start services on the same port or assume exclusive access to generated files.

Code Reviews: put repository policy ahead of generic comments

Kilo Code Reviewer can add feedback to configured GitHub pull requests and GitLab merge requests, using your chosen model and review focus. It also supports local review before you commit. The useful question is whether its comments identify actionable risks in your code, not whether it can produce a long list of suggestions. Kilo Code Reviewer.

For a small team, use it as an additional pass before the human review. Ask it to focus on behavior that matters to the repository: authorization in a customer portal, safe handling of repeated events in billing, or migration compatibility in a shared service. Leave formatting arguments to the tools already enforcing formatting.

The most useful configuration is REVIEW.md, a repository-owned review policy. Commit it to the base branch and enable Use REVIEW.md in Code Reviews settings. Kilo reads the policy from that base branch, not from the proposed change. Otherwise a pull request could change the instructions used to assess itself. Code Reviews documentation.

For a refund service, that policy might ask the reviewer to check duplicate event handling, tenant authorization and assertions around failed external calls. Ask for the relevant path, explanation and evidence for each concern. These are proposed review criteria, not a claim that the agent caught those defects in a test here.

For local work, /review examines uncommitted changes; /review branch examines the branch against its base. A useful sequence is local review, targeted fixes, then a pull request for the normal team process. Keep an eye on whether repeated runs produce new evidence or merely rephrase the same concern.

The boundary is substantial: hosted reviews ignore bot-authored pull requests by default, including dependency-update bots. They also focus on changed files and have execution and concurrency limits. If your main problem is reviewing automated dependency updates, do not assume enabling Code Reviews covers that queue. Verify the intended path before making it a required part of your process.

What Kilo costs for a solo developer or small team

Kilo separates platform access, model inference and hosted compute. Start with the individual platform unless you need shared administration. The current plans and relevant charges fit in one buying block:

• Free & Open Source: no platform charge; usage is separate.
• Teams: $15/user/month for shared billing, keys, agents and usage visibility. Enterprise: custom pricing for governance such as provider/model restrictions, single sign-on and audit logs.
• Inference: Gateway usage at provider rates, with a 5% credit-purchase processing fee listed separately. BYOK bills inference through your provider. Optional Kilo Pass starts at $19/month for subscribed credits; it is not unlimited usage or a Teams seat.
• Compute: Code Review $0.33/hour; Docker/Small Cloud Agent $0.60/hour; Standard $1.20/hour, metered per second, in addition to inference. Kilo pricing.

A three-person Teams workspace therefore starts at $45/month before usage (3 × $15). At the listed review-compute rate, an illustrative ten-minute review would use $0.055 of compute (10 ÷ 60 × $0.33), plus inference and applicable fees. That is arithmetic, not an observed runtime or total review price. Model reasoning and retries still determine much of the eventual bill.

Cloud also requires a $5 launch balance, which is a balance requirement rather than an extra charge; BYOK does not remove compute charges. Cloud billing details. If you consider Pass, count only bonus credits you will use: they expire monthly. Kilo Pass terms.

The Free-to-Teams wall is shared management. The Teams-to-Enterprise wall is governance. Buy the control you need, then budget usage separately.

The limitations that can change the decision

Kilo's flexibility brings configuration choices that a small team needs to own. These are the limitations most likely to change the recommendation.

Auto Free is unsuitable for confidential work without checking its data route. Kilo's own Auto Model documentation says free routes may use providers that log prompts and outputs and use them to improve services. It explicitly advises against submitting personal or confidential data. Open-source client code does not cancel the selected provider's data practices. Use an approved route for private code. Auto Free data handling.

Local setup does not automatically become cloud setup. The missing automatic .kilo/setup-script execution and absent home-directory skills can make the same instruction behave differently remotely. Version the necessary project instructions and define cloud setup explicitly. Otherwise you are comparing environments as much as agents.

Hosted review is not whole-repository assurance. Changed-file review, bot exclusions and execution limits leave gaps. A dependency bot's proposed update and a behavior hidden outside the diff may still need separate attention. A quiet reviewer is not proof that a release is safe.

Public review pricing is inconsistent. The feature page advertises free reviews with free models; the review docs describe free compute during limited beta. The dedicated pricing and cloud pages list a compute charge. This review uses the dedicated pricing page for budgeting. Confirm any beta or account-specific exemption before promising your team zero-cost hosted reviews. The conflict does not justify treating the posted rate as a measured charge on an untested account.

A team plan does not include every governance control. If your requirement is centrally restricting which models or providers can receive code, the pricing page places that control in Enterprise. Shared billing alone is not the same policy. This can decide the purchase before model quality enters the discussion.

Kilo Code review verdict: switch only for a workflow you will use

Kilo earns a place on the shortlist when you want an inspectable agent, model choice and connected local/cloud/review services. Its strongest buying argument is the work you can organize through that combination. Catalog size alone is a weak reason to migrate.

Pick Kilo if you can name a recurring task that benefits from its environment handoff, model routing or repository review configuration, and you are willing to manage the associated usage bill. Pick Cline if your existing open-source agent setup already handles your local work cleanly. Pick Claude Code if you want the Claude-centered experience and your allowance fits. Keeping Kilo beside either is sensible while its added value remains specific.

Next week, choose one small, reversible repository task. Record the model route, setup work, billed usage, human corrections and whether the final patch passes your own acceptance check. Repeat only if the result answers a meaningful buying question. Move more work to Kilo when it reduces the effort to an accepted change, not simply when it generates more code.

Frequently asked questions

Use the AI Business Workflow Audit Checklist to map the task, review owner and acceptance check before expanding your agent setup.