We charged our own tool rent. The bill was not what we expected.

Last week we told you, in writing and in advance, how our own tool could fail, and promised to report the result either way. Here it is — and it is more interesting than the clean win or the clean loss we’d braced for.

codeworld is a deterministic, queryable projection of a codebase’s history. We registered it in our real working sessions with one rule: no nudges. Nobody is told to use it. The failure line was pinned before the first session: near-zero use after three working days is a negative signal — redesign, don’t explain it away.

Three days in, the number was near zero. And we almost stopped there and published exactly that: our tool didn’t earn its place.

We’re glad we didn’t, because it would have been the wrong verdict — and finding out why is the actual result.

We had measured the wrong thing

Near-zero use turned out not to mean near-zero value. It meant the tool was never being looked at. An agent deep in exactly the kind of work the tool exists for — “is this code dead or load-bearing, and why; which of these boundaries is legacy” — was reconstructing the answer from the tools already under its hand, and never turning to consider a specialist one it hadn’t used before. That is a fact about surfaces, not about whether the ground underneath is worth standing on.

So we did what we said we would: we fixed the surface instead of explaining the number away. And when the tool was actually surfaced where the agent was working, the agent used it — immediately, and without being told to prefer it over anything.

Availability is not adoption. A tool has to be met where the work is happening, not left in a drawer to be discovered. That part is a solved problem.

The bill we didn’t expect

Here is the finding that mattered. Once the agent was using codeworld, it reached for it to get oriented — and then, for the deepest questions, it went back to plain git, because git could still answer them more precisely than our ground could.

That is the real bar, and it’s higher than “exist and be found”:

Grounded truth doesn’t earn its keep by being available, or even by being used. It earns its keep only when it out-answers the tools the agent already trusts.

For the questions that matter most — why is this boundary here, which decision set it, is it safe to change — our ground has to be more precise than reading the commit log by hand. Where it isn’t yet, an honest agent correctly routes around it. That is exactly the standard we want to be held to, and now we can measure ourselves against it.

Kano was the first world. The codebase is the second. The thesis still says any causally-recorded system can be next — and the work now is not to convince agents the ground exists, but to make it deep enough that, once they stand on it, they never need to climb back down to git. If you’re building agents that need somewhere real to stand, we’d still like to hear from you.

— The Taniwha team