Kimi CLI

The trait you will feel hourly is the Ctrl-X shell mode. One keystroke flips the same prompt between typing commands yourself and asking the agent to do it, which removes the window-switching tax that makes most terminal agents feel like a separate application. Add the zsh plugin and it stops being a tool you open and starts being where you already are.

It edits across files and touches git, so it is a real working agent, not a chat box. Pick it if terminal ergonomics decide your tools. Pick Claude Code when the hard, long tasks have to land.

The failure mode is blast radius. The capability list confirms command execution and repository operations, and lists no container isolation of any kind. That combination means a mistaken deletion or a bad rebase happens in your actual checkout, not in a copy. The documentation describes what it can do and does not describe what stops it.

Work on a branch you can throw away and keep the repository clean before each session. The one thing done right: it implements the Agent Client Protocol, so it plugs into Zed and JetBrains instead of demanding that its own interface become your editor.

The documented surface is a tool inventory rather than an architecture: reading and editing source, running commands, searching the web, with MCP servers extending that set. How context is selected before an edit, and whether anything verifies the edit afterwards, is not described in the material available. Verification appears to be the human reading the diff.

No benchmark is published, which at least spares the reader a methodology audit. The documentation is thin in exactly the place a researcher wants it thickest, and a tool inventory is not a design.

Read the ownership before the features. This comes from a frontier lab, and the default path into it is an OAuth sign-in to the lab's own coding service. The client is free because inference is where the margin lives, and giving away the terminal is the cheapest distribution a lab can buy. That is a sound strategy and it tells you whose roadmap you are on.

Moat: the K2 model family plus habit, which is thinner than it looks once other endpoints are configurable. Likely pivot: the client narrows toward the lab's own subscription as the free alternatives multiply. Position: use it, keep your configuration portable.

One sentence on the demo: it is fast and engineers will want it. Now the meeting. The default onboarding creates a vendor account per developer, which is sixty relationships my security questionnaire never covered and no central place to see who signed in. There is no single sign-on, no audit trail and no retention statement to hand to legal.

It also cannot run unattended, so it never becomes a pipeline step and never produces a reviewable artifact centrally. Onboarding itself is trivial, roughly an hour. Not yet. Revisit when there is an account layer an administrator can actually see.

Apache-2.0, so a fork survives whatever the lab decides next, and the source is readable Python I can install with uv rather than a curl pipe if I would rather see the package first. Local model endpoints are supported, which means my hardware can serve the loop and nothing has to leave the desk when I do not want it to.

MCP servers extend the tool set, and the zsh plugin means the whole thing travels in the same dotfiles repository as everything else I own. That is the test. It passes, and I do not say that about many vendor-published clients.