The Silicon Thesis · Intelligent Silicon
Every strange fact about the AI economy — collapsing prices beside widening losses, the geopolitics of a memory chip — resolves under one correction. Inference is priced as a cloud service. It is actually a good whose costs are silicon and joules.
The case
The argument, in seven parts.
From the joules inside a single token to a chip a jurisdiction can hold. Read it straight through, or jump to the part you came for.
- 01The DiagnosisInference is priced as a service, but almost none of what you pay for a token pays for thinking. Follow the joules.
- 02The Physical AnswerEtch the model into silicon. The weights stop moving; the memory hierarchy is deleted, not optimised.
- 03What Gets EtchedPrint the prior, stream the state, route the novelty — and the recipe that shapes a model for the die.
- 04The SiliconOne ladder, from a thumbnail of ROM to the sovereign stack. The die, the wafer, the respin.
- 05The EconomicsThe payback clock: spot prices race toward a physics floor the manufacturer already stands on.
- 06SovereigntyThe escrow clause and edge sovereignty — a nation’s intelligence as masks in a vault it controls.
- 07Why NowThe window is a gap between proofs, and seven gates that must hold before any mask is cut.
Part I · The Diagnosis
A category error, priced.
Read the AI market as a cloud service and it is incomprehensible: prices collapse while providers lose money, and supply is rationed by the politics of a memory chip. Read it as a manufactured good — one whose costs are silicon and joules — and each anomaly becomes ordinary industrial economics.
Part I · The Diagnosis
The hidden mechanics of a token
What does a token actually cost to make? Follow the joules, and you find the money is spent not on thinking but on shipping — and the thing being shipped never changes.
- Arithmetic — the actual thinking ~1 pJ
- Moving the weight to the compute ~300 pJ
- System overhead ~60 pJ
On a GPU the weight is fetched from off-chip memory every token, forever — the bill dwarfs the work by a factor of hundreds. Data-movement dominance ismeasured, not modelled.
Figure 1: The joule waterfall of a served token. Arithmetic (~1 pJ) is the work; weight movement (hundreds of pJ) is the bill; system overhead is the residue. The ratios are modelled; that movement dominates is measured.
Follow the joules
What does a token actually cost to make? Follow the energy. A low-precision multiply-accumulate — the single fused multiply-and-add that is the atom of inference arithmetic — costs on the order of one picojoule (a trillionth of a joule). Fetching the weight that feeds it from off-chip memory costs on the order of hundreds of picojoules.
The ratio, not the absolute numbers, is the whole story — and it is measured, not modelled. Studies of production inference confirm that data movement, not arithmetic, dominates the energy of serving a language model. A modern GPU spends the great majority of its power budget not computing the answer but transporting the model to the computation: every layer, every token, every time.
Everything follows from one imbalance
Because the weights must stream from memory before any math can happen, the memory's bandwidth becomes the binding constraint. This is the memory wall — the point where the chip sits idle waiting for data to arrive.
Because the wall binds, the industry buys the fastest memory that exists: HBM, or high-bandwidth memory — DRAM chips stacked vertically and wired directly beside the processor. It is exotic and supply-constrained, so it becomes the geopolitical chokepoint. And because moving each weight is expensive, providers batch many users' requests together to share the cost of one fetch across all of them, trading your individual speed for the fleet's throughput. The whole tower stands on moving data that never changes.
The category error underneath it
Here is the buried absurdity. Inference weights are constants. They are written once, at the end of training, and then read — billions of times, unmodified — for the entire life of the deployment. Nothing about them ever changes when you serve a token.
Yet the industry stores its one great constant in the most expensive variable storage ever manufactured, and pays refresh power, leakage power, and allocation politics for a mutability it never once exercises. The HBM shortage is a tax on mutability that inference never uses.
A constant needs a location, not a vehicle
Stand back and the shape of the problem is simple. The expensive part of a token is not thinking; it is shipping. The thing being shipped never changes. And a constant that never changes does not need a vehicle — it needs a location.
That single reframing is what the rest of this thesis builds on. If the weights are a fixed function, why keep paying to move them? Etch them where the computation happens, once, and the joule waterfall collapses. The GPU does not compute intelligence expensively; it ships intelligence to the compute expensively, forever, one token at a time.
The GPU does not compute intelligence expensively; it ships intelligence to the compute expensively, forever, one token at a time.
The takeawayThe expensive part of a token is not the arithmetic; it is transporting the model to the arithmetic — and the model is a constant we store in the most expensive variable memory ever made.
The memory wall, in 3D
Watch the weights move — forever.
Part I · The Diagnosis
The wave meets the grid
Token demand is not on the internet's gentle curve. It is on a thousand-to-ten-thousand-fold climb that, at today's energy per answer, runs straight into the national grid.
The wave meets the grid
Demand is a rising exponential. Capacity, at a fixed power budget, is a flat ceiling — it climbs only with efficiency. The band between them is rationed.
- Efficiency vs. status quo
- 1.0×
- Capacity ceiling modelled
- 67× today
- Base-case wave, 2032 modelled
- 1,000–10,000×
At today's 60 mJ/token the grid meets a sliver of the base-case wave — the rest is rationed by price, by queue, by jurisdiction. Drive the energy down toward the etched floor and the same wall power serves an order of magnitude more of the curve. Efficiency, not more grid, closes the gap.
Token demand (the base-case 1,000–10,000× climb by 2032, log scale) plotted against grid-limited serving capacity at today's joules per token. The shaded gap is not optional: either joules per token fall by orders of magnitude, or answers get rationed.
The demand side is the whole problem
Token consumption is not growing along the gentle curve of past internet services. Agentic workloads — where a model plans, calls tools, and checks its own work across many steps — multiply the tokens per task by orders of magnitude. Reasoning models alone, the ones that 'think' before answering, have raised consumption on some workloads a hundred-fold.
The wave this thesis plans for — a thousand to ten thousand times today's volume by 2032 — is the base case, not the extreme. That single fact turns the cost of a token from a commercial line item into a civilisational one.
Run the arithmetic and rented FLOPs fail
A token today costs somewhere in the tens to hundreds of millijoules to serve on general-purpose hardware — the thesis models about 60 mJ, with wide error bars. Multiply that by wave-scale volume and the number stops being an energy bill and becomes a wall.
Projected datacenter electricity demand already strains against how fast new generation can be built, and inference is the compounding term — the part that keeps growing with every extra user, agent, and reasoning step. The wave collides with national grids.
So the answers get rationed — unless the physics changes
This is the fork the whole thesis hangs on. Either the joules per token fall by orders of magnitude, or the answers get rationed: by price, by queue, or by jurisdiction. There is no third door where demand at this scale is met at today's efficiency.
Rationing is not hypothetical austerity. It is what a grid-limited system does automatically when it cannot serve everyone — it charges more, makes you wait, or serves some countries and not others.
Where the certified silicon sits
Geography follows the same forcing. Training already migrates to wherever power is cheap. But a manufactured token — an answer produced by a model etched into a chip rather than streamed from a rented cloud — obeys a different logistics. It moves to wherever the certified silicon physically sits.
That means a national datacenter, a workstation under a desk, or — because a printed model can run from a solar panel — places the grid has never reached at all. Sovereign buyers have already begun procuring on exactly these terms, with custody language attached and money committed.
The wave does not negotiate with the grid. But an answer produced where the power already is has nothing to negotiate.
The wave does not negotiate with the grid.
The takeawayEither the joules per token fall by orders of magnitude, or intelligence gets rationed by price, by queue, or by jurisdiction.
Part I · The Diagnosis
The fixed-function precedent
Silicon has frozen an economically vital function before, more than once, and general-purpose hardware lost every time. A trained model, weights fixed, is the same kind of object: a deterministic function waiting to be printed.
Silicon has done this before
The semiconductor industry has run this experiment at scale, with public results. When Bitcoin's proof-of-work froze a single function, SHA-256 (the hash that secures the network), into permanent economic importance, silicon specialised against it. The efficiency of computing that one function improved by orders of magnitude within a decade.
GPU mining, the general-purpose incumbent, did not decline gracefully. It went extinct within months of the first ASICs shipping. An ASIC, an application-specific integrated circuit, is a chip that does one job and nothing else, and that focus is exactly what let it wipe out the flexible chip overnight.
The same fleets, operators, and power-site discipline that mining built are now converting to AI workloads in a multi-billion-dollar wave. Fixed-function infrastructure converts, and its operators outlive any one function.
The standing objection
But mining froze a function that never changes, and that is where the analogy seems to break. The familiar rebuttal is that AI workloads don't freeze: models improve monthly, architectures turn over yearly, and freezing a model into hardware means shipping obsolescence.
Part of the answer is economic. A weight update is a metal-layer respin, costing about a million dollars and taking weeks, not a whole new chip. A respin re-etches only the thin metal layers that encode the weights, leaving the roughly 99% of the mask set that defines the circuit untouched. Obsolescence becomes a product line, not a stranding event.
But the deeper answer is conceptual, and it changes what kind of object a model is.
A model is already a frozen function
A Bitcoin ASIC prints a human-written function. An etched model prints a learned one. The difference is semantic, not industrial.
Consider what a trained model actually is once training ends. Gradient descent has searched a space of programs and returned one: a fixed composition of linear maps and nonlinearities, specified to the last parameter. Fix the weights, the sampling seed, the step schedule, and the conditioning interface, and the model is a deterministic function. The same input produces the same output, bit for bit, forever.
It differs from SHA-256 in what it computes, not in what kind of thing it is. One maps a message and a nonce to a digest. The other maps noise, a prompt, and a schedule to a paragraph, a triage decision, a translation. Both are fixed functions repeated at civilisational scale.
Print the prior, stream the state, route the novelty
The quiet proof is the video codec, the compression standard baked into every phone. Committees revise codecs every few years, yet that cadence never kept decoding in software; it created generations of codec silicon instead. The learned function's revision cadence is faster, and its silicon revision cost is smaller, because a model update touches masks, not architecture.
So the rule is mutability discipline, not etch-everything. A function earns its silicon to the degree that it is stable and endlessly reused. What changes with every input stays in software. What is genuinely new is sent elsewhere.
Three words carry the architecture of everything that follows: print the prior, stream the state, route the novelty. Concretely: the grammar of a language is the prior; this conversation is the state; a case no model has seen is the novelty. The prior is the stable, expensive operator, a language or a procedure. The state is the live, compact, per-request context. The novelty is the case the prior has never seen. Once a deterministic function becomes economically important enough, it stops being software and becomes silicon. Gradient descent has been manufacturing such functions for a decade; lithography simply hasn't caught up.
| Function | Input | Repeated operation | Output | Silicon form |
|---|---|---|---|---|
| SHA-256 | message + nonce | compression rounds | digest | mining ASIC |
| Video codec | frame stream | signal transform | media | codec block, in every phone |
| Seeded diffusion | noise + prompt + schedule | denoising rounds | image, latent, artifact | learned-function ASIC |
| Competent inference | context + retrieval + policy | neural block transition | answer, action, route | the etched model |
A deterministic model is already a frozen function; it just hasn't been printed yet.
The takeawayA trained model with fixed weights is a deterministic function, no different in kind from SHA-256 or a video codec, and every economically important fixed function in computing history has ended up etched into silicon.
Part II · The Physical Answer
The model as a manufactured good
A GPU stores a model and pays to move it forever. Print the weights into metal and the model stops being data you transport and becomes an object you own — the entire memory hierarchy simply disappears.
Three ways to hold a constant
A model's weights are a fixed constant it must consult for every token. Each architecture pays for that differently — select a column to see its bill.
ROM interleaved with adders: the read and the compute are one event. Nothing moves, nothing leaks — idle draw is essentially zero.
Three ways to hold a constant: the incumbent transformer ASIC keeps the full hierarchy (N4P plus 144 GB of HBM3E) and pays to cross the bus forever; wafer-scale SRAM holds the constants on-chip but pays leakage to keep them; the etched model interleaves ROM with adders, so nothing moves, nothing leaks, and idle is free.
A GPU stores a model. It never stops paying freight
Etch the weights into mask ROM and the object changes category. Mask ROM means the values are baked into the chip at manufacture, in the metal itself, exactly as a photo mask patterns them; nothing can rewrite them afterward.
A GPU stores a model. The model is data, endlessly transported to the compute that consumes it, and every generated word pays the freight of hauling weights across a bus. A printed model chip is the model. The weights are a spatial arrangement of the compute itself, a pattern in metal and vias, and there is nothing left to transport.
Both memories leave the die, not one
Around a GPU sits an elaborate machinery whose only job is to move the unmoving: HBM (high-bandwidth memory, the tall stacks of DRAM beside the chip), DRAM controllers, cache towers. On an etched card that entire hierarchy is not tuned down. It is deleted, because there is nothing to move.
Both memories leave the die, not one. The first is the weights, which become lithography — a pattern in metal rather than a payload in DRAM. The second is the KV cache. An autoregressive model writes one token at a time, and to avoid recomputing the whole sequence on every step it keeps a running per-token memory of everything it has said so far: that store is the KV cache. It grows with the conversation, lives in the same scarce HBM the weights are streamed from, and gets re-read on every single token. Watch it grow below.
On an etched card the KV cache is gone too, because a bounded-state model has no such cache to keep. Long context arrives instead as conditioning, compressed by the host and streamed in as a bounded object. The only memory left on silicon is the bounded state of the current thought.
The density physics rests on measured silicon
Here is the one place the physical case rests on a real 2026 silicon measurement, not a model. A ternary read-only-memory study puts numbers on it. Ternary means each weight is one of three values, minus-one, zero, or plus-one, so it stores densely and skips the zeros for free. The study measures 15.0 MB per square millimetre at a roughly 70 percent zero-weight ratio, 3.3 times the density of SRAM on the same node, with 200 TB/s of on-chip bandwidth.
For calibration, 200 TB/s is roughly forty times the bandwidth of HBM, the memory GPUs fight over — available here without a single off-chip wire, because the memory read and the computation are the same physical event. The thesis keeps its own working figure conservative against this measurement by a factor of 1.5 to 2 times, and holds the difference as margin.
Sort every bit by how often it changes
The design rule that organises the whole machine is a mutability audit. Sort every bit the system holds by how often it changes, and place it in the cheapest technology that mutability permits. The weights, which change only per generation of the chip, live in mask ROM. State in flight lives in on-die SRAM. Conversation context lives in commodity DDR on the host. Facts and records live in retrieval, outside the die entirely.
Nothing on the die is writable except a block buffer and a small signed island. There is no weight state to poison, no exfiltration path wider than the answer itself, and no idle draw, because a ROM holds its bits for free. The artifact costs nothing between questions and is instant-on when one arrives.
The right unit of comparison changes with it
With the hierarchy goes the right unit of comparison. Not FLOPs, which measure a general-purpose machine's potential, but lifetime useful outputs per wafer-dollar and watt, which measure what the artifact was actually built to do.
The audit is not particular to language. Run the same sort over a generative world model and the proportions only sharpen: the mutable scene state is megabytes, while the world prior it decodes against runs to terabytes per second of weight traffic, the identical tax, one domain over. The near-term artifact is the language model in front of us; the law it obeys is general.
| What the bit is | How often it changes | Where it lives |
|---|---|---|
| The operator: the model's weights | Per generation | Mask ROM, shell and residual planes |
| The routing (sparse generations) | Per generation | Wires and an argmax — no memory at all |
| State in flight: the block buffer | Every cycle | Megabytes of on-die SRAM |
| Task adapters | Per signed update | A small, signed SRAM island |
| Conversation context (KV cache) | Per request | Commodity DDR on the host |
| Knowledge: facts, records, curricula | Continuously | Retrieval, outside the die entirely |
A GPU stores a model; a printed model chip is the model — the weights are a pattern in metal, and there is nothing left to transport.
The takeawayWhen you etch the weights into metal, the model stops being data you haul to the compute and becomes the compute itself — the memory hierarchy is deleted, not optimised, and the object changes category from a hosted service into an owned, manufactured good.
The memory that grows with the conversation
That memory is HBM — and it is the scarce good the whole industry queues for: up 200%+ since early 2025,23% of all DRAM wafers now reallocated to it, supply locked through 2027.Silicon Analysts · TrendForce · Tech-Insider
The artifact
A model you can hold.
Part II · The Physical Answer
Why regulators will demand a frozen artifact
Sovereign buyers are already writing custody into their contracts — money and language attached, ahead of any deadline. What they need is a model that cannot drift, because drift would require a fab.
§7 · Figure 4
The certification calendar
High-risk conformity was deferred to Dec 2027 andAug 2028. That gap is not a reprieve — it is abuild window: enough time to print, respin and certify an etched artifact before an audited, documented model becomes the only shippable form. Dates are reported.
The EU AI Act calendar and the build window: prohibitions (Feb 2025), GPAI obligations (Aug 2025), the penalty regime (2 Aug 2026), and the deferred high-risk conformity deadlines (Dec 2027 stand-alone, Aug 2028 embedded). The Digital Omnibus lengthened the window; sovereign procurement, not the deadline, is the near-term forcing function.
How regulated things get bought
Regulated intelligence will be bought the way regulated everything is bought: as a certified, version-locked artifact. That is not a marketing preference. Five structural conditions force it, and none of them is speculative.
Conformity assessment — the formal check that a product meets a legal standard — needs an unchanging object to assess. Procurement law needs an auditable artifact to specify. Liability needs determinism: the same input yielding the same output at the same version. Sovereignty needs physical custody of the thing licensed. And post-market surveillance — the duty to keep watching a product after it ships — needs a version lock, because an artifact that silently improves is also an artifact that silently changes.
A hosted model, updated at the provider's discretion, fails all five by construction. You cannot certify, procure, insure, hold custody of, or surveil a thing that quietly becomes a different thing overnight.
A model that cannot drift
A lithographically frozen model, its weights etched into metal on the die, is the only form of the technology that cannot drift, because drift would require a fab. Changing the weights means a new photomask and a fresh run through a semiconductor foundry, not a silent push to a server.
One clarification keeps the claim honest. Immutability satisfies the artifact-side conditions; it does not complete a dossier. The process obligations of a conformity regime — data governance, human oversight, post-market monitoring — still live in the host and retrieval layers, where they belong. The frozen artifact removes drift from the assessment problem. It does not remove the assessment.
The calendar is supporting colour, not the spine
The forcing function is happening now, in procurement, not on a regulator's calendar. Sovereign procurement is running ahead of regulation, with custody language and money attached, and the category-default dynamic follows: the first certified artifact defines what conformity assessment looks like for everything after it.
The regulatory calendar is real but softer than it looks. The EU AI Act's prohibitions took effect in February 2025 and its general-purpose obligations in August 2025; the penalty regime, fines to €35M or 7% of turnover, arrives on 2 August 2026. But the Digital Omnibus agreed in May 2026 deferred the high-risk conformity deadlines to December 2027 for stand-alone systems and August 2028 for product-embedded ones — which lengthens the build window and softens any claim that certification forces freezing right now. The deadline is supporting colour. The buyers are the spine.
Recall equals respin
One mechanism is honestly open: whether a weight-changing metal respin counts as a substantial modification requiring re-assessment has not yet been clarified by any notified body. The question is two-sided, and the etched model wins either way. If yes, a recall is a respin plus a re-certification, a budgeted operational event. If no, re-certifying only the changed expert banks against an unchanged base becomes a decisive advantage.
The contrast is instructive. The FDA's predetermined change-control pathway exists precisely because adaptive models strain assessment regimes built for fixed devices. The etched model does not strain them. It is what they were built for. A corrective action becomes a metal-layer event, budgeted as operations, not an existential one.
Societies already buy frozen silicon
The etched card is the same thermodynamic object as a mining ASIC, a fixed function printed and run at the physics floor, and the opposite business. The mining industry already trained the operators, built the power-site discipline, and proved the fleet economics. What it never had was a durable claim on the value its silicon produced.
The secondary analogs each contribute one load-bearing precedent. Secure elements, the tamper-proof chips in your bank card and passport, for silicon whose immutability is the product: billions bought because they cannot be rewritten. Avionics, for version-locked certification as a priced, survivable process. And the mask-ROM game cartridge, fixed code pressed into read-only memory, for an industry that shipped at consumer scale, updated by revision, and routinely shared ROM content across titles, the direct ancestor of base wafers that serve many models from one design.
Societies already buy frozen silicon, in volume, on purpose. They have never yet been offered frozen intelligence.
| Dimension | Mining ASIC | The etched card |
|---|---|---|
| Reward | Commodity, set by a global market | Contracted, set by a utility agreement |
| Gains over time | Confiscated by difficulty adjustment | Protected by certification |
| Next chip | Devalues the fleet | Is the next contract, upgrade by respin |
A lithographically frozen model is the only form of the technology that cannot drift, because drift would require a fab.
The takeawayRegulated intelligence will be bought the way regulated everything is bought: as a certified, version-locked artifact, and a lithographically frozen model is the only form of the technology that cannot silently change.
Part III · What Gets Etched
Print the prior, stream the state, route the novelty
The split between competent and frontier intelligence is not a business compromise — it is a hardware specification. What is stable enough to certify is stable enough to etch, and nothing else should be.
The split router
Print the prior · stream the state · route the novelty
- ETCHEDmodelled
Procedure — printed into silicon
79%$0.004/M - RADIANTmodelled
Memory — facts that moved
16%$0.15/M - FRONTIERreported
Novelty — rented margin
5%$1.50/M
At this threshold the etched card absorbs 79% of the stream at the physics floor, retrieval carries the facts, and only the 5% that is genuinely out-of-distribution pays frontier margin. The blend lands orders of magnitude under the frontier band —the prior is printed once; only the novelty is rented.
The split as a router: II-Agent routes each request by a measured threshold γ. Procedure is etched into silicon (~$0.004 per million tokens, modelled); memory is retrieved from disk (the part low-bit compression handles worst); the frontier tail is rented through an API — margin, not manufacture.
A business split turns out to be a chip spec
The Strategic Thesis runs on one economic engine: competent intelligence for the routine majority of work, frontier intelligence routed in for the exceptional remainder. That split was described as a way to save money. It turns out to be a hardware specification.
Frontier capability changes every quarter, so it stays on GPUs and APIs — reached through II-Agent, the orchestration layer that routes each request to the cheapest tier that can answer it and earns a distribution margin. Competent capability is the part that is stable, certifiable, and therefore freezable. And stability is the one property that makes a workload manufacturable.
This is where enthusiasts overclaim, so the load-bearing number is NVIDIA's own: serving a 7-billion-parameter small model is 10–30× cheaper than a 70–175B large one. The stronger popular claim — that 80–95% of deployed tokens need only competent capability — is a practitioner's rule of thumb, a dial rather than a fact. The routing threshold γ (gamma) is measured per deployment against its own workload.
Three layers: procedure, memory, tail
The architecture is a three-layer decomposition that recurs at every scale of the document: etched silicon is procedure; Radiant is memory; frontier APIs are the tail. This is the whole gloss made physical — print the prior, stream the state, route the novelty.
Print the prior. The etched card carries the stable procedural operator — the prior — reasoning patterns, language competence, protocol-following: the part deep enough in the training distribution to freeze into metal.
Stream the state. Radiant retrieval carries the knowledge — facts, records, curricula — the live, per-request content that low-bit compression handles worst and that changes too fast to print. It streams in as conditioning rather than being baked into the die.
Route the novelty. The frontier API carries the capability tail, the rare question the prior simply cannot answer — sent elsewhere, not manufactured.
Formally the stack is a system-level mixture-of-experts whose largest expert lives on disk instead of HBM (high-bandwidth memory, the expensive stacked DRAM bolted to a GPU): capacity scales with the total, but energy scales only with the active part. Sovereign workloads sit exactly where this is strongest — the citizen's question is about their records, their law, their curriculum, all retrieval-heavy by nature.
The distribution boundary is the economic boundary
The split has a sharper statement than competent versus frontier, because capability is not the axis that sets cost. Distribution is. Work deep in the model's training distribution is answered by the etched operator at the physics floor.
Work whose facts have moved but whose procedure has not is still in-distribution for the operator — retrieval returns the fresh fact and the etched circuit does the rest. That is how Radiant converts factual novelty into a cheap etched answer rather than an expensive routed one. Only genuine out-of-distribution work, a capability the prior lacks, leaves for the frontier. Out-of-distribution is the routing condition, not the error condition. And what routes repeatedly is not waste — it is the specification for the next generation's training set.
This makes the Champion's advantage informational, not technical. A Champion does not guess what to etch; it measures what repeats. Sitting inside a jurisdiction's workload, it sees the questions a health system actually asks and the forms a ministry actually files, and manufactures against the mass of them. A general-purpose vendor, blind to that distribution, cannot know which functions have frozen there. The moat is not the mask — it is knowing which mask to cut.
A Champion does not guess what to etch; it measures what repeats. The moat is not the mask. It is knowing which mask to cut.
The takeawayThe moat is not the mask — it is knowing which mask to cut, which means measuring what repeats inside a jurisdiction's own workload.
Part III · What Gets Etched
A model built for the die, from the first token
What gets printed is not a transformer downcast to hardware. It is a model shaped, from its very first training token, for the fixed circuit it will become — and the one novel step is watched as a curve during a run already being paid for.
§10 · Figure 7
The recipe pipeline
Five ordered steps, each with published precedent — save one. Click a step to open it.
NVFP4 is a 4-bit floating-point number format — a shared micro-exponent block with per-value 4-bit mantissas. Training natively in it keeps the model close to the low-precision target instead of quantising after the fact.
Starting closer means less distance for the ternary shell to travel later.
Block diffusion generates a block of tokens by denoising, then advances — a finite circuit rather than an unbounded autoregressive loop. The state it must hold is bounded, so it maps onto fixed etched hardware without a growing cache.
This is where the seeded road rejoins: a folded open MoE enters the pipeline here, already carrying most of its knowledge, so the conversion runs on~4.5T tokens instead of 25T.
Distillation trains a fast student to reproduce a slow teacher's output in far fewer passes. Here it collapses the denoiser to K ≈ 4–8 fixed, seeded steps — a known, bounded number of operations the silicon can be sized for exactly.
Fixed K is what turns "sampling" into a schedulable, hardwireable pipeline.
Ternary weights take one of three values: −1, 0, +1. The shell is a ternary copy of the model trained alongside the NVFP4 model — nested inside it — so the etchable weights inherit the full model's behaviour instead of being crushed down afterward. This co-training is the single novel step in the recipe.
Roughly 50% of the trained ternary weights settle on0 — they say nothing, and become free space the circuit can reclaim.measured
Corrupt-and-predict co-training teaches the model to repair a deliberately damaged draft — the basis of editing. The sampler can then revisit and fix its own block instead of committing token-by-token, which is what keeps K low at step 3.
Editing and distillation pull on the same rope: fewer, surer steps.
Four of the five steps rest on published precedent. Only step ④ — nesting a ternary shell inside the NVFP4 model and reading its curve against a ≥ 90% gate during the run — is new. the one bet
The pipeline: NVFP4 pretrain (25T tokens, shell nested) → block-diffusion conversion → sampler distillation (K = 4–8, seeded) → the ternary shell (the watched curve) → editing co-train. The seeded road — fold an open mixture-of-experts, merge, compress, distill (~4–5T tokens) — joins at step two. The gate: at least 90% of the autoregressive baseline, read during the run.
In plain terms, before the acronyms
In plain terms: we train the hardware-ready version of the model — ternary, where every weight is just −1, 0, or +1 — alongside the normal one from the very first day, so we can watch its quality live rather than discover it after we have already committed to silicon.
Only one small step in that recipe has never been published before, and even it is watched as a curve, not gambled on. Everything below names the formats and steps; this is the whole shape of it in two sentences.
A loop the machine cannot hold
The obvious way to put a language model on a chip is to take today's model and squeeze it down. That model is autoregressive: it writes one token, feeds it back in, writes the next — a data-dependent loop whose working memory, the KV cache (the running record of every token so far), grows with every word of the conversation.
A fixed circuit cannot hold a state that grows. Bounded state is not a preference here; it is forced by the machine. A cache that expands with the dialogue is the one thing an etched, unchanging circuit has no room for.
A circuit, not a loop
So the printed model is not an LLM converted after the fact. It is a block-diffusion language model — a design that generates a whole block of tokens at once by starting from noise and denoising it, rather than emitting one token at a time. In hardware terms, it is K applications of one fixed operator to a bounded buffer, with the randomness supplied by a keyed counter, deterministic end to end.
That is the difference the thesis compresses into a line: autoregressive inference is a loop; seeded diffusion is a circuit. Block diffusion is, today, the only published route to a quality language model with bounded state — which is why it was never a downcast transformer, but the design from the first token.
Five steps, each with a published reference
Pretrain in NVFP4. Four-bit native pretraining — training the model directly in a four-bit number format rather than shrinking it later — is production fact, published and reproduced at scale. Its precision split (matrix layers in four bits, attention held high because softmax amplifies rounding noise) is the same split this program derives from first principles.
Convert to block diffusion. Demonstrated at 100-billion-parameter scale by continued training; a fallback route reports 98.7% quality retention at 30B. Commercial diffusion models already serve at 1,000-plus tokens per second at near-parity quality.
Distill the sampler. Consistency distillation collapses the denoising schedule to roughly four to eight fixed steps, with in-loop noise supplied by a keyed counter pinned to the quantisation lattice. Then co-train the ternary shell — the step restructured below — and co-train corrupt-and-predict, which teaches the model to repair damaged context, making committed tokens revisable at inference. No chip needs that reversibility more than a coarsely quantised one.
The nesting: the risk becomes a curve
Here is the single novel move. Ternary weights — every weight forced to just −1, 0, or +1 — are not a different species from NVFP4. They are NVFP4 with the magnitude collapsed to one bit, under the same block scales. That identity lets the ternary 'shell' be trained inside its four-bit parent throughout pretraining, so its quality is a curve you watch during the run rather than a conversion you gamble on afterward. The interactive nesting explainer above lets you follow that one identity — four-bit parent, ternary child, shared block scales — step by step.
The parent had to be NVFP4 specifically: the gap to ternary is just 2.25×, against 5× for FP8 and 10× for FP16 — the only format close enough to nest. Native low-bit training is established on both ends: ternary at 2B parameters over 4T tokens, four-bit at 12B over 10T within about 1% of FP8. But the nesting itself — ternary co-trained inside NVFP4 — has no published precedent. It is stated plainly as the program's principal novel claim, and the first experiment. The curve decides.
Why ternary, not binary
Binary weights minimise the bit. Ternary weights minimise the useful circuit — and the whole difference is the zero. A ternary zero is not another symbol to store; it is an omitted operation: an absent wire, a silent adder input, a smaller reduction tree, a bank that never switches.
Binary forces every weight to participate in every result. Ternary lets the learned function say nothing — and trained ternary models say nothing about half the time. The signature shows up exactly where it should: measured ternary-ROM density rises with the zero ratio. The program does not bet the model on ternary; it buys a proven four-bit model, then spends ~4% more tokens to try to halve the silicon. Ternary, not binary, is where the halving is real.
Autoregressive inference is a loop; seeded diffusion is a circuit.
The takeawayEvery step of the recipe has published precedent except one — nesting ternary weights inside a four-bit parent — and even that is a curve watched live during training, not a bet placed after it.
The mathematics · watched, not gambled
Drag the marker — watch it snap to each lattice and the leap to ternary widen.
One run buys both — the finished 4-bit model, and the ternary shell nested inside it. MXFP4 would spend +36% more tokens to reach the same place.
Part IV · The Silicon
One ladder, from thumbnail to sovereign stack
The program is a single ladder — from a thumbnail of 16-nanometer read-only memory to the sovereign stack — where each rung is a smaller bet than the one just retired. The chip beneath it is a fixed-depth function machine: noise in, tokens out.
§13 · Figure 9
The G-Ladder
Seven rungs, each a smaller bet than the last one retired. Climb from a block-test proof to the sovereign stack — one rung is banked before the next is attempted.
MPW block test: ternary-ROM macro, adder fabric, keyed PRNG
- Node / substrate
- N12/16 shuttle
- First-silicon bet
- $1–5M
- What it proves
- model-to-GDS; the operator in silicon
0rungs retired below — proofs already banked.
Cost figures are modelled targets, not results (§13). The low rungs are deliberately cheap — a printed block, then a minimum printed model — so each proof is retired before capital climbs to the sovereign card. Hover, click, or use ↑ ↓ to climb.
The G-ladder: G0 ($1–5M, operator proven) climbs to G1 ($10–30M, model printed), through the G1a/b modules, up to the G2 Champion card ($60–90M, utility layer), and on to the sovereign rungs G2S/G3/GMax. Each rung is retired before the next; the checkpoint that gates the program is the die that starts it.
The first chip is not an AI accelerator. It is a printed learned function: the smallest artifact that proves the whole thesis, and along the proof path it is deliberately austere. One model. One graph. One precision regime. One host interface. No HBM (the stacks of high-bandwidth memory a GPU streams weights from), no 3D stacking, no mixture-of-experts, no photonics, no frontier claim.
What that first tapeout proves is the single thing everything else depends on: that a useful low-bit model can be compiled into a cheap fixed circuit by a repeatable toolchain — noise in, tokens out, no drama.
Five claims to take
That weights can be hardwired into silicon is no longer in question — a hardwired 8-billion-parameter model has been running on TSMC N6 since February, on the company's own telling. What has never shipped is the printed model itself, and five firsts are there to be taken.
The first printed model, with both memories deleted and the only mutable silicon a block buffer. The first ternary one (weights that are just -1, 0, or +1). The first co-designed one, trained for the die from token zero so it pays no post-quantisation tax. An appliance-class cost floor an order of magnitude below an 815mm² leading-edge monster. And the model-to-GDS compiler — the toolchain that turns a model trained for its own lattice into mask geometry, wrapped in a certification dossier and an escrow chain. That compiler does not yet exist anywhere. It is the crown-jewel IP.
One ladder, two rungs carry the story
The program climbs a single ladder, and each rung is retired before the next is climbed. Read the table top to bottom if you want the full climb; two rungs carry the argument.
G1 ($10–30M) is the proof: the first printed model, a 0.5–3B ternary block-diffusion language model, etched — small enough to fund below a Series A. G2 ($60–90M) is the business: the Champion card, a 14B dense model that becomes the certified bulk-token utility layer. Above G2 sit the sovereign rungs above — escrow custody, jurisdictional expert planes, locked decade-long deployments — each a via-mask variation on the card below it, not a new machine.
The cheap chip subsidises the sovereign stack
The proof rungs run at 16nm-class, not N6 — where a mask set is ~$4M against ~$15M, capacity is uncontended, and the node is already the plan-of-record for G2's bottom die. So the austere first chip is not a detour from the sovereign stack; it is how the sovereign stack gets paid for. The cheap chip subsidises the sovereign stack. That is the strategic hinge of the whole ladder: the smallest bet funds the largest one.
Why the architecture is forced
Autoregression — the way today's models generate, one token at a time — turns time into memory. It appends a token, grows a KV cache (the running store of every earlier token's keys and values), and must write and re-read that cache every single step. So its silicon is a memory machine whose bandwidth scales with the length of the conversation. Memory that grows with use is exactly what kills fixed-function economics.
There's a second tax hidden in it. At batch one — a single user — an autoregressive decoder drains its pipeline once per token, running the silicon at roughly 1/L of capacity. The batching tyranny, rebuilt on-die.
A circuit reused
Block diffusion turns time into recirculation instead. It reuses one fixed operator over a bounded buffer K times — K applications of one stateless function, no data-dependent branching, no state that grows, nothing resident between requests. The silicon becomes a function machine with a static latency envelope and a working set that never grows. A circuit reused is what makes fixed-function economics work; this is why the architecture is forced, not merely preferred.
It is also a utilisation theorem. A diffusion block fills the pipeline width-wise and recirculates it K times back-to-back: near-total utilisation at batch one, with cycle-accurate latency. Single-user speed stops being the thing sacrificed for economics and becomes the thing the geometry produces.
The split, and the one knob
Where does randomness live in a deterministic machine? The design rule draws a firewall. The host owns everything that is policy — seeds, schedules, sampling temperature, top-p, guidance weights, safety filters, retrieval, the audit trail. The card owns the frozen operator and one thing more: the keyed in-loop noise injected between denoising steps, the calibrated warmth that anneals the roughness of the ternary lattice out of the trajectory. It is a few thousand gates of counter-mode PRNG — bit-exact, golden-vector testable, certifiable.
Across the PCIe link between them, only projections cross: activations, never weights. On the reference shapes a full block generation is tens of megabytes against ~64 GB/s — well under a millisecond, with margin. And the whole machine tunes to a single dial. The commitment threshold gamma is a Lagrange multiplier — the speed–quality knob is exactly the price of a joule.
| Gen | Artifact | Node / configuration | Cost (modelled) | Proves / serves |
|---|---|---|---|---|
| G0 | MPW block test: ternary-ROM macro, adder fabric, keyed PRNG | N12/16 shuttle | $1–5M | model-to-GDS; the operator in silicon |
| G1 | Minimum printed model: 0.5–3B ternary block-diffusion LM, etched | 16nm-class, 2D, 45–200mm² | $10–30M | the printed ternary learned function; appliance economics |
| G1a/b | Solar voice teacher; protocol health aide | G1 die + host MCU/NPU | module-level | universal service made physical |
| G2 | Champion competent-inference card, 14B dense | N6; 2D standard / 3D premium | $60–90M | the certified bulk-token utility layer |
| G2S | Sovereign escrow card | G2 + via-mask escrow + dossier | — | custody chain to lithography |
| G3 | MoE expert-plane silicon, dynamic top-k | 3D stack | — | jurisdictional expert libraries |
| GMax | Fully hardwired long-life artifact | any generation, frozen | — | ten-year certified deployments |
Memory that grows with use is what kills fixed-function economics; a circuit reused is what makes them. This is why the architecture is forced, not preferred.
The takeawayThe whole stack is one ladder of shrinking bets on top of one architectural fact: block diffusion reuses a single frozen circuit instead of growing a memory, which is what lets a model be etched once and amortised over every token it will ever produce — with a single knob, gamma, the price of a joule.
The premium stack
Two dies, hybrid-bonded.
- N6Logic + ternary shell ROMthe bonded compute layer — ROM, thermally inert
- 6 µmHybrid-bond interfacecopper-to-copper pads join two dies into one part
- 16 nmResidual + delta + adapter SRAMthe only actively-moving state in the stack
- BGAPackage substrateball-grid array to the board
Part IV · The Silicon
Engraving is capital. Copying is free.
On a GPU the model is rent, paid to memory on every token forever. Etched into silicon, it is capital: engraved once, then copied for the cost of wafer, package, and test.
On a GPU, the model is rent
On a general-purpose GPU, every token the model produces pays a toll. The weights live in off-chip memory, and each pass fetches them across the memory hierarchy — the tiered path from far-away DRAM to the on-chip registers where math happens. That fetch is the dominant cost.
So the model is a recurring rent. You pay it again on every token, forever, for the life of the machine. Nothing about answering the millionth question is cheaper than answering the first.
Etched, the model is capital
Etch the learned function into silicon and the accounting inverts. "Engraving the model" is paid once, as photomasks, process steps, and wafer starts — never per answer, and never meaningfully per die. Once the masks exist, each additional copy costs only wafer area, yield, package, and test.
The model becomes one-time lithographic capital, amortised over every token the artifact will ever produce. This is the economic discontinuity the whole thesis turns on. A photomask is the stencil the fab uses to print each layer of a chip; writing a full set is the expensive act, and it happens once.
The grades of change
Not every update is a full rebuild — the cost depends on how deep the change cuts. Adding more units of the same design costs only wafer, package, and test; copying the model is free. An adapter or curriculum update is a signed payload with no mask at all. A retrieval update is pure software.
A weight respin — changing the learned function on the same base wafers — is a via-mask event, not a redesign. A "via" is one of the tiny vertical wires connecting a chip's layers; the model can be encoded in just the final via masks. Weights compile to GDSII, the industry's chip-layout file format, in about a week by the toolchain vendor's account. A full new architecture is the one genuinely expensive path: a full design-and-mask cycle, a generation of work.
A respin is ~99% unchanged
A weight respin runs about $1M and takes weeks. That is an inference, but a defensible one: about 99% of the mask set is unchanged, and the physical mask writing takes only days. A full N6-class mask set is about $15M; a 16nm-class set, $3–5M. Masks are cheap. Being wrong in masks is not.
The deeper flow is via-ROM with wafer banking. Base wafers — identical and model-agnostic — are fabricated ahead of time and parked before the final via layers are added. The model itself lives in one or two via masks applied at the very end, moving the moment of commitment to the latest, cheapest, most reversible point it can occupy.
What the inversion buys
From there the consequences compound. Personalising a model per customer or jurisdiction becomes a weeks-scale packaging-line event. A sovereign escrow artifact shrinks to a handful of via masks. The same banked wafer can ship as a cheap ternary card or a dual-precision sovereign part, depending only on whether a second die is bonded on at the end.
The supply logistics cooperate. Mature-node capacity is genuinely uncontended — analysts describe idling N6/N7 lines being repurposed as the leading edge moves on — with wafers around $9,500 (N6) and $4,000 (16nm-class). The design's scarce inputs are the ones nobody is fighting over.
| Change | Cost mode |
|---|---|
| Same design, more units | Wafer + package + test; copying is free of the model |
| New model, same base wafers | Via-mask respin against banked wafers, weeks |
| New architecture | Full design and mask cycle, a generation |
| Adapter or curriculum update | Signed payload or storage pack, no mask at all |
| Retrieval update | Software, by design |
Engraving the function is capital. Copying it is free. That is the whole inversion.
The takeawayA GPU pays the model's cost as rent to memory on every token; an etched chip pays it once as lithographic capital, then copies it for the price of wafer area, package, and test.
The respin economy
Print once. Copy for free.
Part IV · The Silicon
The last-mile intelligence appliance
A voice-first, grid-optional box whose intelligence is printed into silicon, whose knowledge is a signed pack, and whose custody stays local. This is where "intelligence as universal service" acquires a housing, a speaker, and a panel that drinks sunlight.
The last-mile appliance BOM
Bill of materials
Lifetime arithmetic
- No API bill
- No network dependency
- Near-zero idle
A $50 device answering100 times a day for3 years serves roughly110,000 interactions. The silicon is bought once; every answer after is free at the margin — the capital amortises to$0.00046 per interaction.
The last-mile appliance: solar panel feeds a ternary ASIC and microcontroller; a signed knowledge pack and a mic-and-speaker turn a question into a spoken answer. $20–75 BOM, modelled; idle near zero; grid optional.
A promise with no body
The Strategic Thesis makes two universal-service promises: every citizen gets an intelligence account, and every provider must honour a daily quota of answers. Today those commitments have no physical form beyond distant datacenters and the phones in people's pockets.
That leaves the people who need it most on the wrong side of a wire. If the answer lives in the cloud, it arrives only where the internet reaches, only while the power holds, and only as long as someone keeps paying the metered bill for every query.
The product family
This section supplies the missing artifact, in the order a Champion (a national or regional deployment partner) would ship it. A teacher in a box: a patient, tireless voice tutor in the local language. A protocol health aide — named with care, not a doctor replacing doctors but an aide that follows clinical protocols, never forgets, and knows when to escalate.
Then a civic services box for forms, entitlements, and paperwork; a disaster and refugee field node that works when infrastructure doesn't; and a rural edge node serving a single school or clinic. Intelligent Silicon ships the modules and reference designs; Champions and manufacturing partners build, deploy, and support the boxes.
The bill of materials is the argument
Add up the parts, on modelled targets. A ternary ASIC (the chip with the model printed into it) at $5–30; a microcontroller and audio at $1–5; mic and speaker $1–5; battery or supercapacitor $3–8; solar panel $3–10; enclosure $3–10; optional storage and connectivity $1–8; assembly and test $3–10. That is $20–75, all in.
The lifetime arithmetic follows. A $50 device serving 100 interactions a day for three years delivers roughly 110,000 answers at about $0.00046 of capital per interaction — with no API bill, no network dependency, and near-zero idle draw. That last property, drawing almost nothing when it isn't working, is exactly what makes running on a small solar panel viable at all.
Procedure etched, memory packed, tail escalates
The obvious objection is that a printed model has frozen, stale weights. The appliance answers it by construction. The fixed, etched model is only the procedural part — the tutor that knows how to teach, the aide that knows how to follow a protocol. It never changes because it never needs to.
The knowledge that does change — curriculum, health protocols, local information — lives in signed, updatable storage packs: cryptographically verified files, the appliance's own version of the cloud's live knowledge layer. Session memory stays local and encrypted. And when a question exceeds what the local box can safely answer, the tail escalates to a larger model upstream. Nothing frozen ever needs to change, and nothing that changes was ever frozen.
| Component | Low | High |
|---|---|---|
| Ternary ASIC | $5 | $30 |
| Microcontroller + audio | $1 | $5 |
| Mic + speaker | $1 | $5 |
| Battery / supercapacitor | $3 | $8 |
| Solar panel | $3 | $10 |
| Enclosure | $3 | $10 |
| Storage + connectivity (optional) | $1 | $8 |
| Assembly + test | $3 | $10 |
| All in | $20 | $75 |
A cloud model answers only where the internet reaches. A solar etched model answers wherever sunlight reaches.
The takeawayOnce the model is etched into silicon, an interaction costs almost nothing and needs no network: a $50 solar box can answer roughly 110,000 questions over three years at about $0.00046 of capital each.
Run the numbers
The case, in figures you can move.
Every number here is drawn from the thesis's own evidence register. Move the inputs and watch the physics — and the economics — respond. Modelled figures are targets, not results.
Joules & dollars per token
Serve the same tokens two ways. The GPU pays to move the weight every time; the etched card deletes the move.
$1.50
$0.15
$0.004
Frontier band is a reported market anchor; certified tier and manufacturing target are modelled — a served-token floor, not a listed price.
Energy figures are modelled targets (§17); the etched floor sits at6 mJ/token, best case 1.7, compound-worst 26. Prices are a reportedfrontier anchor against a modelled served-token floor (§18). Move the GPU slider to see the gap breathe.
§18 · The breakeven
How many cards retire the generation.
At this fleet the NRE clears in1.8years
One mid-sized national deployment — a few thousand cards, well under2,400–4,700— retires an entire generation's engineering bill inside two years. After that the tokens are effectively free of their capex: the card keeps clearing margin against a manufacturing floor a hundredth of the sale price. Every figure here is modelled — a target, not a result.
From die area to a model to a cost
A 100 mm² die holds a3.5B-parameter model and costs$7 in raw silicon at 16nm-class. Density, cost and yield are modelled targets; wafer prices are reported.Above 400 mm² is not a first product — reticle, yield and bonding costs turn against you.
Load residency
The share a local etched artifact answers before it escalates to the frontier.
- Local modelled
- $0.150 $/M · always paid
- Escalated reported
- — (1−p) × $1.50/M
- Effective
- $0.277 vs $1.50 all-frontier
Push residency toward the top of the band and the effective cost falls to the local floor — escalation becomes a rounding error. The tail is what frontier is for.
Part V · The Economics
The payback clock
Spot inference prices halve every two months. A frozen artifact should be underwater within a year — yet three structural facts turn that curve from a threat into the business.
§1 · §18 — Figure 13
The Payback Clock
Spot inference price halves about every 2 months. It is falling toward a floor the manufacturer already stands on.
Drag the decline rate. However fast the spot price falls, it converges on the same destination — the physics floor. The price war is a race to a line the manufacturer etched first. Median decline is50×/yr, but the plausible band runs 9× to 900×; theendpoint does not.
The payback clock: cost per million tokens against utilisation, log scale. The frontier API band falls ~50× per year; GPU self-hosting sits below it; the etched card (modelled) is the floor. The clock ticks in the shaded band between the falling price and the fixed physics floor.
The objection, at full strength
Spot inference prices — what you pay per token on the open market — fall about 50 times a year, halving roughly every two months. A frozen artifact underwritten against that curve looks underwater within a year. So how can a printed model, whose weights never change, ever pay for itself?
This is the honest objection, and the section poses it at full strength before answering. The answer is three structural facts, in ascending order of importance: the contract, the respin, and the floor.
First, the contract
The certified tier does not sell spot tokens. It sells custody and conformity at fixed quality on utility terms — the arrangement a hospital or a ministry signs, not a metered API bill.
The buyer of a certified artifact is buying the one property the spot market can never offer: that the artifact does not change under it. Frozen weights are the feature, not the liability.
Second, the respin
The installed base is not stranded by the improvement curve; it rides it. A weight respin — about $1M and a matter of weeks — refreshes a deployed card to a better model without new silicon.
Every training-side gain is collected in a register and pushed as a free field upgrade. The etched fleet keeps improving after it ships.
Third, the floor
What is falling is the price of inference. Its destination is the cost of inference — and that cost floor is set by physics: roughly 4 to 8 millijoules per token on the etched card, against the tens to hundreds of millijoules a general-purpose GPU spends to serve the same token.
The spot market is racing toward manufactured-good economics. The manufacturer is already standing there. When the price war ends, it ends at the physics floor, where the product already sits.
The payback clock
The arithmetic is short. A G2 card selling manufactured tokens at $0.15 per million — an order of magnitude under the frontier band, and well over an order above its own $0.004 manufacturing target — clears roughly $9,500 of gross margin per card-year at utility-class use.
Between 2,400 and 4,700 deployed cards retire an entire generation's non-recurring engineering cost (the NRE: masks, design, tape-out) in two years. One mid-sized national deployment is that number; the whole G2 generation costs about one week of a frontier lab's compute bill. And the buyers exist — pensions, insurers, sovereign funds that cannot hold frontier-lab equity but are built to hold infrastructure priced on contracts, plant, and certified assets.
The surplus buys judgment, not only savings
A substrate fifty times cheaper can be spent two ways. Taken as savings, it is fifty times lower cost — the axis the incumbents compete on. Spent as thought, it is ten independent agents on one task at five times lower cost: a drafter, a critic, a citation checker, a fairness reviewer, an appeal-rights advocate, an escalation monitor.
The unit of public-sector intelligence is not the token; it is the deliberated task. And because the substrate is deterministic — fixed seeds, versioned weights, logged retrieval — the committee is reproducible. A citizen's decision becomes not one sampled response but a recorded procedure, which is what an auditor, an appeal, or a court requires.
When the price war ends, it ends at the physics floor, where the product already sits.
The takeawayThe falling price of inference is racing toward the cost of inference — the physics floor — and the etched manufacturer is already standing on it, selling custody the spot market cannot offer.
Part VI · The Foundry and the Network
The escrow clause and edge sovereignty
Intelligent Silicon fabricates nothing. It sells printed learned functions — certified, escrowed, respin-refreshed, royaltied per device. A nation's certified intelligence, held in a vault it controls, reproducible at any qualified foundry, and independent of any company's survival, including this one's.
§21 · Figure 14
The custody chain
From the Champion's licence to lithography. The escrowed object is thethinnest layer in the stack — and it survives any company.
- G2 · ChampionThe Champion's licence
- G2S · EscrowThe sovereign vault
- Any qualified foundryRe-fabrication
- CertifiedThe card
- In the fieldDatacenter → village
Hover or step through each link. The whole chain reduces to one escrowed sliver: two via masks and a hash.
- Standard base masks · shared, off-the-shelf 93%
- The escrowed layer · via masks + hash 7%
The weights never move; the value never leaves. What sits in escrow is avia-mask respin — a pattern in metal reproducible at any qualified foundry from standard base wafers. Custody chain to lithography is a physical fact, not a promise.
The custody chain, from protocol to lithography to schoolroom: the Champion's licence, the via masks and model hash in a sovereign vault, re-fabrication at any qualified foundry, the certified card and appliance in the field. The thinnest layer in the stack is the one the jurisdiction holds.
What sovereigns buy today
Nations already pay, in committed money, for custody of compute inside their borders. The flagship sovereign-AI buyer describes its in-Kingdom datacenters in exactly those terms: "This is what AI sovereignty looks like."
And the category's largest public company earns 86% of its revenue from sovereign-linked buyers. That demand is not a forecast; it is the current customer. But custody of a datacenter is custody of the machine, not of the mind that runs on it — the model still arrives as someone else's hosted service, held on someone else's premises.
The escrow clause: the jurisdiction holds the mask
The escrow clause carries that sovereignty commitment all the way down to lithography — the etching of circuit patterns onto silicon. The point is physical possession: each jurisdiction escrows, against globally standard base wafers, the two objects that are its model. Its via masks — the etched pattern that encodes the weights as physical wiring — and its model hash, a cryptographic fingerprint that proves the artifact is unchanged.
This is only possible because the model lives in just one or two via layers, so the sovereign artifact is the thinnest layer in the whole stack — and the cheapest to re-fabricate. A jurisdiction can keep those masks in a vault it controls and re-fabricate at any qualified foundry; refreshing them is a respin, a new via-mask that costs roughly $1M and leaves about 99% of the mask set untouched.
So the escrowed object is a nation's certified intelligence, reproducible anywhere it qualifies a fab, independent of any company's survival, including Intelligent Silicon's. In time that vault holds a jurisdiction's expert library — its law, its language, its curriculum — printed as mask layers and re-certified incrementally as they change.
The same portability at the other end of the wire
Edge sovereignty is escrow's logic run to the far end of the network. Because the whole model is a fixed pattern in metal, it can travel to wherever it must live — not only a vault behind a national datacenter, but a voice box in a school, a clinic, a village. There it keeps answering when the network fails and the grid follows it down: the appliance SKU draws under a watt on a solar duty cycle.
This is what sovereignty adds to certification. Certification (Part II) is why the artifact must be frozen; freezing is what lets a jurisdiction physically hold it — in a vault, or in a box under a desk in a place the network never reached. Nothing to update is also nothing to cut off.
Sovereigns already pay for custody of compute. The step this sells is custody of the model itself — the same buyer, one clause further along. One custody chain, from protocol to lithography to schoolroom.
Custody of the datacenter is custody of the machine. The escrow clause is custody of the mind that runs on it.
The takeawayCertification is why the artifact is frozen; sovereignty is who physically holds it. Because a printed model lives in one or two etched via layers — the thinnest, cheapest layer in the whole chip — a jurisdiction can keep its own via masks in a vault it controls and re-fabricate at any qualified foundry. The same fixed weights that make it certifiable make it portable into that vault — and make a village voice box keep answering when the network dies.
Part VII · Timing
Why now, and what must be true
The window is not a moment but a gap between proofs — six lab gates and one market gate that must all hold, with a sovereign buyer already standing at the counter. Seven reasons it is open now, and the discipline of naming every fracture point before a single mask is cut.
§23 · The Seven Gates
Every gate holds, or no mask is cut.
Six gates live in software — cheap to open, cheaper to break, and each one is a place the thesis has told you where it could fall. The seventh is a signature: no experiment forces a sovereign buyer to sign. Naming the fracture points is what separates a thesis from a pitch.
The seven gates: six in the lab, one in the market. Each is tested in software during a run already being paid for, before any mask is cut.
The window is a gap between proofs
The case for now is not a mood. It is seven reasons, each pointing at evidence already tabled elsewhere in the thesis, and each pushing in the same direction.
First, the adjacent category shipped. Hardwired-weight silicon — a model with its numbers physically etched into the chip rather than loaded from memory — is already running with demonstrated economics. But the printed model with bounded state (a design that also throws away the two big off-chip memories: the weight store and the KV cache, the running scratchpad a model keeps while it generates) remains unclaimed.
Second, the recipe is published. Every step of the training method now has an open reference, which collapsed the training risk for everyone, including this program. Third, the capacity is uncontended: mature, older-generation fab lines are idling as the industry's leading edge moves on, and this design needs no HBM (high-bandwidth memory, the scarce stacked DRAM that GPUs fight over) allocation at all.
The buyer is already at the counter
Fourth, sovereign procurement is live ahead of regulation — with custody language and committed money already on the table. The category's largest public company earns 86% of its revenue from sovereign-linked buyers. That demand is not a forecast; it is the current customer.
Fifth, certification arrives on a legible schedule, and the first certified artifact will define what conformity looks like for the whole category. Sixth, the first proof is cheap: G0 costs eval-branch money, G1 less than a Series A, and both run on the idling capacity.
And seventh, every month the position stays unclaimed, the category's eventual first mover hardens into its default. The window is a gap between proofs rather than a moment — and the first proof is already priced.
What must be true
Honesty about fracture points is the discipline that separates a thesis from a pitch. Seven things must be true for this to work, and each is gated before any mask is cut — six in the lab, one in the market.
The six lab gates test the technical bets: that the ternary shell (weights compressed to just three values, −1, 0, +1) holds quality at scale; that a model converted from left-to-right generation to block diffusion (generating whole spans in parallel) reaches parity; that the step count falls as far as the speed targets assume; that the fold from a mix-of-experts teacher into a dense student keeps what naive distillation loses; that the measured energy gap survives contact with real hardware; and that the appliance clears its safety thresholds.
The seventh is the commercial one: a sovereign buyer contracts for a version-locked artifact on utility terms — the demonstrated demand for custody of compute converting into demand for immutability of the model.
Fracture points placed where they are cheapest
The nesting reshapes the list. The shell-quality question is a curve watched during pretraining rather than a cliff discovered after it, and the NVFP4 floor (the higher-precision fallback format) exists whatever the curve shows.
One gate is different in kind. The precision bets have floors on the same machine, but bounded-state decoding is the machine. If conversion parity is never reached at deployment scale, the failure shows up in software, where it costs a checkpoint — and what remains is the hardwired-accelerator category, which is already occupied and which this document deliberately does not claim.
So the technical fracture points are placed where they are cheapest to discover: in software, during a run already being paid for, before any mask is cut. The commercial one is placed where it is most visible: in a named contract. The program's cheapest experiment — a one-to-three-billion-parameter full-pipeline dress rehearsal — and its first product are the same object. And the first mask now costs less than the experiment used to.
| Gate | Where | The claim that must hold |
|---|---|---|
| a | Lab | The ternary shell holds quality at 14B on long-form generative work |
| b | Lab | Converted diffusion reaches parity after alignment at quality-preserving commitment rates |
| c | Lab | The step count K falls as far with editing and distillation as the speed targets assume |
| d | Lab | The fold retains what naive sparse-to-dense distillation loses |
| e | Lab | Measured GPU joules-per-token leave the modelled energy gap intact |
| f | Lab | The appliance clears acceptance and escalation-safety thresholds under protocol constraints |
| g | Market | A sovereign buyer contracts for a version-locked artifact on utility terms |
Honesty about fracture points is the discipline that separates a thesis from a pitch.
The takeawayThe window is a gap between proofs, not a moment; the first proof is already priced at less than a Series A, and every technical bet is tested in software before a single mask is cut.
The first proof
It answers wherever sunlight reaches.
Conclusion
The weights never move
The whole thesis reduces to one observation and one consequence — and then to a single object small enough to hold in your hand.
One observation, one consequence
The document reduces to one observation and one consequence. The observation: intelligence is a manufactured good being sold as a service. We rent it by the token today, but the expensive, stable, repeated part of it is a physical thing that can be built.
The consequence follows directly. Whoever manufactures the certified good — and escrows it, hands a sealed copy into the custody of the jurisdictions that depend on it — owns the physical layer of the intelligence age.
The first proof is smaller than the thesis
The proof does not start in a datacenter. It starts with a single printed learned function: a small model etched permanently into silicon, speaking through a speaker, answering off the grid and without a network.
That artifact proves the category more cleanly than a datacenter card ever could. It is a one-watt appliance small enough to hold in your hand, and nothing about it can be metered, throttled, or switched off from far away. What that object has, every larger artifact inherits.
Three properties, inherited at every scale
From that first artifact the stack scales upward — teacher box, health aide, Champion card, sovereign mask, expert plane, utility layer — each rung a smaller bet than the last one retired. And every artifact inherits the same three properties from the object below it.
It cannot drift: the weights are physical, so the model you certified is the model that answers, this year and in ten years. It cannot be cut off: the answer is computed locally, so no network switch reaches it. And it cannot be taken back: once the silicon is in a jurisdiction's hands, custody runs all the way down to the lithography that made it.
A law three words wide
The law beneath all of it is three words wide. Print the prior, stream the state, route the novelty. By now the words need no gloss; the whole document has been their proof.
The token was its first unit and the answer its first product. The deliberated decision, the embodied skill, and — further out than this document reaches — the generated world-second are the same architecture under later interfaces. What holds at every scale is the single claim argued from the first page: the expensive, stable, repeated part of intelligence belongs in silicon a jurisdiction can hold.
Where ownership physically lives
The Strategic Thesis asked who will own the intelligence age. This document answers where that ownership physically lives: in weights that never move, on silicon a jurisdiction can hold, from the national datacenter to the village school.
The weights never move. The value never leaves. And the answer reaches wherever sunlight does.
The weights never move. The value never leaves. And the answer reaches wherever sunlight does.
The takeawayIntelligence is a manufactured good being sold as a service; whoever manufactures the certified good and escrows it to the jurisdictions that depend on it owns the physical layer of the intelligence age.