Corerope

The cost model

Change any assumption; see what is left of 1000x

The design's cost model, running in your browser. It prices one core set against its throughput, adds energy, per-model NRE and memory storage, then applies tokens per task and the Tier B and GPU shares.
Scenario
Preset

The design doc's headline: one via mask per model (~$3M NRE) and 0.05% GPU fallback.

The baseline (B2026)
1 J

A late-2026 frontier token on GB300 NVL72: about 0.5 to 2 J, derived from its price and SemiAnalysis's Rubin measurement.

$0.12

DeepSeek-V4-Pro on GB300 at about 27 tok/s per user: $0.12 per million output tokens (InferenceX).

The wired core
12B

The wired ternary reasoning core, in billions of weights. Every weight is a wire, so energy scales with this.

0.1 pJ

Wired ternary with shared partial sums, including wiring. Taalas HC1 implies about 2 pJ per parameter; experiment 1 tests 0.1 pJ.

2x

A zero activation holds its wires still, so nothing downstream switches.

0.2 mJ

Recurrent state, sparse global attention and memory-tier lookups: about 0.2 mJ in the central case.

1.3x

Leakage, I/O, control and sampling, as a multiple of the token's energy.

Tokens and tiers
1.49x fewer

Joule-priced RL, compiled skills and grounded latent reasoning, against a small core's habit of thinking longer.

5%

Tier B is the same design scaled up: a ~60B-weight wired core.

5x

About 5x Tier A's cost per token.

0.05%

The Amdahl trap: a share f at baseline cost caps the gain at 1/f. For 1000x it must stay near 0.05%.

Silicon and power
$15k

Dies, package and HBM for per-user state.

1,000 W

With the energy per token, this sets the set's throughput.

50%

The share of its life a core set is serving.

3 years

Years over which a core set's capital is spread.

$0.08/kWh

Price of a kilowatt-hour at the facility.

1.3

Facility energy over IT energy.

Per-model cost
$3M

Masks, design and verification per frozen-core generation: ~$40M for a new chip, an assumed ~$3M with one via mask.

3 x 10^16

Over which the NRE is spread. A core that stays frozen longer serves more.

$0.00005

A thousand concurrent streams read the same tables, so storage capital per token is negligible.

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.

Dollars per million tokens, wired fleet$0.00059
  • 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.

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.

Per solved task
Energy per task
Dollars per task
Per token
Energy per token
Dollars per token
Times cheaper than B2026 (log scale)

A model of a design, not a measurement: every input is an assumption that the experiments on this site would test.

Show the numbers
Multipliers by case
MeasurePessimisticCentralOptimistic
Energy per task (per task)15x749x46,009x
Dollars per task (per task)1.9x263x10,533x
Energy per token (per token)27x801x11,502x
Dollars per token (per token)2.9x203x2,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:

AssumptionPessimisticCentralOptimistic
Tier A core size, ternary weights24B12B8B
Energy per weight-operation, incl. wiring0.3 pJ0.1 pJ0.03 pJ
Event-driven sparsity gain1x2x4x
Tokens per task vs baseline1.5x more1.5x fewer4x fewer
Tasks to Tier B / to GPUs10% / 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 token0.5 J1 J2 J

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.

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.

Central case$0.00059 per million tokens
  • 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:

Pessimistic case$0.041 per million tokens
Optimistic case$0.000046 per million tokens
Show the numbers
Dollars per million tokens, by term and case
TermPessimisticCentralOptimistic
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
Gain per task by GPU fallback share
Share on GPUsEnergy per taskDollars, $3M NREDollars, $40M NRE (as recorded)
0%1,196x303x98x
0.05%749x263x94x
0.1%545x233x89x
1%92x75x50x
5%20x19x17x

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}")