Preprint · CC BY 4.0 · reproducible from the repository
One claim, and we measured it: grounding is a property of the environment, not of the model. Drop a 12B model into a flat pile of chunks and it scores zero on questions that need a chain. Put the same model in a curated forest it can walk, and it scores perfectly, cheaper per correct answer, on hardware that fits under a desk.
The claim
Take the smartest person you know and hand them eleven questions about your company’s internal documentation, real questions, the kind people actually ask. Now impose the RAG condition: for each question they may read six paragraphs, chosen by a similarity function that saw only the question, and nothing else. No follow-up. No “let me check where that report points.”
They will fail. Not for lack of intelligence, but because those six paragraphs hold the first link of a chain whose remaining links live somewhere else, and the protocol forbids following them. We ran exactly that protocol against a set of strictly multi-hop questions. The model did not hallucinate its way to wrong answers; it did something more damning. Eleven times out of eleven it reported, correctly and uselessly, that the context did not support the question.
Then we removed the constraint. Same model, same corpus, the same eleven questions, but this time it could walk: read a map, smell its options, hop to the next node, follow a cross-reference, open a body only once it was sure. Eleven out of eleven.
That is the whole paper. Everything below is the mechanism that makes the second run possible, and the accounting that says what it cost.
“Nothing about the model changed. What changed was the shape of the world we put it in.”
The problem
Chunk, embed, take the top k, generate. It is the default architecture of most systems deployed today, and four properties of that shape decide the outcome before the model is involved at all.
The bet on which fragments matter is placed before the model has read a word, and it is never revised. There is no second look, because there is nowhere to look from. Chained questions defeat single-shot retrieval structurally, not probabilistically.
Chunking destroys the corpus’s native organisation: folders, sections, cross-references, the table that sat next to the paragraph. What survives is a bag of fragments where a path used to be, and similarity is not a path.
The thousandth query costs exactly what the first one did and lands on exactly the same chunks. A pipeline that answered a question yesterday knows nothing today that helps it. There is no substrate on which experience could accumulate.
Watch a coding agent orient itself: grep, open, read, re-read; minutes and thousands of tokens spent rebuilding context before the first useful decision, every single session. Unstructured knowledge taxes agents even when no retriever is in sight.
On mixed-difficulty questions, classic top-k looks respectable: it is the number a demo shows you. Add the requirement that every question needs at least three chained hops and the score goes to zero. Because the collapse is structural rather than gradual, any evaluation that also contains single-hop questions averages the cliff away and reports a healthy number over a broken system.
The idea
Knowledge lives in a hierarchical, git-versioned graph of markdown nodes. A small model enters through search and forages: it reads passports, follows typed edges, and leaves a trail for whoever hunts next. No animal that lives off dispersed resources runs similarity search over its own habitat.
Every node carries a curated, machine-validated passport: a title, a summary held to a hard sixty-token budget, tags, and a one-line scent for each neighbour. That is what turns a hop into a decision instead of a gamble: the agent chooses which door to open before opening any of them. Every observation is budgeted and says out loud when it was truncated, so “not there” never gets confused with “cut off”.
Edges are curated and typed (this note supersedes that one, this entity owns that incident), not inferred from cosine distance. The forest is a git repository: every write, by a human or by an agent, is a commit. Ask a RAG pipeline why it retrieved what it retrieved and you get cosine similarities; ask a forest and you get a trail you can walk yourself.
A successful hunt deposits heat along the trail it walked and can mint a permanent shortcut link. Heat evaporates on a half-life, so trails that stop paying fade out. The corpus becomes the medium through which agents teach each other, across sessions, without ever communicating: stigmergy, borrowed intact from ant-colony optimisation.
The Forest Principle
“Spend intelligence on the environment so you can spend less on the model.”
The three clauses are independent. Curated structure turns one hard global guess (which k fragments are jointly sufficient?) into a sequence of easy local questions. Stigmergic feedback makes the thousandth query cheaper and better grounded than the first. And the economics follow from the first two: a 12B local model outperforms the architecture a frontier model needs in order to fail politely.
The reflex of the field is a bigger window, a bigger reader, a better re-ranker: intelligence at query time, paid on every query, learning nothing. The Forest Principle moves that spend to ingest time and to structure, where it compounds. It is also modality-independent: anything with a decomposable substrate, cheap curated signals over its parts, and repeated queries whose successes can be recorded is a candidate. The invariant is the rule, not the markdown.
The evidence
One 12B model served locally, one corpus, the same questions, three arms. No frontier-scale model appears anywhere in the paper, and every figure below regenerates from committed scripts in the repository.
11 questions asked
Classic top-k RAG
one shot · six paragraphs
Forest navigator
same model · walking
Numbers from the preprint, §5. The corpus, the question sets and the harness are committed to the repository; every table regenerates with one command.
The honest part
Two of the paper’s findings are failures against their own original criteria, and they are written down rather than dropped. A benchmark you can only pass is not a benchmark.
Trail learning was supposed to cut hops by at least a quarter over repeated exposure. Measured across five passes, hops did fall, by roughly half of the threshold we had set. Criterion: not met. The mechanism was demonstrably working: shortcuts were grafted on the first pass, reinforced without duplicates afterwards, and heat re-ranking stayed stable. The resolution is the finding. Good entry search plus disciplined curation already navigates this benchmark cold in about one and a half hops, and there is no quarter to reclaim near the one-hop floor. Curation and trail learning are economic substitutes; trails need deeper corpora before they can pay.
Walking costs a hop at a time. On shallow questions, classic top-k is faster and perfectly adequate, which is why a zero-LLM one-shot path exists alongside the agent. The deployment rule that falls out of the measurements is to route through the cheap path first and escalate to navigation when the answer smells aggregate, or when the cheap path comes back dry. We are not claiming you should walk everywhere.
The paper is written, versioned and public. It has not been through peer review, and the DOI deposit has not happened yet. We are not going to describe it as anything else. It is published as prior art and as an open invitation to replicate, under CC BY 4.0, with attribution as the only condition.
One benchmark family, generated by us: external multi-hop suites are needed, and the entry-search numbers reward exactly the naming fields our own pipeline curates, which is one more reason external corpora come first. Correctness is scored by substring matching. The headline table has no statistical repeats yet. Our corpora are small, hundreds to thousands of nodes, and behaviour at a hundred thousand is untested. And the learning layer introduced a genuinely new failure class: because heat is not conditioned on the query, a trail worn by one question can lift the wrong node for another. We hit it, traced it, and named it. We have not fixed it.
It takes one command, and it is the whole argument. Clone the repository, build the fixture forest, point it at any OpenAI-compatible endpoint (a local llama.cpp server is enough) and run the bench. If you would rather have a counterparty than a weekend, we do that too.