Machine-written code has moved in two years from completing the next line to being handed a task and finishing it. Kilo Code belongs to the second group, and it takes the letting-go further than most: it does not merely produce code, it runs commands in a real environment, runs the tests, looks at the errors, fixes them and verifies again.

It is an open project that lives inside the two large editor families and also offers a command-line form, brought in-house in 2026 by a data platform company and listed on a large cloud marketplace. The client is free and open; what you pay for is the model behind it, if you choose to pay for one.

It repairs its own work, so you do not have to watch

Anyone who has used these tools knows the ritual: ask for a change, the change lands, the first run fails, and now you paste the error back and wait for another round. Kilo Code closes that loop itself. After writing code it executes the tests, reads the failure, locates the problem and repairs it, repeating generate, run, repair and verify until the thing holds. A dedicated debugging mode walks the whole codebase, follows the error back to its source and proposes a fix, which is a particular relief in a project you have just inherited.

The self-check goes past running tests. Before applying a change it reviews its own output, flags what looks risky, and asks for confirmation before anything destructive. One reviewer reported that this built-in review caught a race condition in asynchronous handling ahead of time — exactly the class of problem a human eye skips over at the end of a long afternoon.

One task, several agents at once

A single-threaded assistant has a ceiling however fast it is, so the design here is to split. Parallel tool use lets it read several files and run several searches at the same moment. More involved work goes to sub agents: ask for a payment feature and it dispatches one to write the server endpoints, one for the interface components, one for the callbacks, each holding its own context and progressing at the same time, with the results merged at the end. A further coordinating mode handles the wider view, breaking a large requirement into architecture, coding and testing subtasks and assigning them to different roles.

Parallelism usually raises the fear of agents stepping on each other. Here each sub agent gets its own working area as a separate branch of the version history, so nobody's edits collide. A management panel shows the progress of each one, lets you review the changes they produced, and lets you compare how several models handle the same task.

Five hundred models, and a bill you can read

Nothing here binds you to a single model vendor. Through the project's own gateway you can call more than five hundred models at list price, covering the closed flagship systems and the open ones, with no markup claimed on top; or you can supply your own key, or point it at a model service running on your own machine, in which case the code never leaves. The model can be switched in the middle of a session — a cheap small one for a simple edit, a stronger flagship when the refactoring gets serious — and new users usually start with a free allowance large enough to form an opinion.

One partner across every environment you use

The selling point is that the same agent is everywhere: inside both large editor families, in the terminal, in the cloud, even inside a chat application, with sessions synchronised across them. Start a task on a phone and continue it on the desktop with the context intact. A built-in memory keeps the project's architectural decisions and your preferences, so the same explanation is not needed twice.

Extension follows an open protocol with a built-in catalogue, so external tools such as databases and document stores attach in one step. The client itself is open and auditable: which model ran, how much context was sent, all of it visible. At the end of 2026 the editor extension had passed a million installations and the community was among the liveliest in open coding tools. The client is free; the real cost is whichever model service you pick, and a free or local model makes the whole thing cost nothing.

Who it suits

Anyone tired of cleaning up after an assistant that edits confidently and breaks the build. Anyone whose work is big enough that a single-threaded agent feels slow. Teams that need to see which model touched the code and how much of the repository went with it. Install it into an editor and it behaves like a pair programmer who finishes the job without being watched.