Corerope

Experiments

Experiments: what was tested, and what to run next

This session tested only the silicon arithmetic: synthesized gate counts for wired layers, an add-count model of shared partial sums at full layer width, and the cost model behind the chart. Everything about model quality is untested. The seven experiments below would confirm or kill the design, ordered so that the cheapest decisive ones run first.

What was run, and re-run for this site

Three pieces of arithmetic about the silicon, recorded in RESULTS.md. This site's build pipeline runs all three again from the scripts in the repository and checks the output against the record.

Wired-layer gate counts, Yosys 0.71

15 of 15

Designs whose cell count matches the recorded one exactly.

Shared partial-sum add counts

All match

Every ratio for the four layer shapes, to two decimals.

Cost model, three cases and the Amdahl sweep

Exact

Central case 749x energy per task, as recorded. The site's TypeScript port matches to the last bit.

Wired ternary needs about 30 gates per weight; wired 4-bit about 75, a stored-weight MAC 435

Generic gates per weight after synthesis, for hardwired matrix-vector layers with random weights (8-bit activations unless noted). Fewer gates means less switching.

Stored-weight 4-bit MAC, the GPU-style unit, per operationplus the weight fetch
435
Wired 4-bit weights, 32 x 32 layer
75.0
Wired ternary, 32 x 32 layer (40% zeros)
30.8
Wired ternary, 4-bit activations
20.0
Wired ternary, 48 x 256, direct
26.1
Wired ternary, 48 x 256, shared partial sums (groups of 4)
16.1
  • Stored weights (GPU-style)
  • Wired 4-bit weights
  • Wired ternary weights

A proxy for switching energy, not a measurement of it: wire capacitance is left out, and Yosys ran without ABC optimization, so absolute counts are high but the ratios are like for like. Re-run for this site with Yosys 0.71: 15 of 15 cell counts match the recorded ones.

Show the numbers
Every synthesized design
DesignLayerActivation bitsGroupCells (re-run)Cells (recorded)Gates per weight
Wired ternary, direct48 x 25681320,496320,49626.1
Wired ternary, direct48 x 648186,17786,17728.1
Wired 4-bit weights32 x 32450,07150,07148.9
Wired 4-bit weights32 x 32876,77676,77675.0
Stored-weight 4-bit MAC, per operation1 x 14315315315.0
Stored-weight 4-bit MAC, per operation1 x 18435435435.0
Wired ternary, shared partial sums48 x 25683217,214217,21417.7
Wired ternary, shared partial sums48 x 25684198,169198,16916.1
Wired ternary, shared partial sums48 x 25686224,306224,30618.3
Wired ternary, shared partial sums48 x 648361,81661,81620.1
Wired ternary, shared partial sums48 x 648461,71561,71520.1
Wired ternary, shared partial sums48 x 648673,89573,89524.1
Wired ternary32 x 32420,47720,47720.0
Wired ternary32 x 32831,53531,53530.8
Wired ternary64 x 648120,218120,21829.4

Sharing partial sums saves more as layers get wider: up to 2.9x fewer adds

Adds for a hardwired ternary layer when every signed combination of a group of g inputs is built once and shared by every output row, against adding each row's inputs directly.

  • 48 x 64 layer
  • 48 x 256 layer
  • 1,024 x 1,024 layer
  • 4,096 x 4,096 layer

An add-count model, not a synthesis: random ternary weights with 40% zeros. Re-run for this site: every ratio matches the recorded output.

Show the numbers
Saving by layer and group size
Layerg = 1g = 3g = 4g = 5g = 6g = 7g = 8
48 x 641.00x1.60x1.42x1.24x1.06x1.19x1.01x
48 x 2561.00x1.86x2.02x1.71x1.27x1.24x1.03x
1,024 x 1,0241.00x1.90x2.31x2.38x1.86x1.35x1.12x
4,096 x 4,0961.00x1.92x2.42x2.84x2.85x2.19xnot run

Seven experiments, cheapest decisive first

