Every control.
One forward pass.

01 / The problem

Latency is error in control.

A helicopter in a collapsing cave has three controls: collective, cyclic and winch. The game advances every 250 ms whether or not the model has answered. An answer that arrives late acts on a state that no longer exists; an answer that has not arrived means the previous controls keep running.

Nagi answers a question by reading option-letter probabilities from one forward pass. With K controls, the plain way is K-call: one forward pass per control, one after the other. At three controls that is three passes per tick, and on an H100 they do not fit in 250 ms.

This is not a small effect. In our previous test the same K-call model reached a normalized score of R = 0.324 on the helicopter game when time was frozen (24 seeds) and 0.108 when it had to keep up with the clock (5 seeds). It survived 75.1 s on average frozen (24 seeds) and 22.9 s in real time (5 seeds). So we rank models only in real time: the world never pauses, and latency is never subtracted or normalized away. A benchmark that freezes time measures a product nobody can run.

02 / How Burst works

K answer slots, one pass.

The readout

Burst renders one prompt: the state, then every control with its lettered options, then an answer block with one slot per control. Each slot is a marker [k] followed by a blank token □:

STATE:
<state>

CONTROLS (choose all at the same time):
[1] collective: A) <option>  B) <option>  C) <option>
[2] cyclic: A) …  B) …  C) …  D) …
[3] winch: A) …  B) …  C) …

ANSWER:
[1]□
[2]□
[3]□

One forward pass over this prompt. For slot k we take the hidden state h_k at the last token of [k] and project it only onto the letter tokens of that control's options, through the model's own output head:

pk = softmax( softcap(hk · Wletters(k)) / T ), answer = argmax. T = 1.0.

The token after each [k] is always the blank, never an answer, so no slot sees another slot's choice. The K distributions are read in parallel and are conditionally independent given the prompt. Training targets for each slot are the max-marginals of an exact joint oracle, so that per-slot argmax recovers the best joint action when it is unique. Ties are the known failure mode of this design, and they matter below.

What is shared, what changes

S = state tokens, q = tokens for one control's question and options. The state dominates the prompt, so K-call re-reads it K times while Burst reads it once.

Latency: every measurement we have

Rows 1–4: Burst's first test, 26 Sep 2026. Rows 5–7: Arena v3 Board 1, 27 Sep 2026, p50 over all requests of all rounds (player_summary.json). Row 8: the preregistered latency check of the release, 27 Sep 2026: a probe on each game's frozen filler prompts, p50 with a one-sided 97.5% moving-block bootstrap upper bound. Row 9: the release run itself, p50 over all requests of all rounds (seed indices 0–33, results.json). In play the p50 is higher than in the check on every game, and on Booster Gauntlet (290 ms) it is above the 250 ms tick. The Board 1 Burst player renders byte-identical prompts to release variant A. Brackets: 95% bootstrap intervals where the report computed one. Ratios without brackets are ratios of the p50s shown. With one control (K = 1) Burst has nothing to save and is slightly slower (longer prompt). Serving 3 streams per GPU instead of 1 multiplies latency by 2.27 for Burst and 2.80 for K-call.

03 / Evidence

Survive longer when the clock is real.

Arena v3 is a set of three fail-first games: difficulty rises every tick, on the same schedule for every player, until everyone fails (cap 60 s, six 10 s levels). The metric is simple: on the same seed, whoever fails later wins that head-to-head; a tie counts ½. We average over opponents, then over games. It is invariant to how the difficulty ramp is shaped.

Snake Rush

1 control (direction). Speed and walls ramp up. Burst has nothing to save here.

Rotorwash-Ramp

3 controls (collective, cyclic, winch). Helicopter in a collapsing cave.

Booster Gauntlet

4 controls. Consecutive rocket landings with rising wind and heavier engines. The least-seen game for Nagi.

Preregistered confirmation on fresh seeds

Every gate below, its threshold, and the rule that picks the readout variant were frozen before any Burst data existed (preregistration, frozen commit f0d6204 plus a pre-data amendment 0c346f5). The variant is chosen mechanically from the offline receipts and committed before any real-time result is opened, so game outcomes cannot influence it. Real time: Burst and Jev on seed indices 10–33 of each game, which no player had seen (n = 24 per game). Indices 0–9 are the Board 1 screen below and count only as a screen.

