Every Wall Forces a New Machine

The history of computing is not one machine getting faster. It is a sequence of different machines, each born when the last one hit a wall it could not climb.

A wall forces every turn. There are three kinds, and the turn is defined by the one it answers.

Most turns answer one wall. Some answer two at once. Naming which wall forces the turn is the entire discipline, because the next machine is defined by the wall it answers. Get the wall wrong and you get the machine wrong.

Underneath every one of them runs the same motive: we build machines to imagine the world. For fifty years our algorithms were our model of reality, and the computer ran that imagination faster than reality could unfold.

Attention is an index.
And the index thins.

The transformer is the best interpolator we have ever built. Inside the dense interior of its training distribution it composes, generalizes, and reasons. That capability is bought against the density of the data, and it thins exactly at the sparse frontier where real engineering and real discovery live.

The gradient is real, and it holds at every scale. Performance falls off as the work moves toward novelty, and more parameters have never flattened that curve. A bigger model pushes the cliff further out, then drops off beyond it the same way. The edge moves. It does not close.

The index does not fail loudly. It fades, precisely where you needed it most.

Approximation, under many names

• Reduced precision: FP32 → FP16 → BF16 → FP8 → FP4, now standardized as microscaling (MX) formats and shipping in silicon. Blackwell does FP4. Most of the last five years of efficiency gains are approximation under another name.
• Analog and in-memory compute: Do the matmul where the weights already live: memristor crossbars, compute-in-SRAM, PCM. Inherently approximate, an order of magnitude more efficient on the MAC core, with the system win bounded by data conversion and variability.
• Conditional computation: Do not compute what you do not need. MoE routing, activation sparsity, early exit. Approximation as less work, not less precision.
• Stochastic computing: Values as bit-streams, where multiplication is an AND gate. Cheap and noisy, with precision that costs stream length. Resurging at the edge.
• Approximate then verify: Speculative decoding. A cheap draft proposes, the expensive model checks, the result is exact. The pattern that unifies all of the above.

Approximate where you can. Be exact where you must. Let a verifier mark the boundary.

That boundary is not arbitrary. Be cheap where the work is bulk and forgiving, in matmul precision, proposal generation, and raw throughput. Stay dense and exact where novelty is actually produced, and where it is verified. The calculus has flipped, because the dominant workload is now energy-bound, error-tolerant, and paired with cheap verification.

Grounding, not architecture

What escapes the index is not a new architecture. The paradigm, autoregressive or diffusion or state-space, is a distraction. What escapes it is two things at once: a generator with enough reasoning widthto reach a novel-correct candidate, and an external oracle that can certify it. A transformer only models the distribution it was shown, so it cannot certify its own novelty, and the oracle cannot invent what the generator never proposed. Capacity is the floor. Grounding is the moat.

In silicon, that oracle is the simulator. RTL is generated, then run against a testbench it did not author and cannot see, and the mismatch drives the next revision. Not the prior. The mismatch. This is the one claim a competitor cannot answer by scaling a model or swapping autoregression for diffusion, because their loop closes against the model and ours closes against reality.

This is where the world model earns its keep. The oracle is the truth, but it is too expensive to sit in the inner loop at SoC scale, so the world model is the cheap surrogate the system plans and prunes against, proposing and scoring moves at speed, while the exact oracle is called only to confirm. Expensive oracle, cheap surrogate. The loop is old: a learned surrogate plus an exact verifier is Bayesian optimization, learned cost models, RL for placement. What is new is the target. This is not PPA optimization of human-written RTL against a cost model. It is correct logic synthesized from intent, conjured from a plain spec and graded against a frozen functional oracle it has never seen.

It resolves the efficiency wall cleanly. The generation can be approximate and cheap in its arithmetic, a wide model at low precision proposing candidates, because the verification is exact. Approximate where you can, exact where you must, and the oracle draws the line.

We did not forecast the next machine. We built it, for silicon.

• A plain-language spec goes in. Synthesizable Verilog and SystemVerilog come out.
• A testbench is written and frozen before the RTL, so every design is graded against reality, not against its own guess.
• Each candidate runs on real EDA tools. The mismatch with the simulator drives the next revision.
• A world model and an RL brain plan the next move, instead of retrying blindly.
• A knowledge base of verified RTL patterns grounds the work, and decomposition carries it from a single block to a full SoC.
• The system is agentic to the core. Autonomous agents own each step, so it expands and adapts on its own. New tools, targets, and strategies plug in without a rewrite.