A talk · Greg Magarshak
We are burning billions to push a model from a 9 to a 9.5, while the factor it multiplies against sits untouched at a 2.
The shape of the argument
Cached search — paid once, at training, then redeemed almost for free at inference. And live decision — the loop that composes those cheap redemptions, explores, and aborts when it is out of its depth.
The base model is the cached search. The substrate — harness, graph, certified experts, workflows — is the decision layer. Capability is not the sum of these. It is the product.
Turn the 2 into a 4 and you doubled. Push the 9 to 9.5 and you bought 6%, at a cost of billions.
It is the same error, five times
Every one of these fields built a system to pay the worst-case cost everywhere — when the worst case is rare, and the typical case is cheap. The theorem is true. It is just rarely binding.
The mistake, in four words:
Layer 1 must solve everything.
Don't. Add a layer that handles the smooth 99% cheaply and certifiably escalates to L1 only at the rare singularity. Lightning for payments. Eventual consistency for reads. Zip for files. The substrate for inference.
Why it works — ground to root
This is LAWS — Learning from Actual Workloads Symbolically: a self-certifying parametrized cache above any trained model, experts created from observed inference and certified by the model's own Lipschitz constant, the base model running only on genuine misses. KV-caching and Mixture-of-Experts fall out as degenerate special cases.
The question I couldn't answer until now
For a long time I thought the expert was a distillation — a cheaper copy of the oracle's existing knowledge. That view is what motivated the prior work: compress the oracle's own computation (KV / PLT), or train a small model to replace the oracle on a workload (SGT). Both treat the oracle as the source of truth and the expert as a compression of it. Under that view the expert's ceiling is the oracle, and the only win is cost.
The expert is not a distillation of the model.
It is accrued, self-certifying domain knowledge the base model never had.
Grokers does not distill the model. It ingests a specific codebase and builds the graph of that domain's structure — this framework's call graph, these types, these conventions — knowledge the base never saw. The expert is the base's general reasoning applied to install structure about a domain it lacks, which then self-certifies (duck-typed vs. not, this framework vs. that) and updates as the domain shifts.
That changes the type of the object. The old view: expert ⊆ oracle, ceiling is the oracle, win is cost. The correct view: expert ⊄ oracle — it holds structure the oracle lacks, so on its ball it can be better than the oracle, because it is the oracle's reasoning times accrued domain knowledge. Not cheaper intelligence. Additive intelligence.
It is the stove-burn, in code: the coarse model predicts most code fine, hits a domain it doesn't know — the Lipschitz violation — and an expert is installed, certified, final, updated occasionally. So the lineage re-sorts: KV and SGT are about the engine (caching or replacing the oracle's own computation); the LAWS expert is the rig — the accrued domain layer on top of whichever engine you use, holding what neither the cache nor the replacement contains, because it came from the deployment domain, not the oracle.
The engine reasons. The rig knows.
And the rig is where the deployment-specific intelligence accrues — which is exactly why you don't need a heavier engine.
The honest seam: the expert installs knowledge the base lacks; the reasoning over it is still the base's. So "expert beats the bigger model" holds where the win is domain structure the bigger model also lacks — and is contested where superior reasoning over the same structure wins. Which is, again, the eval.
Two attacks, one conclusion
JEPA predicts in representation space, discarding the detail layers — smaller models, quantizable, as good or better, because the detail was never load-bearing. That is the cancellation insight on the representation side: model the smooth manifold, not the noise.
The substrate is the complement on the exploration side. The missing intelligence is the exploratory, expert-installing loop — and you generate it by running the existing model in a baby-animal exploration loop during grokking. No new training. No bigger model.
LeCun makes the representation cheaper. This makes the exploration cheaper.
Both say the marginal scaling dollar is buying the wrong factor.
The honest boundary
"You only win locally" is not an objection. It is the design. A certified expert claims validity in its ball and hands back to the base model everywhere else. The claim is bounded, and the boundary is the credibility.
Strong primitives, undersearched combination space, with a cheap verifier to prune bad branches — the AlphaZero shape. Math. Code. Structured frameworks. Here, exploration over a fixed base reaches the frontier, and scaling the base is overkill.
Verifier-poor domains — open judgment, ill-posed problems — where the loop can amplify confident error as fluently as insight, and a better base may genuinely raise the ceiling. This boundary is empirical, not settled from the armchair.
Which is exactly why the move is an eval — not a manifesto.
The bet · one falsifiable line
The claim, testable
Grokers + Opus, on frameworks in non-duck-typed languages, can outperform Claude Code + the next bigger model — at ~95% lower inference cost, with error low enough for genuine no-human-in-the-loop operation.
Code is the ideal ball precisely because it is verifier-rich — types, tests, compilation. Cheap verification is what lets the loop run unsupervised and compound. And code is the thing that builds other things: more cheap, correct code is more capability, 24/7.
Today's models are trained once, frozen, and deployed static.
They don't learn on the job.
Dropped into a new codebase, a new domain, a new task — they rediscover nothing. Every deployment starts from the same frozen weights. The structure of the specific domain they're working in is never captured, never accrued, never kept.
That is the missing capability — not "the model isn't smart enough," but the system doesn't learn from its actual work. What's needed is autonomous discovery of domain knowledge through the workload itself — the job is the teacher — accrued with finality, and shared across the fleet so each discovery is paid once and propagates to all.
So maybe the goal isn't AGI — one universal system.
Maybe it's intelligence almost everywhere: learning to be good on the job, in every domain it's dropped into.
A growing union of certified balls, each accrued from real workloads and shared across the fleet — not a single frozen model. That is the Safebots plugin: the layer that turns a static engine into a system that gets better at each domain by working in it.
How to prove it
The eval is credible because it is built to come out against the thesis at the edge. Showing where it breaks is what makes the part that holds believable.
What this reframes
The model is the engine — swappable, and getting commoditized. The substrate is the rig — the durable layer any engine clips into. Most of the field is racing to build a slightly better engine. The rig is sitting at a 2.
And the rig is also the safety layer: propose-don't-execute, certified abort, governed orchestration. The thing that makes an agent capable and the thing that makes it safe are the same architecture. Building it is the same work.
The jump · what the rig really is
Drop a brilliant generalist into a new company, a new field, a new community. They can reason about anything — and they know nothing about here: not this codebase, not this org's way of doing things, not this domain's hard-won exceptions. General capability, zero local knowledge.
What a culture passes down to that generalist is exactly the rig: institutional memory, best practices, the accumulated "we tried that, it doesn't work," the norms — and the morals and ethics of that culture. The stuff a new hire absorbs in their first year, not from training, but from the work and the people.
Culture is accrued, certified, fleet-shared exception-knowledge installed at the singularities of a domain.
This is not a metaphor — it is the same object. Culture is accrued from real experience, not taught abstractly. It is installed at singularities: norms are mostly exceptions — "in general do X, but here, because of the thing that once burned us, do Y." Norms are the stove-burns of a community, encoded so the next person doesn't have to get burned. It is shared across the fleet — transmission of culture is the fleet-sharing of installed experts, each lesson learned once and propagated to all. It is final, with occasional revision. And crucially, it does not change the underlying genius. Culture doesn't make you smarter in general; it makes you good here. The engine is the engine before and after. The culture is the rig on top.
The field keeps asking: how do we put the right values into the model — train them into the weights, hope they stick, where no one can read them? A culture has never done it that way. It instills its ethics into its members as accrued norms, installed at the moral singularities — here is where people get hurt, here is the line — transmitted and kept.
So the values go in the rig — legible, gated, revisable —
not smeared into the engine where no one can read them.
You don't align a genius by surgery on its inscrutable weights. You install the culture — including its ethics — as an accrued, certified, governed, inspectable layer on top, the way every culture has always done it with its own geniuses. The safety-relevant layer and the culture layer are the same layer. And it is the readable one.
The end goal
The feared end state is recursive self-improvement — the optimizer rewrites the optimizer, the target moves, and there is no fixed surface a defender can reason about. It is the capability everyone fears and no one can secure.
The substrate points somewhere else: continuous directed evolution. The model stays fixed. A vetted toolkit of certified experts grows by composition, accrued from real workloads, gated by humans and a static check. It reaches almost the same ceiling — the ninety-nine percent that is real work — by a route that turns defense back into something as tractable as a compiler pass.
RSI rewrites itself in the dark.
CDE grows in the light, under a gate, where a defender can read it.
Capability rises with the combinatorial closure of approved tools; danger does not, because the new capability is composed from vetted parts under a static check. The same architecture that makes the system learn on the job is the one that makes it defensible. — the full argument