One thesis, two worlds

Last week's post ended with a promise dressed as a prediction: “nothing in the contract says the world has to be made of rock… worlds made of code. Deterministic, rewindable, checkable down to the last fact.”

This week we built one. Out of our own codebase. And then we started charging it rent.

The same question, a different world

Ask a procedurally generated planet “what's here?” and any decent engine can answer: a chunk of coal. Ask it “why?” and almost all of them go silent — the mountain is there because a noise function said so. Kano can answer why because its worlds are grown through causes: a forest stood here, an earthquake buried it, pressure did the rest. The why-chain exists because the world was made of causes in the first place.

Here is the same why verb — same interrogation grammar, same MCP surface — pointed at a file in our engine repo instead of a location on a planet:

why crates/.../tipu.rs  (identity 1e4df827:.../florasynth.rs):
  1. 2026-07-08 6489fdc7  feat(flora): rainforest paradox - leach fertility...
  2. 2026-07-07 f4ce58f1  feat(flora): CSR adaptability budget, flower pins...
  ...
because: created in 1e4df827 (2026-06-25) - "feat(florasynth):
  `grows` verb - what-grows-here as botanist build calls",
  born as florasynth.rs; 25 recorded events since.

A numbered evidence chain, followed through a rename, terminating at a real commit. Forest → earthquake → coal; resonator → extraction → tipu. Two worlds, one verb.

The thing answering is called codeworld: a deterministic projection of a repository's history into a small, inspectable world an AI agent can query. Same commit in, same bytes out — every time, on every machine. Files keep their identity through renames. Every answer carries the provenance it was computed under. And “why” chains end at verifiable commits or say unrecorded — they never invent intent.

Why determinism is the whole point

Modern coding agents don't usually fail because facts are missing. The facts are all there, in git, perfectly preserved. They fail because every agent, every session, every subagent improvises its own reading of those facts — which files matter, what changed, what's stable — and no two improvisations agree. Each reading is private, unverifiable, and slightly different from yesterday's. Over a long project, that drift compounds quietly.

Model-side improvements raise the odds a reading is good. None of them make two readings agree. Guarantees aren't probabilities — and shared ground that two agents can check each other against has to be a guarantee.

So codeworld is deliberately boring where it counts: the derivation pipeline contains no AI at all. It is ordinary, versioned, deterministic code over git. Think of it as a lockfile for interpretation: your manifests never change either, but you still lock resolution, because letting it float means two builds of the same source disagree.

What we measured — and what broke

We ran this as an experiment, not a demo: disproof criteria pre-registered before any results existed. Across four codebases in four languages and development cultures (a Rust engine, two production platform repos, an enterprise C#/TypeScript system):

Determinism: dozens of byte-identical double-derivations, including the nastiest commits we could find — a 306-file refactor, rename storms, binary churn, merge-heavy history. Locality: across hundreds of adjacent-commit pairs spanning entire histories, a commit never changed the world beyond what it touched. When 79 commits of real work landed in one day, the world's diff was 26 entries out of 236 — and it named the theme of the work unprompted. Identity: zero losses across every rename either git or we could find. Consistency: three independent agent sessions — on two different models — asked the same six questions of the same world and returned byte-identical answers, down to a six-decimal float.

And because honest instruments keep honest ledgers: our own pre-registered tests caught the instrument lying six times — a platform encoding bug on the second-ever test run, calibration values leaking through a docstring, symlinks read from the filesystem instead of the tree. Every defect was found by a test or an adversarial review, fixed by definition rather than workaround, and logged. Twice we found the documentation was wrong about the code. The record of what broke is part of the result.

What we are not claiming

Codeworld is not semantic search, not a call graph, and not “AI memory.” It does not remember meaning — it measures structure and churn. For a single agent in a single session, plain git is often faster and richer, and we say so in our own docs. The claim is narrower and harder: when more than one mind — or one mind across many sessions — has to stay coherent about a changing codebase, improvised readings drift and pinned ones don't.

And the biggest question is deliberately still open: we have not yet shown that agents produce better work over long horizons with this than without it. The ground is provably solid. Whether anyone falls without it is an empirical question, and we treat it as one.

The rent experiment

So this week we started charging the thesis rent. The tool is registered in the daily working environments of three people — including our most reliable skeptic — across nine repositories, with a rule we imposed on ourselves: no nudges. Nobody is told to use it. The agents discover the tools in their toolbox and choose, or don't. At each day's end we log — honestly — what got used, what got ignored, and where plain git was simply better.

The failure condition was written down before the first session. We'll quote it, not paraphrase it:

Consult count ≈ 0 after three real working days → the rent signal is negative. That result is accepted in advance: redesign the surface before any controlled trial; do not explain it away.

We'll publish the verdict either way. If our own tool doesn't earn its place in our own sessions, you'll read that here too — because the entire point of building ground truth is that you don't get to argue with it.

Kano came first. The codebase is the second world. The thesis says any causally-recorded system can be next — and if you're building agents that need somewhere real to stand, we'd like to hear from you.

— The Taniwha team