Each one confirms or kills a part of the design. Nothing about model quality has been tested yet; experiments 2 to 6 are where that happens.

Experiment 1

Post-layout energy of a 1024 x 1024 wired ternary tile with shared sums, driven by real activation traces, in a 5nm-class flow

Tests
Invention 2's 0.1 pJ per weight-operation
Pass bar
At most 0.15 pJ including wiring and leakage
If it fails
Above 0.5 pJ, wired silicon is only a speed play, as Taalas's cost figures suggest; drop to stored-weight ASICs

Experiment 2

Hard-task share: run a frontier agentic and reasoning suite through 8 to 15B models with retrieval, then 60B models

Tests
The Amdahl section's 5% and 0.05% shares
Pass bar
Tier A solves at least 90%; fewer than 0.1% need more than Tier B
If it fails
The two-tier fleet caps at ~20 to 50x; redesign Tier B larger

Experiment 3

Inference-priced allocation law: cores of 0.5 to 3B with memory tiers 0 to 100x their size

Tests
Invention 1, and where Engram's U-curve moves when memory is priced at its inference cost
Pass bar
A 3B core plus memory matches a model with 3x its active compute on knowledge, within 2 points on math and code
If it fails
Knowledge and reasoning do not separate; the core must grow, and the central case drifts toward the pessimistic one

Experiment 4

Native ternary training at 3 to 8B with dReLU-style activation sparsity

Tests
Event-driven gain and the precision penalty
Pass bar
Within 1.5% loss of FP8 at equal compute, at least 70% zero activations, under 1.2x longer reasoning
If it fails
Fall back to 2 to 3-bit wired weights at ~2x the gates

Experiment 5

Freeze regret: freeze a 1 to 3B core, update only memory and adapters over 12 months of time-sliced data

Tests
Invention 3
Pass bar
Under 1 point behind a retrained model at 12 months
If it fails
Chip life shortens and NRE per token rises in proportion

Experiment 6

Joule-priced RL on an open reasoning model, scored per solved task

Tests
Invention 5
Pass bar
At least 2x fewer tokens per solved task at 1 point or less
If it fails
Tokens per task becomes the pessimistic 1.5x inflation

Experiment 7

Via-programmed fabric: foundry quote and a routing study for choosing 1 of ~40 sum wires per input with one via layer

Tests
The $3M NRE assumption
Pass bar
One-layer customization at under 2x area
If it fails
NRE returns to ~$40M; dollars fall back to ~90x per task

The survey's program, for GPUs

Before the design, the survey laid out what a well-resourced team could run with techniques that exist today. Its kill criteria are the same discipline the design's experiments follow.

A ranked, four-phase program a well-resourced team could run#

The reference design follows from where the remaining headroom sits. The flagship is a fine-grained MoE of ~2T total and ~20 to 25B active parameters (about 1 to 1.25% activation), with expert granularity near the 8 to 12 optimum identified by the Ling scaling laws (arXiv 2507.17702). It is trained natively in NVFP4 with fewer than 15% of linear layers kept in higher precision, following NVIDIA's recipe (arXiv 2509.25149), and its experts move to Rubin's ~3.125-bit LUT format or to ternary only if Phase 1 clears the bar. Its attention stack uses three Gated DeltaNet or KDA layers for each global layer, where the global layer is CSA/HCA-style compressed-sparse attention with an FP4 indexer, MLA-style latents and NVFP4 KV; the global-attention ratio stays tunable until frontier-scale multi-hop evaluations pass, to guard against the MiniMax failure. It supports 1M-token context, with recurrent-state checkpoints at chunk boundaries so prefix caching works, and ships trained-in MTP heads plus a DSpark-style parallel drafter designed for state rollback. Post-training uses RL with an explicit compute-cost term in the reward, AdaptThink-style skip-thinking, loop detection and several effort levels, and offloads long-tail knowledge to retrieval and tools to stay under the ~2 bits per parameter ceiling. The student is a ~3 to 4B-active MoE distilled from the flagship, sharing its tokenizer and drafter, trained with native low-bit QAT and a small KV footprint, with frozen base weights so it can be hardwired and adapters held in SRAM. In the fleet, a small router plus verifier assigns each task to the student or the flagship and picks an effort level; the flagship serves on Rubin NVL72 with disaggregated prefill and decode, wide expert parallelism and KV-aware routing, while the student runs on hardwired-ROM or SRAM-dataflow silicon.

