The design
Corerope design: inventing a 1000x cheaper frontier LLM
The invented stack reaches about 750x less energy and about 260x lower cost per solved task than a late-2026 frontier deployment in the central case of its cost model. Energy passes 1000x if no task falls back to GPUs; dollars reach 1000x only in the optimistic case. The range is wide, from 15x to 46,000x in energy, because one scientific bet decides most of it: whether a ~12B-parameter ternary reasoning core paired with a huge lookup memory can match frontier quality.
Built fromresearch/02-corerope-design.md (edit)
The stack has seven parts:
- Move knowledge out of the matrix multiplies, so that per-token compute scales with reasoning and not with facts.
- Freeze that small reasoning core into silicon as ternary wiring, not stored weights, so no weight is ever fetched.
- Share partial sums across output rows. A synthesis test showed 2.4x fewer gates per weight than wired 4-bit and a further 1.6x from sharing.
- Make the core freezable for years, so every model update lands in rewritable memory instead of a new chip.
- Program the silicon in a single via layer, so a new model costs about $3M of masks instead of $40M.
- Price tokens per task into training, so cheap tokens are not spent on longer reasoning.
- Keep every task on the new stack: the cost model shows a 1% fallback to GPU serving caps the energy gain at about 92x.
Source: research/02-corerope-design.md, lines 9 to 17Edit on GitHub
The seven parts, one page each
Split mind, a small reasoning core and a vast lookup memory
The split mind stores knowledge in a lookup memory of tens of trillions of parameters and keeps only reasoning in a ~12B-weight core.
Falsified by experiment 3Invention 2Wired-weight ternary silicon
In wired-weight silicon a weight is not a number in memory but a connection: each input wire feeds an adder tree's plus input, its minus input, or nothing.
Falsified by experiment 1, 4, 7Invention 3ROM core, RAM mind
A frozen core must stay competitive for two to three years while frontier models change every few months, so it is trained to be frozen.
Falsified by experiment 5Invention 4Lookup-in-storage memory tier
The memory tier lives in storage that computes: each memory die gathers the rows a token asks for, sums them with their gate weights on the die, and returns one small vector.
TODO: no falsification experiment yetInvention 5Cutting tokens per task
Cheaper tokens get spent: median output per task rose from ~35k to ~59k tokens in a single Artificial Analysis index revision.
Falsified by experiment 6Invention 6Context cartridges for a frozen core
Once weights stop moving, each user's context state is the largest remaining data movement.
TODO: no falsification experiment yetPart 7The Amdahl trap and the two-tier fleet
If a share f of tasks still runs at baseline cost, the gain can never exceed 1/f.
Falsified by experiment 2The design doc's summary counts seven parts by what each does; its sections, which these pages follow, give six numbered inventions and the fleet.
Where the remaining 1000x hides
A late-2026 frontier token costs about $0.12 per million output tokens and roughly 0.5 to 2 J. That is DeepSeek-V4-Pro-class serving on GB300 NVL72 at ~27 tok/s per user (Silicon Report, citing InferenceX). The joules are derived from that price and from SemiAnalysis's Rubin measurement of ~10 J per token at 300 tok/s per user. Ordinary engineering will not find 1000x inside that token, because the companion report found the levers that remain on GPUs mostly overlap.
The headroom is in the gap between what GPUs spend and what physics charges. An H100 spends 11.68 pJ to move one bit from HBM and 0.52 pJ per tensor-core operation (arXiv 2607.26571). An 8-bit digital adder in modern silicon switches a few femtojoules. The thermodynamic floor is about 108 below current practice, so physics is not the binding limit; architecture is.
| Cost term in a B2026 token | Why it is large today | Floor it could reach | Invention that attacks it |
|---|---|---|---|
| Weights moved per token | Stored weights are fetched from HBM or SRAM for every use, amortized only by huge batches | Zero: weights that are wires are never fetched | Wired-weight ternary silicon (2) |
| Multiply-accumulate energy | General FP4 multipliers, about 0.1 to 0.5 pJ per operation with operand movement | Tens of fJ: ternary weights need only add, subtract or skip | Wired ternary plus shared partial sums (2) |
| Parameters touched per token | Knowledge lives in the same weights that do reasoning, so 49B active weights fire per token | A small reasoning core plus O(1) lookups | Split mind (1), lookup-in-storage (4) |
| Per-user context state | KV cache grows with context and is re-read every token | A fixed recurrent state plus a few KB of sparse attention reads | Context cartridges (6) |
| Tokens per task | Rose from ~35k to ~59k median in one Artificial Analysis index revision | Several times fewer at equal score (already a 4.4x spread between near-equal models) | Cost-priced tokens (5) |
| Capital and mask cost per token | Accelerators cost ~$50k+; a hardwired chip needs new masks per model | Commodity silicon programmed in one via layer | Freezable core (3), via-programmed fabric (2) |
Each row's floor is reachable only if the row above it is solved too. Once weights stop moving, per-user state becomes the dominant data movement; once compute is nearly free, capital and mask cost dominate dollars. That ordering explains why the inventions come as a set.
Source: research/02-corerope-design.md, lines 21 to 36Edit on GitHub
What one weight costs per token, from fetching it to wiring it
Energy per weight per token. The hollow dot is an assumption, not a measurement: experiment 1 tests it.
Show the numbers
| Step | Picojoules | What it is |
|---|---|---|
| H100: read one 8-bit weight from HBM | 93.4 | measured coefficient |
| H100: the 2 FLOPs that weight feeds | 1.04 | measured coefficient |
| Taalas HC1: hardwired 4-bit, per parameter | 1.95 | derived from vendor and EE Times figures |
| Corerope: wired ternary, shared sums (assumed) | 0.1 (0.03 to 0.3) | assumption to test (experiment 1) |
Every task stays on wired silicon: a 1% GPU fallback caps the gain at 92x
The two-tier fleet. A router sends each task to the small wired core; only what it cannot do climbs to a larger wired core, and almost nothing reaches GPUs.
Cost model, central case: a GPU fallback share of 0% gives 1,196x less energy per task; 0.1% gives 545x, 1% gives 92x and 5% gives 20x.