Offline gates use one-sided 97.5% bounds (Bonferroni over the two variants). The release rule needs the selected variant's offline gates, V_rt and R-RT; G1-B belongs to variant B only. B also failed its latency gate (p50 774 / 1,039 ms on Rotorwash-Ramp / Booster); A passed every gate, and the frozen rule selected it. The real-time tests are a fixed sequence at one-sided α = 0.025. A “head-to-head” is one seed index of one game: whoever fails later wins, a tie counts ½. The preregistration's own power analysis: the per-game tests are underpowered unless the effect is large, and Booster's 22 s wall compresses its rates.

n = 24 seed indices per game, 0 void rounds. Mean survival ≤ 60 s is the restricted mean survival time (RMST) with a 95% t interval, an estimate without a hypothesis test. Only Booster Gauntlet is individually significant; Snake Rush and Rotorwash-Ramp are not, and on Snake Rush Burst's point estimate is below Jev's. The Booster p-value is the Monte Carlo floor (100,000 sign flips).

% of rounds still alive vs time

Each line is the share of a player's rounds still running at time t (Kaplan-Meier; no round reached the 60 s cap in either dataset, so nothing is censored). Higher and further right is better.

Preregistered confirmation: realtime, fresh seed indices 10–33 per game (n = 24), Nagi-ENORMOUS Burst (variant A) vs Jev 1.13.0, 0 void rounds. Per-round times: data.json.

Board 1 screen: all players, same seeds

Win rate against the other five players on the same seed index; ties count ½. CI: 95% bootstrap over seed indices. RR = Rotorwash-Ramp, BG = Booster Gauntlet. Latency: p50 over all requests (Board 1 player_summary.json). 0 void rounds, 0 stale replies for every player except Nagi-ENORMOUS (released) on Booster Gauntlet (11 stale, 8 expiry resets). A screen: 10 seeds per game, and Burst was picked as the best of four Nagi entries after the fact, so its numbers are optimistic (see limitations).

Same weights: the gain is speed, not judgment

Because Burst and K-call share weights, comparing them isolates the readout. Burst's first test gives a consistent picture: with time frozen, the two make decisions of the same quality, and K-call even gets three passes per move to Burst's one. Once the clock is real, the direction reverses, because Burst's answers arrive in time. That reversal rests on a 5-seed exploratory run and the 10-seed screen; there is no preregistered real-time test of Burst against K-call.

Frozen time: every player gets unlimited time per tick (lockstep). In frozen time every Burst Rotorwash round ended on the cave ceiling (24/24), a flying failure K-call did not show. Real-time Rotorwash with 5 seeds is exploratory, not a decision. "+0.000" on 780 states means Burst was not shown to be worse, but the interval is wider than the preregistered 0.02 margin, so non-inferiority was formally not established.

Versus Jev, the faster player

Jev (version 1.13.0, a commercial API) answers all controls in one request, like Burst, and was the fastest player on the two multi-control games: p50 212 and 214 ms including the network, fresh on 88–90% of ticks against Burst's 66%. In the Board 1 screen Burst still survived longer in 70% (Snake Rush), 90% (Rotorwash-Ramp) and 100% (Booster Gauntlet) of head-to-heads. Against a faster opponent, a lead cannot come from speed; it has to come from the decisions, including Nagi's training on similar tasks (below). The screen picked Burst after the fact, so the preregistered test on 24 fresh seeds is the result that counts: 67.4% ([57.7%, 77.0%]). It passed the superiority test, but the lead is uneven: 97.9% on Booster Gauntlet, 58.3% on Rotorwash-Ramp and 45.8% on Snake Rush, and only Booster is individually significant.

Caveats: Jev runs on unknown vendor hardware over the network from a recorded client region; its latency includes the network and is not subtracted. In the release run the first Jev job stopped at its per-job cost guard before Rotorwash-Ramp indices 25–33; a second job played them, and Jev's measured p50 there was 297 ms against 172 ms in the first job (3 streams, latency probe). Jev's answers are not deterministic on repeated identical requests; its version string (jev-1.13.0) matched Board 1 in every job. Nagi was trained on similar control tasks (hover, crane, closed-loop snake); Jev's training is unknown. This is a specialist against a general model, on the specialist's kind of task.

Watch the rounds