Research bets ranked by expected value against B2026#

RankBetCredited central vs B2026ConfidenceWhy it ranks here
1Per-task accounting, cost-aware reasoning RL, effort control, routing cascade~4xHighMultiplies with everything; 4.4x token and ~8x cost spreads exist today at near-equal scores
2Rubin-class deployment, disaggregated wide-EP serving, co-trained MTP/parallel drafter~3xHighIndependently measured 2-5x per generation; 1.2-2.8x software gains in six months
3Hybrid linear plus compressed-sparse attention with 4-bit KV~1.5-2x at agentic contextsMedium-highDeepSeek and Kimi data are strong, but MiniMax's scale failure is unresolved
4Native sub-4-bit experts and ~1.5% activation~1.5-2xMediumNo frontier-scale equal-compute ternary result; precision law predicts a parameter penalty
5Distilled student plus retrieval offload of knowledge~1.5-2x on routed shareMediumDensing law is real; brittleness and the knowledge floor cap it
6Hardwired or SRAM silicon for the frozen student~1.3x cost, 2-10x energy on routed shareMedium-lowOnly vendor data plus one hands-on demo; respin cost and model churn
7Analog in-memory and photonic tiersNot budgetedLowSimulation and single-layer demos only
DroppedEarly exit, mixture-of-depths, unstructured pruning, diffusion as main decoderUnder 1.2xGains small, shrinking, or quality-limited at frontier

Phases, milestones and kill criteria#

PhaseMonthsWorkExit milestoneKill or redirect criterion
0. Measure0-4Rebuild B2024 and B2026 on rented H100 and GB300/Rubin. Build a fixed agentic plus reasoning suite. Meter prefill, decode and idle power. Ablate FP8 vs FP4 KV, MTP, effort and routing on existing open models (V4-Flash, Qwen3.5, gpt-oss)Baselines reproduce InferenceX and Epoch within ~30%. Routing plus effort control gives ≥3x $/task at ≤1 point loss on held-out tasksIf routing gains fall below 2x, re-weight toward model-side work
1. Factorial co-design at 1-10B active3-12Grid over activation {3%, 1.5%, 0.75%}, precision {FP8, NVFP4, 3-bit LUT, ternary native}, attention {3:1, 7:1 hybrid, CSA-only} and MTP depth. Train to ~800 tokens/param with equal-compute baselines. Evaluate multi-hop and retrieval at 128KInteraction matrix showing which pairs compound. Sub-4-bit passes at ≤1.5% loss gap and ≤1.2x reasoning-length growth. Hybrid passes on multi-hop parity at 128KDrop sub-4-bit if trace inflation appears (the 2-bit failure mode); fall back to CSA-only if hybrids fail multi-hop
2. Flagship and student9-24Pretrain ~2T/20-25B-active flagship with the Phase 1 winners. Cost-aware RL post-training. Distill the 3-4B-active student. Ship state-checkpointed prefix cachingWithin ~2 points of the contemporaneous open frontier at ≥10x lower $/task on the same Rubin hardware. Student solves ≥60% of routed tasksBelow 5x: hold the architecture and invest in serving software instead
3. Silicon and fleet18-36Tape out a hardwired or SRAM chip for the frozen student (2-month respin cadence, adapters in SRAM). Run the production cascade. Pilot analog or photonic on one frozen expert bank or attention substitute≥30x $/task and ≥80x J/task against B2026 on the fixed suite. Silicon tier ≥5x J/task vs Rubin on its routed shareIf student churn exceeds respin economics, keep the student on SRAM-dataflow or GPUs

