SmallCode

The deciding trait is that it was designed downward rather than up. Everything else in this category assumes a frontier model with an enormous window and perfect formatting, then degrades badly when it does not get one. This one starts from the model you can actually run and builds the compensations in, which is a completely different engineering posture.

It will not match a hosted agent on hard problems, and it does not pretend to. Pick it if the inference is already yours. Pick something hosted if you were going to pay anyway.

Forgiving parsers fail in the worst way available: quietly and plausibly. A model that emits a slightly wrong call gets its intent reconstructed by heuristics, and the reconstruction is right most of the time, which is exactly what makes the remaining cases hard to notice. A stricter reader would refuse and retry. This one proceeds, and the evidence of a misread arrives as a strange edit rather than an error.

What it does right is patch rather than rewrite. Search-and-replace edits limit the blast radius of a bad turn to the region it named.

1. Moving the plan out of the context window into a file on disk is the single most effective answer to a short window, because the state that must persist stops competing with the state that must be read. 2. Summarising against a declared budget rather than truncating at a limit keeps the decision about what to lose explicit.

2. Each of these is a known technique applied deliberately to a stated constraint, which is better engineering than most of this board. No evaluation quantifies any of it, so the constraint is named and the benefit is not measured.

The bet is a good one and structurally uncapturable. If open weights on consumer machines keep improving, tools shaped for them become more useful every year, and the value flows to the model publishers and the hardware vendors rather than to a terminal agent with two thousand stars and no entity behind it.

Moat: none available in this position. Likely path: the design ideas are absorbed by larger tools once small models are good enough for everyone to care. Position: use it, pin the version, and expect no company to appear.

Source code that never leaves the machine is the answer I have been trying to negotiate out of vendors for two years. No processor agreement, no residency clause, no retention policy to review, because there is no third party in the transaction. For the teams working under our strictest customer contracts, that alone puts this ahead of better tools.

The cost moves to hardware and to variability, since the results depend on what each machine can run. No console, no directory login, nothing unattended. Approved with conditions: restricted projects only, on machines my platform group specifies.

Naming three different local runtimes means somebody actually ran all three, which is a different claim from listing one and hoping. Whichever way I happen to be serving weights this month is already supported, and the hosted providers are there as a fallback rather than as the assumption everything else was built around.

Tool servers attach over the protocol, so what I have already exposed is reachable without a wrapper, and the permissive licence keeps a fork legal. Small enough to read, which is the last thing on my list and the one that matters most.