Coding Agents
Codex, Claude Code and KiCode: The Differences That Matter
Every terminal agent demos the same way. The real differences are where it runs, what it may do unattended, and what artefact it leaves behind.
The terminal coding agents have converged on a shape: you type an instruction, the agent reads files, proposes a diff, runs a command, and asks whether to continue. The differences that matter are not in the demo. They are in where the code runs, what the permission model is, and how much of your repository the agent can see before it starts editing.
I build one of these (KiCode), so read the comparison with that bias declared. The useful part is the dimensions, not the verdict.
Dimension one: where it runs
- Local-first — the agent is a process on your machine. Files never leave the disk except as prompt tokens. It can use your shell, your compiler, your test runner. This is the right default for private repos and for work that needs a real environment.
- Cloud-hosted — a remote sandbox clones the repo, runs the agent, and returns a branch or a pull request. Good for parallel work and for handing a task off from a phone. The cost is a copy of your source in somebody else's sandbox.
Codex, Claude Code and KiCode all have a local terminal mode; the cloud variants differ in how much of the environment they reproduce. A cloud sandbox that cannot run your database migrations will fail the tasks that involve them, and no amount of model quality fixes that.
Dimension two: what it can do without asking
The permission model is the security boundary. Some agents ask before every write and every command; some run reads freely and gate writes; some have an explicit allow-list per project. The question to ask is not how few clicks but what is the worst thing this agent can do unattended.
If the answer includes `git push --force`, deleting a volume, or running an arbitrary network command, the agent needs a sandbox, not a confirmation dialog. Confirmation fatigue is real: a prompt you approve forty times a day is a prompt you stop reading.
Dimension three: how it finds context
Every agent greps. The difference is what happens after the grep. A good one builds a map — imports, call sites, tests that touch the symbol — and shows you the plan before editing. A weaker one opens the file you named, edits it, and discovers the type error three steps later.
An agent that reads before it writes produces smaller diffs. Smaller diffs are the whole game.
Dimension four: the exit
How do you get the work out? A patch you apply, a commit on a branch, a pull request with a description. The best answer is the one that leaves a reviewable artefact — a diff with a message you can read — because the review is where the value is captured. An agent that edits files in place with no diff has moved the risk, not removed it.
How to choose
- Private or regulated code → local agent, bring your own key, no telemetry.
- Parallel delegation → cloud sandbox with a real test environment and PR output.
- Cost control → an agent that lets you pick the model per task, not one that hardcodes a frontier model for a rename.
- Team adoption → whatever produces the smallest, most reviewable diff. That is a workflow decision, not a model decision.