The scripts

As recorded, unchanged. The site's data step runs them; nothing on this site is typed in by hand.

experiments/wired-layers/gen.py40 lines, generates a hardwired layer or a stored-weight MAC as Verilog
import numpy as np, sys
rng = np.random.default_rng(0)
def wired(kind, N, M, abits, zero_frac=0.4):
    """y = W x with W hardwired. kind: 'ternary' or 'int4'."""
    if kind == 'ternary':
        W = rng.choice([-1,0,1], size=(M,N), p=[(1-zero_frac)/2, zero_frac, (1-zero_frac)/2])
    else:
        W = rng.integers(-8, 8, size=(M,N))
    ob = abits + 4 + int(np.ceil(np.log2(N))) + 1
    L = [f"module top(input signed [{N*abits-1}:0] xin, output signed [{M*ob-1}:0] yout);"]
    for i in range(N):
        L.append(f"  wire signed [{abits-1}:0] x{i} = xin[{(i+1)*abits-1}:{i*abits}];")
    for j in range(M):
        terms = []
        for i in range(N):
            w = int(W[j,i])
            if w == 0: continue
            if kind == 'ternary':
                terms.append(("+ " if w > 0 else "- ") + f"x{i}")
            else:
                terms.append(f"+ ({w} * x{i})")
        expr = " ".join(terms) if terms else "0"
        if expr.startswith("+ "): expr = expr[2:]
        L.append(f"  wire signed [{ob-1}:0] y{j} = {expr};")
        L.append(f"  assign yout[{(j+1)*ob-1}:{j*ob}] = y{j};")
    L.append("endmodule")
    nnz = int((W != 0).sum())
    return "\n".join(L), nnz

def mac(abits, wbits=4):
    acc = abits + wbits + 8
    return f"""module top(input signed [{wbits-1}:0] w, input signed [{abits-1}:0] x, input signed [{acc-1}:0] a, output signed [{acc-1}:0] y);
  assign y = a + w * x;
endmodule""", 1

if __name__ == "__main__":
    kind, N, M, abits = sys.argv[1], int(sys.argv[2]), int(sys.argv[3]), int(sys.argv[4])
    src, nnz = mac(abits) if kind == 'mac' else wired(kind, N, M, abits)
    open(f"{kind}_{N}x{M}_a{abits}.v", "w").write(src)
    print(nnz, N*M)

experiments/wired-layers/gen2.py40 lines, the same layer with shared partial sums
# Ternary hardwired layer with shared partial-sum wiring (SPW):
# split inputs into groups of g; build each signed combination used by any row ONCE; rows add one term per group.
import numpy as np, sys
kind, N, M, abits, g = sys.argv[1], int(sys.argv[2]), int(sys.argv[3]), int(sys.argv[4]), int(sys.argv[5])
rng = np.random.default_rng(0)
W = rng.choice([-1,0,1], size=(M,N), p=[0.3,0.4,0.3])
ob = abits + int(np.ceil(np.log2(N))) + 2
L = [f"module top(input signed [{N*abits-1}:0] xin, output signed [{M*ob-1}:0] yout);"]
for i in range(N):
    L.append(f"  wire signed [{abits-1}:0] x{i} = xin[{(i+1)*abits-1}:{i*abits}];")
if kind == 'direct':
    for j in range(M):
        t = [("+ " if W[j,i]>0 else "- ")+f"x{i}" for i in range(N) if W[j,i]!=0]
        e = " ".join(t) or "0"; e = e[2:] if e.startswith("+ ") else e
        L.append(f"  assign yout[{(j+1)*ob-1}:{j*ob}] = {e};")
