The cost model
Change any assumption; see what is left of 1000x
Built fromexperiments/cost-model/costmodel.py (edit)research/02-corerope-design.md (edit)
The design doc's headline: one via mask per model (~$3M NRE) and 0.05% GPU fallback.
Against B2026, with these assumptions
Less energy per solved task
749x
1.3x short of 1000x
Lower cost per solved task
263x
3.8x short of 1000x
Less energy per token
801x
1.2x short of 1000x
Lower cost per token
203x
4.9x short of 1000x
Bar: 1x to 100,000x on a log scale. Dashed line: 1000x. Ring: the central preset of this scenario.
The Amdahl cap
With 0.05% of tasks on GPUs at baseline cost, no gain per task can exceed 2,000x.
- Capital 66.9%
- Per-model NRE 16.9%
- Memory-tier storage 10.1%
- Electricity 6.1%
- Core energy per token
- 0.6 mJ
- Token energy, with state and overheads
- 1.04 mJ
- Throughput per core set
- 961,538 tok/s
- Baseline (B2026)
- 1 J and $0.12 per M tokens
The multiplier budget against the late-2026 frontier
In the central case the stack is 749x cheaper in energy and 263x cheaper in dollars per solved task, and 1000x lies inside both ranges. The spread runs from 15x to 46,000x in energy because the assumptions compound: a core twice as large, three times more energy per weight and no sparsity gain together cost two orders of magnitude.
Source: research/02-corerope-design.md, line 148Edit on GitHub
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 model prices one core set (dies, package and HBM for per-user state) against its throughput, adds energy, per-model NRE and memory-tier storage, then applies tokens per task and the Tier B and GPU shares. Its main assumptions:
| Assumption | Pessimistic | Central | Optimistic |
|---|---|---|---|
| Tier A core size, ternary weights | 24B | 12B | 8B |
| Energy per weight-operation, incl. wiring | 0.3 pJ | 0.1 pJ | 0.03 pJ |
| Event-driven sparsity gain | 1x | 2x | 4x |
| Tokens per task vs baseline | 1.5x more | 1.5x fewer | 4x fewer |
| Tasks to Tier B / to GPUs | 10% / 1% | 5% / 0.05% | 2% / 0% |
| Core-set capital at utilization | $40k at 35% | $15k at 50% | $8k at 70% |
| Per-model NRE over lifetime tokens | $20M over 1016 | $3M over 3 x 1016 | $1M over 1017 |
| Baseline energy per token | 0.5 J | 1 J | 2 J |
Source: research/02-corerope-design.md, lines 152 to 163Edit on GitHub
Dollars lag energy because capital dominates once energy is nearly free. In the central case a million tokens costs about $0.00059: capital is two thirds of it, NRE 17%, memory storage 10% and electricity only 6%. Reaching 1000x in dollars needs cheaper or harder-worked silicon, not more efficiency.
Source: research/02-corerope-design.md, line 165Edit on GitHub
Capital is 66.9% of a million tokens' cost; electricity only 6.1%
Dollars per million tokens on the wired fleet, split into the terms the cost model adds. Once energy is nearly free, the price of the silicon dominates.
- Capital (core sets over their life) 66.9%, $0.0004
- Per-model NRE (masks, design, verification) 16.9%, $0.0001
- Memory-tier storage 10.1%, $0.00006
- Electricity 6.1%, $0.000036
The other cases, for comparison:
Show the numbers
| Term | Pessimistic | Central | Optimistic |
|---|---|---|---|
| Capital (core sets over their life) | $0.038 (92.6%) | $0.0004 (66.9%) | $0.00001 (23%) |
| Per-model NRE (masks, design, verification) | $0.002 (4.92%) | $0.0001 (16.9%) | $0.00001 (21.9%) |
| Memory-tier storage | $0.0003 (0.74%) | $0.00006 (10.1%) | $0.000022 (47.4%) |
| Electricity | $0.00073 (1.79%) | $0.000036 (6.1%) | $0.0000035 (7.63%) |
| Total | $0.041 | $0.00059 | $0.000046 |
Every task that falls back to GPUs pulls the gain toward 1/share
The cost model's central case, run at each GPU fallback share. A share f at baseline cost caps the gain per task at 1/f, however cheap the rest becomes.
- Energy per task
- Dollars per task, $3M NRE (via fabric)
- Dollars per task, $40M NRE (new chip)
- Ceiling: 1 / share
With no fallback at all: 1,196x less energy, 303x lower cost with a $3M per-model NRE, and 98x with $40M.
Show the numbers
| Share on GPUs | Energy per task | Dollars, $3M NRE | Dollars, $40M NRE (as recorded) |
|---|---|---|---|
| 0% | 1,196x | 303x | 98x |
| 0.05% | 749x | 263x | 94x |
| 0.1% | 545x | 233x | 89x |
| 1% | 92x | 75x | 50x |
| 5% | 20x | 19x | 17x |
The model itself
One short Python file. S holds each assumption's pessimistic, central and optimistic value; run(i) turns one case into multipliers. The scripts that turn its output into this site's charts live in scripts/data/costmodel_data.py.
experiments/cost-model/costmodel.py58 lines
"""Thousandfold cost model: energy and dollars per solved task vs B2026.
B2026 = DeepSeek-V4-Pro-class on GB300 NVL72, $0.12 per M output tokens at ~27 tok/s/user (InferenceX via Silicon Report),
energy per output token ~0.5-2 J (derived; Rubin measured ~10 J at 300 tok/s/user, B200 ~0.36 J on a 5B-active model)."""
S = { # low (pessimistic), central, high (optimistic)
'base_J_per_tok': (0.5, 1.0, 2.0),
'base_usd_per_Mtok': (0.12, 0.12, 0.12),
'core_active_B': (24, 12, 8), # wired ternary reasoning core, billions of weights
'pJ_per_weight_op': (0.3, 0.1, 0.03), # wired ternary + shared partial sums, incl. wiring
'act_sparsity_gain': (1.0, 2.0, 4.0), # event-driven: zero activations do not toggle fanout
'data_mJ_per_tok': (0.6, 0.2, 0.08), # recurrent state + sparse global attn + memory-tier lookups
'overhead_mult': (1.6, 1.3, 1.15), # leakage, I/O, control, sampling
'tok_ratio': (1.5, 0.67, 0.25), # new tokens per task / baseline tokens per task
'deep_share': (0.10, 0.05, 0.02), # tasks escalated to a 5x larger wired deep core
'deep_cost_ratio': (6, 5, 5),
'gpu_share': (0.01, 0.001, 0.0), # tasks that still fall back to B2026-class GPUs
'set_capex_usd': (40e3, 15e3, 8e3), # one core set: dies + package + HBM for state
'set_power_W': (600, 1000, 2000),
'utilization': (0.35, 0.5, 0.7),
'life_years': (3, 3, 3),
'usd_per_kWh': (0.10, 0.08, 0.06),
'pue': (1.4, 1.3, 1.2),
'nre_usd': (150e6, 40e6, 10e6), # per frozen-core generation (masks + design + verification)
'life_tokens': (1e16, 3e16, 1e17), # tokens served by one frozen core generation
'memtier_usd_per_Mtok':(2e-4, 5e-5, 2e-5),
}
def run(i):
p = {k: v[i] for k, v in S.items()}
core_mJ = p['core_active_B']*1e9 * p['pJ_per_weight_op']*1e-12 / p['act_sparsity_gain'] * 1e3
tok_mJ = (core_mJ + p['data_mJ_per_tok']) * p['overhead_mult']
# per-token cost of the tiered wired fleet (deep core priced as a multiple), then GPU fallback by share
wired_mix = (1 - p['deep_share']) + p['deep_share'] * p['deep_cost_ratio']
E_new_tok = tok_mJ * 1e-3 * wired_mix # J per token, wired tiers
thr = p['set_power_W'] / (tok_mJ * 1e-3) # tok/s per set at full power
capex = p['set_capex_usd'] / (p['life_years']*3.156e7 * thr * p['utilization']) * 1e6
energy_usd = tok_mJ*1e-3 * p['pue'] / 3.6e6 * p['usd_per_kWh'] * 1e6
nre = p['nre_usd'] / p['life_tokens'] * 1e6
usd_new_tok = (capex + energy_usd + p['memtier_usd_per_Mtok']) * wired_mix + nre
# per task: tokens ratio, then Amdahl blend with GPU fallback at baseline cost per task
E_task = (1-p['gpu_share']) * E_new_tok * p['tok_ratio'] + p['gpu_share'] * p['base_J_per_tok']
U_task = (1-p['gpu_share']) * usd_new_tok * p['tok_ratio'] + p['gpu_share'] * p['base_usd_per_Mtok']
return dict(core_mJ=core_mJ, tok_mJ=tok_mJ, tok_per_s_per_set=thr,
usd_per_Mtok=dict(capex=capex, energy=energy_usd, nre=nre, total=usd_new_tok),
energy_x_per_token=p['base_J_per_tok']/E_new_tok, usd_x_per_token=p['base_usd_per_Mtok']/usd_new_tok,
energy_x_per_task=p['base_J_per_tok']/E_task, usd_x_per_task=p['base_usd_per_Mtok']/U_task)
for i, name in enumerate(['low', 'central', 'high']):
r = run(i)
print(f"{name:8s} core {r['core_mJ']:.3f} mJ | token {r['tok_mJ']:.3f} mJ | {r['tok_per_s_per_set']:,.0f} tok/s/set | "
f"$/Mtok capex {r['usd_per_Mtok']['capex']:.5f} energy {r['usd_per_Mtok']['energy']:.6f} nre {r['usd_per_Mtok']['nre']:.5f} total {r['usd_per_Mtok']['total']:.5f}")
print(f" energy x/token {r['energy_x_per_token']:,.0f} x/task {r['energy_x_per_task']:,.0f} | dollars x/token {r['usd_x_per_token']:,.0f} x/task {r['usd_x_per_task']:,.0f}")
# Amdahl illustration: GPU fallback share caps the gain
print("Amdahl cap (energy x/task, central otherwise):")
for s in [0.0, 0.0005, 0.001, 0.01, 0.05]:
S['gpu_share'] = (S['gpu_share'][0], s, S['gpu_share'][2]); print(f" fallback {s:.2%}: {run(1)['energy_x_per_task']:,.0f}x energy, {run(1)['usd_x_per_task']:,.0f}x dollars")
print("With via-programmed fabric (NRE per model ~$3M central) and 0.05% GPU fallback:")
S['nre_usd'] = (20e6, 3e6, 1e6); S['gpu_share'] = (0.01, 0.0005, 0.0)
for i, name in enumerate(['low', 'central', 'high']):
r = run(i); u = r['usd_per_Mtok']
print(f" {name:8s} energy x/task {r['energy_x_per_task']:,.0f} | dollars x/task {r['usd_x_per_task']:,.0f} | $/Mtok capex {u['capex']:.5f} nre {u['nre']:.5f} total {u['total']:.5f}")