One clip per game, rendered from verified replays of recorded rounds (every recorded decision is replayed and checked before drawing). Each clip shows Nagi-ENORMOUS Burst's round from the release run next to Jev's and SemIf-4B's Board 1 rounds on the same seed, so all three face the same seed and difficulty schedule. The seed is chosen by a fixed rule, never by hand: the index of Burst's lower-median survival time, or, if not every shown player has a round there, the next index in order of Burst's survival time, shortest first. SemIf-4B played only indices 0–9, so on Snake Rush and Rotorwash-Ramp the rule lands on Burst's shortest round among those (4.5 s and 12.9 s). On Booster Gauntlet every Burst round ends at the 22 s wall and the rule takes index 0. These clips show Burst's weaker rounds, not its best.

Seed indices 0–9 are the Board 1 screen, so the clips illustrate rounds; they are not part of the fresh-seed test. The on-screen label “ENORMOUS Burst” is Nagi-ENORMOUS Burst.

What this benchmark measures, and what it does not

04 / Limitations and what failed

The parts that did not work.

• Failed a preregistered gateBurst was prototyped as “Chord”. That first prototype failed its preregistered order gate: rotating the order in which the controls are listed changed the joint answer on 26.0% of 500 states [18.4%, 34.3%], against a 10% limit. The verdict was REJECT, and it stays REJECT; it is never passed retroactively. Board 1's Burst player used that same readout.
• The fix, tested as a new candidateTwo variants, with gates frozen before any data. A: the SDK always renders the controls in the environment's declared order, so the served answer cannot depend on the order a client lists them in. This is a software guarantee, not a property of the model: presented in another order, the model still changes its answer on 24.8% of states, and clients that bypass the SDK must use the canonical order. B: render the state under the K rotations of the control order, score the K prompts in one batched forward pass, and average each control's log-probabilities, so every control sits in every slot once. B costs K× the tokens of A and was predicted to miss the latency limit. It did (p50 774 / 1,039 ms on Rotorwash-Ramp / Booster), and its order residual missed too (9.0%, upper bound 13.2% against 10%). Selected by the frozen rule: A (canonical order). Every gate of variant A passed.
• Ceiling crashes in real timeOn the 24 fresh-seed Rotorwash-Ramp rounds, 12 ended on the cave ceiling (collapse 9, terrain 3). The preregistration requires disclosing this at 50% or more. The offline climb-bias gate (G3) passed, but it detects only gross bias.
• No coordination gainWe hoped reading all controls together would improve coordination between them. It did not: the preregistered “clear win” test on coordination states failed (MA2 −0.016 [−0.113, +0.072], MA2b +0.010 [−0.078, +0.088]).
• Worse flying with time frozenIn frozen-time Rotorwash, Burst hit the cave ceiling in 24 of 24 rounds and survived 43.1 s less than K-call [−53.0, −32.0]. The real-time advantage exists in spite of this.
• Screen-level evidenceBoard 1 is a screen: 10 seeds per game. Burst was picked as the best of four Nagi entries after the results, which inflates its numbers (winner's curse), and two of the four share weights. That is why the release test runs on fresh seeds under a preregistration. It compares Burst with Jev only; Burst versus one pass per control in real time has only this screen and a 5-seed exploratory run. The preregistration bounds the selection optimism at about 0.076 in win-rate units at n = 10.
• A player we could not rankCLM-8B was entered but failed its own conformance gate (rule D15), so it is not ranked. Board 1 therefore has 6 players, and Burst was selected against 2 external models (Jev, SemIf-4B), not 3.
• In-domain trainingBurst's weights, K-call's and ENORMOUS-CL's were trained on similar machine tasks (hover, crane, closed-loop snake). This was intended and is flagged on every row. No game engine, seed or state from the Arena appears in training (audited). External players' training is unknown.
• A timing wall in Booster GauntletEach landing must happen within 22 s, and many of the strongest rounds end at exactly 22.0 s. Those head-to-heads are ties, so Booster separates strong from weak players more than it separates the strong ones.
• Trained on three controlsEvery Burst training row had K = 3 slots (with the control order shuffled per row). Booster Gauntlet's K = 4 is outside the trained range, and K ≥ 5 was never evaluated. Two genres were held out of training; on them every readout is weak (joint decisions acceptable: 0.17 Burst vs 0.18 K-call, 120 instances).
• One control, no gainWith K = 1 (Snake Rush) Burst does one pass either way and is slightly slower (231 vs 213 ms p50) because its prompt is longer. On Snake Rush every model sits near the floor: Burst's median survival (10 s) is below that of the naive reference bot (13.75 s).
• The baseline is sequentialK-call here is the SDK default: K forward passes one after another. We did not measure a K-call that batches its K prompts or caches the shared state prefix. Such a baseline would close part of the latency gap, at the cost of more tokens.
• Uneven lead over JevThe superiority result is carried by Booster Gauntlet (97.9% of head-to-heads). On Rotorwash-Ramp (58.3%) and Snake Rush (45.8%) the difference from Jev is not significant, and Booster’s 22 s wall means Burst “wins” there by reaching the wall while Jev fails earlier. An audit after the gates passed found that Burst never landed a hop: all 34 of its Booster rounds ended at the hop timeout with the booster still climbing, so its Booster lead comes from not crashing, not from landing. Under a stall-proof scoring (not preregistered) Booster is a tie, and on the other two games Burst is non-inferior to Jev, not better (52.1% [37.8%, 66.3%]). Jev’s measured latency also differed between its two release jobs (p50 172 vs 297 ms); without the second job’s 9 rounds the win rate is 65.7% [54.3%, 77.1%], still above 50% (a sensitivity check, not preregistered).
• Hardware and servingAll self-hosted numbers: H100 80 GB, bf16 weights with the adapter merged, fused kernels, 3 streams per GPU. Other GPUs, quantization or batch sizes will give other numbers. Nothing here is a service-level guarantee.
• Training historyA preregistered pause fired at step 125 of 417 (language benchmark −2.07 points) and was overridden by the project owner; the run continued. At the final step the language score is −0.5 points vs the released ENORMOUS (0.8578 vs 0.8631, n = 200); Arena retention against it was inconclusive, and the public benchmark suite was not re-run.
• ProbabilitiesTemperature 1.0 is not learned calibration; probabilities can be overconfident on new domains. Held-out genres in the offline test rest on 2 families only.
• Who ran thisNagi's developers designed, ran and analysed every test on this page. Everything needed to check it is linked below.

05 / Reproduce

Check it yourself.

python -m pip install "nagi-decisions @ git+https://github.com/nagisanzenin/nagi.git@v0.6.0"

from nagi import load_enormous_burst   # 80 GB GPU, BF16, adapter merged in place
nagi = load_enormous_burst()
state = "tick 3: water 0.4 m\n\nCONTROLS (set together each tick): gate = closed | open; pump = down | idle | up."
questions = {"pump": {"type": "choice", "instructions": "Choose the pump setting.", "criteria": {"down": "pump water out", "idle": "leave pump idle", "up": "pump water in"}},
             "gate": {"type": "choice", "instructions": "Choose the gate setting.", "criteria": {"closed": "gate stays closed", "open": "gate is open"}}}
out = nagi.system_one(state, questions, mode="burst")   # one forward pass for every control
print({qid: a["choice"] for qid, a in out["answers"].items()}, out["burst"])

Needs an 80 GB GPU in bf16 (the base alone is about 56 GB). The answer dictionary has the same shape as the default K-call mode; out["burst"] reports the slot order used (here taken from the CONTROLS line, not the dict order) and the number of forward passes.

Names used on this page

Burst

The one-pass K-slot readout. Research name “Chord” until 27 Sep 2026.

Nagi-ENORMOUS Burst

The release: the step-417 weights served with Burst in the environment's declared control order (variant A). Labelled “ENORMOUS Burst” in the clips.

K-call

One forward pass per control, the SDK default.

Same weights

Qwen3.8-27B + rank-8 LoRA at step 417 (research name “T-dual”), trained on both formats. Burst and K-call on this page both use it.

ENORMOUS (released)

The released Nagi-ENORMOUS adapter (step 500), which Burst's weights continue from; one pass per control.

ENORMOUS-CL

An unreleased closed-loop fine-tune of ENORMOUS, K-call readout.

Jev

Jev 1.13.0, commercial API, one request with all controls.

SemIf-4B

The OpenJev / SemIf 4B reference, self-hosted on its native stack.

Prior art

Parallel decoding of action dimensions in one pass: OpenVLA-OFT (Kim, Finn, Liang 2025, arXiv:2502.19645). Shared trunk with independent per-dimension heads: action branching (Tavakoli et al. 2018, arXiv:1711.08946), OpenAI Five (2019). Letter-symbol multiple-choice readout: Robinson et al. (ICLR 2023, arXiv:2210.12353). Independent parallel predictions and the multimodality problem: Gu et al. (ICLR 2018, arXiv:1711.02281). Burst combines a letter readout through the existing LM head at K slots with max-marginal slot targets; we did not find this exact combination, but each piece is standard.