Corerope

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.

The stack has seven parts:

  1. Move knowledge out of the matrix multiplies, so that per-token compute scales with reasoning and not with facts.
  2. Freeze that small reasoning core into silicon as ternary wiring, not stored weights, so no weight is ever fetched.
  3. 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.
  4. Make the core freezable for years, so every model update lands in rewritable memory instead of a new chip.
  5. Program the silicon in a single via layer, so a new model costs about $3M of masks instead of $40M.
  6. Price tokens per task into training, so cheap tokens are not spent on longer reasoning.
  7. Keep every task on the new stack: the cost model shows a 1% fallback to GPU serving caps the energy gain at about 92x.

The seven parts, one page each

The 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 tokenWhy it is large todayFloor it could reachInvention that attacks it
Weights moved per tokenStored weights are fetched from HBM or SRAM for every use, amortized only by huge batchesZero: weights that are wires are never fetchedWired-weight ternary silicon (2)
Multiply-accumulate energyGeneral FP4 multipliers, about 0.1 to 0.5 pJ per operation with operand movementTens of fJ: ternary weights need only add, subtract or skipWired ternary plus shared partial sums (2)
Parameters touched per tokenKnowledge lives in the same weights that do reasoning, so 49B active weights fire per tokenA small reasoning core plus O(1) lookupsSplit mind (1), lookup-in-storage (4)
Per-user context stateKV cache grows with context and is re-read every tokenA fixed recurrent state plus a few KB of sparse attention readsContext cartridges (6)
Tokens per taskRose from ~35k to ~59k median in one Artificial Analysis index revisionSeveral times fewer at equal score (already a 4.4x spread between near-equal models)Cost-priced tokens (5)
Capital and mask cost per tokenAccelerators cost ~$50k+; a hardwired chip needs new masks per modelCommodity silicon programmed in one via layerFreezable 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.

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.

H100: read one 8-bit weight from HBMmeasured coefficient
H100: the 2 FLOPs that weight feedsmeasured coefficient
Taalas HC1: hardwired 4-bit, per parameterderived from vendor and EE Times figures
Corerope: wired ternary, shared sums (assumed)assumption to test (experiment 1)
Picojoules per weight per token (log scale)
Show the numbers
Energy per weight per token
StepPicojoulesWhat it is
H100: read one 8-bit weight from HBM93.4measured coefficient
H100: the 2 FLOPs that weight feeds1.04measured coefficient
Taalas HC1: hardwired 4-bit, per parameter1.95derived 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.