An open research program
Making a frontier-quality LLM roughly 1000x cheaper to run
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.
Nothing here is proven at scale. Each part comes with the first experiment that would falsify it.
Source: research/02-corerope-design.md, lines 5 to 19Edit on GitHub
The numbers, and how sure they are
The design's cost model against a late-2026 frontier deployment (B2026), beside what the survey found every known lever can do against the same baseline.
Less energy per solved task, central case
749x
Range 15x to 46,009x. Modeled, not measured.
Lower cost per solved task, central case
263x
Range 1.9x to 10,533x. Modeled, not measured.
What the known levers give against B2026, central
~35x in dollars
~80x in energy. The survey's overlap-adjusted estimate.
Gain per task if 1% of tasks fall back to GPUs
92x
Why every task must stay on the new stack.
Central case: 749x less energy and 263x lower cost per task
How many times cheaper the Corerope stack would be than a late-2026 frontier deployment (B2026), from its cost model. The dot is the central case; the whisker runs from the pessimistic to the optimistic case.
A model of a design, not a measurement: every input is an assumption that the experiments on this site would test.
Show the numbers
| Measure | Pessimistic | Central | Optimistic |
|---|---|---|---|
| Energy per task (per task) | 15x | 749x | 46,009x |
| Dollars per task (per task) | 1.9x | 263x | 10,533x |
| Energy per token (per token) | 27x | 801x | 11,502x |
| Dollars per token (per token) | 2.9x | 203x | 2,633x |
The name
Weights woven into the hardware
The Apollo Guidance Computer stored its software in core rope memory: each bit was set by whether a wire was threaded through a magnetic core or around it, so the program was literally woven into the hardware. Corerope does the same with a neural network's weights: in wired-weight silicon a weight is a connection to an adder's plus input, its minus input, or nothing.
Core rope memory. A wire threaded through a core is a 1; a wire passing around it is a 0. The Apollo Guidance Computer's software was woven in this way, so it could not change.
A wired weight. Each input is wired to an adder's plus input (+1), its minus input (−1), or nothing (0). No weight is stored, so none is ever fetched, and no multiplier exists.
Two layers: a survey of what exists, and a design for what does not
Stacked levers reach 1000x only against 2024
A roughly 1000x cut in cost and energy per solved task, at fixed quality, is credible against a 2024 baseline (a dense ~405B transformer in BF16 on H100s) but not, on current evidence, against the late-2026 frontier.
| Central estimate, per solved task | Dollars | Energy |
|---|---|---|
| Against B2024 (dense 405B, H100) | ~700x | ~2,000x |
| Against B2026 (late-2026 frontier) | ~35x | ~80x |
Seven inventions for the gap the levers cannot close
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.
Where to go next
The baseline
Why the unit is dollars and joules per solved task, and why 2024 and 2026 give different answers.
2The levers
Every known efficiency lever as of November 2026: its measured gain, its quality cost, and what it overlaps.
3The design
Each invention, the cost term it attacks, and the experiment that would falsify it.
4The cost model
Every assumption as a slider, running the same arithmetic as costmodel.py.
5Experiments
What was synthesized and modeled, re-run for this site, and the seven experiments to run next.
6Risks and prior art
What could kill the design, the gaps in the evidence, and the work it builds on.