Two architecture candidates from ASI-Arch, seven lines of evidence, one number each. The weights and the scoring rule were fixed at 01:59 UTC on 12 November 2026, about 90 seconds into the first Fusion run and before any Fusion number had been read. Nobody independent witnessed that.
Bottom line. At full size Fusion #879 scores higher: it was ahead under your objective on 3 of 3 seeds, which is too few to prove it; in every form that could fit at 560 layers neither is ahead.
Fusion #879 is on top of the index: 85.5 to 74.3, a lead of 11.2 points. It stays on top under 86% of 20,000 random re-weightings of the same evidence, so the result does not hinge on my choice of weights (a sensitivity check, not a statistical confidence).
Read this with the headline. The headline scores your objective with each candidate’s faithful form, as the frozen formula says. Only a cut-down form could fit at 560 layers (by parameter count; nobody has run one there). In the low-rank form, at equal steps, DLGM gains 0.117 and Fusion 0.102 nats over the live block (3 and 3 seeds), and the same index then reads DLGM 80.6, Fusion 80.7: neither ahead (a gap of 0.1 points, inside the 3-point band fixed in advance). With a gentler cut that should also fit (low-rank gate, per-channel kernels kept): DLGM 0.120, Fusion 0.112 nats (3 and 3 seeds), index DLGM 80.6, Fusion 83.0: neither ahead (a gap of 2.4 points, inside the 3-point band fixed in advance). Keeping the per-channel kernels recovers about 30% of what Fusion lost in the low-rank form, on average. That points at the full-width gate, the part too large to train at width 8192, as where its full-size lead comes from. With three seeds that share is rough, and these runs do not isolate the cause. With the gate projection trained instead of fixed: DLGM 0.117, Fusion 0.112 nats (3 and 3 seeds), index DLGM 80.6, Fusion 83.3: neither ahead (a gap of 2.8 points, inside the 3-point band fixed in advance).
Each line gives the better candidate 100 points and the other its share of that gain over the shared baseline. Hover a bar for the raw numbers; the table below has all of them.
Index points each line adds to one side (its weight times the score gap). Bars to the left favour DLGM #458, bars to the right favour Fusion #879.
| Evidence | Weight | DLGM | Fusion | Gain over the shared baseline |
|---|---|---|---|---|
| Your objective, same number of training steps Held-out loss after 1,200 steps in the AGILLM-objective simulator (0.6 AR + 0.2 SAT + 0.2 NAT), gain over the live block. Faithful form, all complete seeds. | 35% | 81.9 | 100.0 | simulator, faithful form: DLGM +0.1108, Fusion +0.1352 nats (3 and 3 seeds) |
| Your objective, long context What 4x more context does to the loss (1,024 tokens against 256) at step 1,200, relative to the live block. Faithful form. | 5% | 100.0 | 93.9 | simulator, faithful form: DLGM +0.2495, Fusion +0.2343 nats (3 and 3 seeds) |
| Your objective, same simulator box time The site's equal-time method (step cost = 0.75 x bytes streamed + 0.25 x measured ms per step, against the base run of the same day), gain over the live block. Low-rank form, the one that fits at full scale. | 10% | 0.0 | 0.0 | simulator, low-rank form: DLGM -0.0470, Fusion -0.1505 nats (3 and 3 seeds) |
| Your matched small-model run (v65 R6) Held-out cross-entropy gain over the width-96 Transformer at an equal 120 training-CPU-seconds, about 350k parameters, 3 paired seeds; WikiText and FineWeb scored separately and averaged. | 15% | 100.0 | 81.0 | wikitext: DLGM +0.0677, Fusion +0.0587 nats per byte; fineweb: DLGM +0.0847, Fusion +0.0637 nats per byte |
| ASI-Arch paper: benchmark tasks 7-task average, gain over the Gated DeltaNet baseline; the 20M and 340M runs scored separately and averaged. Single runs. | 15% | 70.6 | 97.3 | 20M parameters: DLGM +1.14, Fusion +2.77 accuracy points; 340M parameters: DLGM +2.03, Fusion +1.92 accuracy points |
| ASI-Arch paper: training loss Final training loss, gain over the Gated DeltaNet baseline; the 20M and 340M runs scored separately and averaged. Single runs. | 10% | 100.0 | 90.6 | 20M parameters: DLGM +0.1778, Fusion +0.1445 nats; 340M parameters: DLGM +0.0721, Fusion +0.0720 nats |
| Serving readiness Rubric: 100 = an exact incremental cache verified against full recompute on trained checkpoints; 50 = a cache that reproduces the same tokens but failed the exact-match gate; 0 = none. | 10% | 50.0 | 100.0 | DLGM 50, Fusion 100 |
| Index | 100% | 74.3 | 85.5 |
The simulator is a small mirror of the live binary-weight block (12 layers, width 256), trained for 1,200 steps with your real mix of objectives and scored on held-out text. Lower loss is better. Candidate layers replace attention on 3 of every 4 layers.
| Run | Seeds | AR | SAT | NAT | Gain, equal steps | 4x context | ms per step | Gain, equal sim time |
|---|---|---|---|---|---|---|---|---|
| Live block (base, base_r2, base_r3; 3 distinct seeds) | 7 | 5.2429 | 5.4642 | 5.8446 | 0 | -0.316 | 202 | 0 |
DLGM #458, faithful form (dlgm458) | 3 | 5.0965 | 5.3806 | 5.8133 | +0.111 ± 0.007 | -0.067 | 461 (x2.37) | -0.003 |
Fusion #879, faithful form (fusion879) | 3 | 5.0718 | 5.3597 | 5.7861 | +0.135 ± 0.004 | -0.082 | 370 (x1.90) | +0.032 |
DLGM #458, low-rank form (dlgm458_lr) | 3 | 5.0901 | 5.3797 | 5.8043 | +0.117 ± 0.002 | -0.089 | 543 (x2.79) | -0.047 |
Fusion #879, low-rank form (fusion879_lr) | 3 | 5.1074 | 5.3908 | 5.8154 | +0.102 ± 0.013 | -0.118 | 744 (x3.82) | -0.150 |
DLGM #458, low-rank gate, per-channel kernels (dlgm458_lrk) | 3 | 5.0851 | 5.3723 | 5.8081 | +0.120 ± 0.011 | -0.071 | 412 (x2.12) | +0.013 |
Fusion #879, low-rank gate, per-channel kernels (fusion879_lrk) | 3 | 5.0983 | 5.3830 | 5.8000 | +0.112 ± 0.004 | -0.088 | 393 (x2.02) | +0.008 |
DLGM #458, low-rank gate with a trained projection, per-channel kernels (dlgm458_lg) | 3 | 5.0904 | 5.3723 | 5.8069 | +0.117 ± 0.025 | -0.058 | 321 (x1.65) | +0.067 |
Fusion #879, low-rank gate with a trained projection, per-channel kernels (fusion879_lg) | 3 | 5.0977 | 5.3826 | 5.8037 | +0.112 ± 0.015 | -0.095 | 280 (x1.44) | +0.066 |
DLGM #458, per-head norm check (dlgm458_hn) | 3 | 5.1091 | 5.3895 | 5.8113 | +0.102 ± 0.004 | -0.073 | 362 (x1.86) | +0.018 |
Fusion #879, per-head norm check (fusion879_hn) | 3 | 5.0830 | 5.3705 | 5.8011 | +0.123 ± 0.006 | -0.061 | 317 (x1.63) | +0.056 |
Gain = live block minus candidate on 0.6 AR + 0.2 SAT + 0.2 NAT, in nats, so positive is better; ± is one standard error across seeds. “4x context” is how much the loss on the last 256 tokens improves when the model also sees the 768 tokens before them (positive helps, negative hurts). “Equal sim time” charges each candidate for its step cost in this small simulator.
“Neither ahead” means the index gap is inside the 3-point band fixed in advance; it does not prove the two are equal. The random re-weighting shows how much the result depends on my choice of weights; it is not a probability that either is better. Each comparison below pairs the two candidates seed by seed.
| At 560 blocks, width 8192 | Binary latents | Extra floating-point parameters for the mixer | Candidate layers |
|---|---|---|---|
| Live block | 886.9 B | 0 | 0 |
| DLGM #458, low-rank | 886.9 B | 10,106,880 | 420 |
| Fusion #879, low-rank | 886.9 B | 17,794,560 | 420 |
| DLGM #458, low-rank router, per-channel kernels | 886.9 B | 180,794,880 | 420 |
| Fusion #879, low-rank gate, per-channel kernels | 886.9 B | 284,067,840 | 420 |
| DLGM #458, the same with the projection trained | 886.9 B | 290,895,360 | 420 |
| Fusion #879, the same with the projection trained | 886.9 B | 394,168,320 | 420 |
| DLGM #458, faithful | 886.9 B | 58,532,302,080 | 420 |
| Fusion #879, faithful | 886.9 B | 60,390,301,440 | 420 |
Both candidates keep every binary matrix of the live block (886.9 billion latents at 560 blocks), so storage and streaming are the same for both. The faithful forms add about 58.5 and 60.4 billion 32-bit parameters for their routers and gates, which is too much to train at this size; the low-rank forms add 10.1 and 17.8 million, under a tenth of a gigabyte, which is nothing; the gentler cut that keeps the per-channel kernels adds about 0.2 and 0.3 billion (0.7 and 1.1 GB of 32-bit weights). Every cut-down form also carries a fixed projection table of 110 million values per candidate (0.44 GB), which this column does not count, and training holds about four times the weight bytes (weights, gradient and two optimizer moments: roughly 2.9 and 4.5 GB for the gentler cut). So only the cut-down forms could run. These are counts of parameters, not measured memory, and no form has been run at this size.
“Equal time” is the simulator’s model, not a full-scale measurement. In the small mirror a candidate step costs two to three times a live-block step, because at width 256 the mixer’s convolutions and memory updates are large next to tiny matrices. At width 8192 the arithmetic runs the other way: a block spends about 800 million multiply-adds per token in its binary matrices, attention over 2,048 tokens about 34 million, and either mixer about 6 million. By that count both candidates would cost about the same per step as the live block, and the two differ from each other by well under 1%. The count leaves out optimizer work, the projection tables and memory traffic, so it cannot settle speed. Nobody has timed either mixer inside the real trainer.
For a gain component each candidate scores 100 x max(gain, 0) / max(gain of DLGM, gain of Fusion, floor). The better one gets 100 when its gain clears the noise floor, the other gets its share of that gain, and a candidate that does not beat the shared baseline gets 0. Where a component has sub-experiments they are scored separately and averaged. Index = weighted sum of the component scores (0 to 100).
The name on top is the higher index. A margin under 3 points is called level in words.
Formula file: index_spec_v1.json (sha256 fda0f7ad167e19c1…), frozen 2026-11-12T01:59:02Z. Everything on this page as data: index.json.