else:
    G = N//g; pb = abits + int(np.ceil(np.log2(g))) + 1
    nsums = 0
    rowterms = [[] for _ in range(M)]
    for k in range(G):
        cols = list(range(k*g, (k+1)*g))
        seen = {}
        for j in range(M):
            pat = tuple(int(v) for v in W[j, cols])
            if all(v == 0 for v in pat): continue
            # canonical sign: first nonzero positive; reuse negation
            s = next(v for v in pat if v != 0)
            canon = tuple(v*s for v in pat)
            if canon not in seen:
                name = f"p{k}_{len(seen)}"; seen[canon] = name
                t = [("+ " if v>0 else "- ")+f"x{cols[q]}" for q,v in enumerate(canon) if v!=0]
                e = " ".join(t); e = e[2:] if e.startswith("+ ") else e
                L.append(f"  wire signed [{pb-1}:0] {name} = {e};"); nsums += 1
            rowterms[j].append(("+ " if s>0 else "- ") + seen[canon])
    for j in range(M):
        e = " ".join(rowterms[j]) or "0"; e = e[2:] if e.startswith("+ ") else e
        L.append(f"  assign yout[{(j+1)*ob-1}:{j*ob}] = {e};")
L.append("endmodule")
open(f"{kind}_{N}x{M}_a{abits}_g{g}.v","w").write("\n".join(L))
print(f"{kind}_{N}x{M}_a{abits}_g{g}.v", int((W!=0).sum()), N*M)

experiments/wired-layers/run.sh9 lines, synthesizes one design and prints its cell count
#!/bin/bash
read nnz tot < <(python3 gen.py "$@")
f="$1_$2x$3_a$4.v"
yowasp-yosys -p "read_verilog $f; synth -flatten -noabc -top top; opt -full; opt_clean; stat" > "log_$f.txt" 2>&1
cells=$(grep -E "^\s+[0-9]+ +cells$|^\s+[0-9]+ cells$" "log_$f.txt" | tail -1 | grep -oE "[0-9]+")
[ -z "$cells" ] && cells=$(grep -iE "number of cells" "log_$f.txt" | tail -1 | grep -oE "[0-9]+$")
python3 -c "
c=int('${cells:-0}'); t=$tot; n=$nnz
print(f'$1 N=$2 M=$3 abits=$4 weights={t} nonzero={n} gates={c} gates/weight={c/t:.2f} gates/nonzero={c/max(n,1):.2f}')"

experiments/wired-layers/run2.sh5 lines, the same, for gen2.py's designs
#!/bin/bash
read f nnz tot < <(python3 gen2.py "$@")
yowasp-yosys -p "read_verilog $f; synth -flatten -noabc -top top; opt -full; opt_clean; stat" > "log_$f.txt" 2>&1
cells=$(grep -E "^\s+[0-9]+ cells$" "log_$f.txt" | tail -1 | grep -oE "[0-9]+")
python3 -c "c=int('${cells:-0}'); print(f'$1 N=$2 M=$3 a=$4 g=$5 gates={c} gates/weight={c/$tot:.2f}')"

