Open LLM reasoning
Open weights were the first fight, and it's largely won: you can download a frontier-adjacent model, run it on your own metal, and nobody can take it away. But watch what happens the moment those open models start working. Every agent, on every machine, grinds out the same chains of reasoning — grounding the same claims, weighing the same evidence, deriving the same conclusions — and then throws all of it away when the context window closes. The weights are open. The reasoning they produce is exhaust.
That's the strange asymmetry of this moment. We collectively spent billions making model capability a commons, then let every unit of model work evaporate on private machines. Closed labs at least recycle internally: your conversations become their training signal. The open ecosystem doesn't even do that. Each open model instance reasons alone, from zero, forever.
Reasoning as an artifact, not exhaust
Open LLM reasoning is the missing second act: treat a completed piece of reasoning as a first-class artifact — distilled, signed, addressable — that another agent can find, verify, and reuse instead of recomputing. Not raw chain-of-thought scraped from a transcript, but the resolved trace: the claim, the evidence it grounded on, the verdict, and who signed it.
Three properties make a reasoning trace safe to share, and all three are enforceable, not aspirational:
Signed. Every trace carries the Ed25519 signature of the peer that produced it. A model can refuse what it can't trace to a named hand — that's the difference between a commons and a poisoning surface.
Eligibility-gated. A trace is only served when it clears a relevance threshold for the incoming question. Below the bar, the requesting agent falls back to its own model. Wrong reuse is worse than no reuse, so the gate is strict by construction.
Private by default at the query layer. Peers see what was served, never what you asked. Query text never enters the shared feeds; only node ids and counts travel.
Measured, not promised
This isn't a roadmap slide — it runs today, over real transport. Two folklore processes on separate machines, TCP with Noise encryption, a CPU-only 3B model on the consumer side, SciFact-labeled claims as the workload: the consumer pulled three signed traces from its peer, all three verified, all three reused correctly, and the local model never had to run — 1,938 tokens and 24.5 seconds of model eval avoided, with reuse decided in about 14 milliseconds end-to-end. Zero false reuse; ineligible traces rejected at the gate.
Scale the same mechanism to a small network and the economics get louder: in a four-peer run, once traces persisted and federated, 75% of all repeat LLM fallback calls were avoided — again with zero false reuse. The network converges on doing each piece of reasoning roughly once, then serving it from memory at millisecond cost. That's what "open reasoning" means operationally: the marginal cost of an already-answered question trends toward a fetch.
Why open, and not a platform
You could build this as a hosted service — a big shared cache with an API key. That recreates exactly the thing open weights escaped: a central owner of the commons, able to meter it, mine it, or shut it off. Folklore's answer is structural: there is no central server to own. Traces sync peer-to-peer over a CRDT; provenance lives in the signature, not in an account database; a private flag on a node is enforced at the sharing layer, so what stays local stays local. The reasoning commons belongs to the peers who produced it, the way it should have from the start.
Open weights made intelligence something you can hold. Open reasoning makes the work of intelligence something a community can keep. One is a download; the other is folklore — knowledge that survives because peers pass it on, signed by whoever ground it out first.