KIT

The deciding trait is the session tree. Conversations branch rather than accumulate, so when a turn takes the work somewhere useless you go back to the fork and try the other approach instead of scrolling, apologising and re-explaining. That single behaviour changes how willing you are to let an agent attempt something ambitious.

What is missing is company. This is a young project with a small crowd, so when something odd happens there is nobody to ask. Pick it if branching matters to you. Pick Aider if answers do.

The guard is thin for what it guards. A preset defined in markdown decides which tools a delegated agent may reach, and one of the tools on the other side of that decision executes commands. There is no container, no review step and no documented default beyond whatever the author of the preset typed, which makes safety a configuration exercise done under time pressure.

What it does right is make delegation explicit. A named preset with a declared tool list is inspectable before it runs, which is more than a prompt convention offers.

1. In-process tools remove a serialisation boundary and a subprocess from every step, which matters because the file operations dominate turn count in any real session. 2. It also removes a substitution point: a built-in cannot be swapped for an instrumented version without recompiling, so measurement of the core loop is harder for anyone but the author.

2. The external protocol is still supported for everything else, so the choice is scoped rather than dogmatic. That distinction is the part worth noting, and it is stated clearly.

The authorship is the only asset worth pricing. A small lab known for infrastructure libraries brings credibility that a hundred stars does not, and credibility is what makes a free tool get picked up by the people who build the next layer. There is still no business model, no meter and nothing an acquirer could buy except attention.

Moat: none, and Go is easy to reimplement. Likely path: it stays a well-regarded utility, or the ideas get absorbed by a funded terminal agent. Position: depend on it where a rewrite is cheap.

This one crosses the line from a tool engineers use into a step I can measure. Structured output means the result lands in the systems my team already runs, and a workflow triggered from a comment fits the review process rather than asking sixty people to change how they work. The licence costs nothing across all of them.

What is absent is everything around it: no directory integration, no audit export, no vendor to call. Approved with conditions: it runs in the pipeline under our own credentials, and it does not get installed on laptops.

Extending this means writing real code rather than describing a tool to a model and hoping. My additions are the same kind of thing as the built-ins, with the same access and the same speed, and the widget hook means the interface itself is mine to change. The permissive licence keeps that fork alive whatever happens to the author.

Speaking the editor protocol over standard input means it drops into anything that hosts an agent, and a local runtime keeps the whole loop on my hardware. This is what ownership looks like in Go.