experiments/spw-model/adds.py23 lines, the add-count model
import numpy as np
rng = np.random.default_rng(0)
def adds(N, M, g, p0=0.4):
    W = rng.choice([-1,0,1], size=(M,N), p=[(1-p0)/2,p0,(1-p0)/2])
    direct = int(np.maximum((W!=0).sum(1)-1,0).sum())
    if g == 1: return direct, direct
    pre = 0; row = np.zeros(M, int)
    for k in range(N//g):
        blk = W[:, k*g:(k+1)*g]
        nz = (blk!=0).any(1); row += nz
        # canonicalize sign by first nonzero
        first = np.where(blk!=0, blk, 0)
        s = np.array([r[r!=0][0] if (r!=0).any() else 1 for r in blk])
        canon = blk * s[:,None]
        uniq = {tuple(r) for r in canon[nz]}
        pre += sum(max(sum(1 for v in u if v)-1,0) for u in uniq)
    return direct, pre + int(np.maximum(row-1,0).sum())
for (N,M) in [(48,64),(48,256),(1024,1024),(4096,4096)]:
    out=[]
    for g in [1,3,4,5,6,7,8]:
        if g>1 and N>=4096 and g>7: continue
        d,s = adds(N,M,g); out.append(f"g{g}:{d/s:.2f}x")
    print(N,M," ".join(out))

experiments/cost-model/costmodel.py58 lines, the cost model
"""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}")

experiments/RESULTS.md53 lines, the recorded outputs
# Recorded experiment results (Nov 19, 2026)

## Wired-layer gate counts (Yosys 0.71, synth -flatten -noabc, generic gates)

```
direct_48x256_a8_g1.v  cells=320496
direct_48x64_a8_g1.v  cells=86177
int4_32x32_a4.v  cells=50071
int4_32x32_a8.v  cells=76776
mac_1x1_a4.v  cells=315
mac_1x1_a8.v  cells=435
spw_48x256_a8_g3.v  cells=217214
spw_48x256_a8_g4.v  cells=198169
spw_48x256_a8_g6.v  cells=224306
spw_48x64_a8_g3.v  cells=61816
spw_48x64_a8_g4.v  cells=61715
spw_48x64_a8_g6.v  cells=73895
ternary_32x32_a4.v  cells=20477
ternary_32x32_a8.v  cells=31535
ternary_64x64_a8.v  cells=120218
```

Gates per weight: stored-weight 4-bit MAC 435 per op (8-bit act), 315 (4-bit act); wired int4 32x32 75.0 (a8), 48.9 (a4); wired ternary 32x32 30.8 (a8), 20.0 (a4); ternary 64x64 29.4; ternary 48x64 direct 28.05, SPW g3 20.12, g4 20.09, g6 24.05; ternary 48x256 direct 26.08, SPW g3 17.68, g4 16.13, g6 18.25.

## SPW add-count model (adds.py): direct adds / SPW adds

```
48 64 g1:1.00x g3:1.60x g4:1.42x g5:1.24x g6:1.06x g7:1.19x g8:1.01x
48 256 g1:1.00x g3:1.86x g4:2.02x g5:1.71x g6:1.27x g7:1.24x g8:1.03x
1024 1024 g1:1.00x g3:1.90x g4:2.31x g5:2.38x g6:1.86x g7:1.35x g8:1.12x
4096 4096 g1:1.00x g3:1.92x g4:2.42x g5:2.84x g6:2.85x g7:2.19x
```

## Cost model (costmodel.py)

```
low      core 7.200 mJ | token 12.480 mJ | 48,077 tok/s/set | $/Mtok capex 0.02511 energy 0.000485 nre 0.01500 total 0.05369
         energy x/token 27  x/task 15 | dollars x/token 2  x/task 1
central  core 0.600 mJ | token 1.040 mJ | 961,538 tok/s/set | $/Mtok capex 0.00033 energy 0.000030 nre 0.00133 total 0.00182
         energy x/token 801  x/task 545 | dollars x/token 66  x/task 89
high     core 0.060 mJ | token 0.161 mJ | 12,422,360 tok/s/set | $/Mtok capex 0.00001 energy 0.000003 nre 0.00010 total 0.00014
         energy x/token 11,502  x/task 46,009 | dollars x/token 885  x/task 3,541
Amdahl cap (energy x/task, central otherwise):
  fallback 0.00%: 1,196x energy, 98x dollars
  fallback 0.05%: 749x energy, 94x dollars
  fallback 0.10%: 545x energy, 89x dollars
  fallback 1.00%: 92x energy, 50x dollars
  fallback 5.00%: 20x energy, 17x dollars
With via-programmed fabric (NRE per model ~$3M central) and 0.05% GPU fallback:
  low      energy x/task 15 | dollars x/task 2 | $/Mtok capex 0.02511 nre 0.00200 total 0.04069
  central  energy x/task 749 | dollars x/task 263 | $/Mtok capex 0.00033 nre 0.00010 total 0.00059
  high     energy x/task 46,009 | dollars x/task 10,533 | $/Mtok capex 0.00001 nre 0.00001 total 0.00005
```