Write the rules.
Get the decision.

01 / How it works

Exact search first. A small prior for ties.

Every decision goes through the same path. The parts drawn in yellow are exact: they work on the rules you wrote, not on a learned approximation of them, and give the same answer for the same rules, state, session and step. The search is bounded, though: at most 100,000 simulations and depth 40 per decision, so on larger machines it sees only part of the future (on the sealed set it exhausted the tree on 24.9% of decisions). Only the core is learned, and it is only asked when the search finds several moves equally good.

1. Reader. Parses mz-1 text (integer variables, controls with DEC / KEEP / INC options, ordered rules, an optional random input, crash conditions, a goal) into the exact machine. mz-1x adds reply delay, hidden variables and a history window. Invalid programs are rejected, never guessed.
2. Lookahead. Simulates the parsed machine itself: 100,000 simulations per decision, horizon up to 40, with belief tracking when variables are hidden or controls are delayed.
3. Learned core. Reads the program structure and proposes a prior. It is used only inside the set of moves the search cannot tell apart, and only when its confidence is at least 0.6.

The learned core

On the three Arena games the released policies differ: on Snake Rush the SDK Snake search pack plays (20,000 simulations, horizon 12, no learned core); on Rotorwash-Ramp and Booster Gauntlet the core's game head plays without lookahead.

02 / See it play

Watch the sealed rounds.

One full round per game, at real speed, from the recorded controls: Nagi Burst V2, Nagi Burst V1 and Jev on the same sealed seed. The seed is fixed by a rule, not picked.

Each clip replays one sealed round from the recorded controls, three players on the same seed: Nagi Burst V2, Nagi Burst V1 and, for reference only, Jev (descriptive; the release gates compare with V1 only). The seed is fixed by a rule, not picked: the round at the median of V2's per-seed margin over Jev, so each clip shows a typical round, not V2's best. Rotorwash-Ramp's median seed #38 could not be replayed exactly for V1 on the render host, so the rule's fallback (the next seed by distance to the median) gave #44. Raw full rounds at real speed: no cuts, no slow motion; the last frame holds for about a second on the per-seat scores. Every on-screen score equals its record; render receipt arena_v2_videos.json.

Every seed, every score: the Game Arena →

03 / Benchmarks

One sealed run. Every gate receipted.

The candidate (core, search configuration, policies) was frozen before any sealed data was touched. Each step ran exactly once: the prose reader test R, the sealed policy runs, latency and interface, the analysis, and a recount by a separate agent that recomputed every number from the raw receipts with its own code (in-house, not third-party). R decides which path ships: it failed, so V2 ships the exact parser path.

Decision: RELEASE on the parser path. In-house recount of every number by a separate agent: MATCH.

Arena: V2 against Nagi Burst V1

The comparator is our previous release, Nagi Burst V1 (Nagi-ENORMOUS-Burst, a 27B model), through its pinned live evaluation records on the same seeds. This is release gate A, the claim. All three games were in V2's training data.

Seeds: Snake 10–33, Rotorwash-Ramp and Booster 34–57; 250 ms ticks; reply profile: nominal 1-tick (decision for boundary t applies at t+1). Booster: 23/24 landed (rule: at least 6); V1 landed none, and a Booster round is its first hop. V2's own rounds replay exactly from their recorded controls: 72/72. With no losses the t bound of the gate is degenerate (it equals W), so the exact Clopper–Pearson column shows the real uncertainty. Gate A tests improvement over V1, our previous release, and nothing else; V1 never landed a Booster hop, so that game says little about absolute skill.

Arena with Jev, for reference

Jev (jev-1.13.0, an outside vendor model served by API) played the same seeds; its single-stream records were pinned before V2 played. The preregistration made every Jev comparison descriptive, so these rows show counts only, with no test and no claim. Timing differs: V2 was replayed offline with one-tick replies, while the V1 and Jev numbers are live records, where a slow reply lands later.

Unseen machines: Zoo-Unseen-D

The test machines were written by Claude Opus agents in a separate author process from the training authors, checked by blind review and an exact oracle, kept hash-only until the single sealed run, and opened once. Each family groups related machines; families are grouped into domains. A machine's success is the share of its 16 episodes (each capped at 100 ticks) that reach the goal; θ̂ is the mean over families. Two research claims were preregistered next to the gates and tested together with a Holm correction: NS asks whether mean success is above the threshold; G+ asks whether the learned core adds anything to the same lookahead at the same latency cap.

Reference: every Zoo-Unseen-D machine was admitted only if an exact oracle succeeds at least 0.95 of the time (48 families / 16 domains). V2 θ̂ 0.854; the same search with no core 0.857. The gap is the planner's: mostly the Rotorwash-like stratum (0.484) and 3 domains below 0.60, which hold 88.4% of the failed episodes.

How much of each machine the lookahead saw

Only the low-coverage subset says something about machines the search cannot cover, and there NS is not shown. Its lower bounds sit below the NS threshold, so the full-set number is not north-star attainment.

Descriptive checks

• Leak check · descriptiveZoo-Unseen-D minus the development set Zoo-Dev-L: −0.031 (lower bound −0.156) → no flag, so gate G stands.
• Zoo-Unseen-C · descriptiveA second unseen set (16 families / 4 domains): θ̂ 0.893; Δ̂+ +0.012 (lower bound −0.013). Learning is not shown there either.
• Prose path · descriptiveWith the frozen prose reader in front, G would be 0.469: −0.385 per family against the exact parser (lower bound −0.517). That is why the reader moves to V2.1.

Latency

Measured single-threaded on the serving class cpu-m2-1t. The gate bounds the p95 from above; the p99 is reported, not gated. Booster Gauntlet rounds are short, so it has fewer requests than the target sample and every one was used.

04 / What we learned

With the rules given, search does the work.

On unseen machines, V2G's success comes mainly from exact lookahead on the given rules, which on small machines covers much or all of the reachable state set.

Why the learned core could not help

The learned core added nothing measurable on unseen machines: Δ̂+ = −0.003, so claim G+ is not shown. By construction that was close to certain. The core may only reorder moves that the exact search already rates as tied for best. When the tied moves are all truly optimal, the run with the core and the run with search alone both play optimally and cannot differ; the core matters only where a tie hides a worse move.

And the test machines are small for the search: the median machine has 922.5 reachable states and the largest 25,921, against 100,000 simulations per decision. The search exhausted its tree on 24.9% of decisions, and 48.3% were high-coverage. The same search with no core (and a slightly larger budget) scores 0.857. So this null answers a narrow question (does a tie-breaking prior help a near-exhaustive search on small machines?), not whether learning can generalize. That needs machines the search cannot cover: E2 below.

The prose reader failed, in line with the literature

Our small (0.8B-parameter) prose reader turned 23 of 48 sealed rulebooks into exactly the right machine (gate R FAIL). With it in front, success on unseen machines would be 0.469 instead of 0.854, so V2 ships the exact parser. That is in line with published results: strict semantic checks are much harsher than "it parses". Planetarium (NAACL 2025) reports GPT-4o at 96.1% parseable and 94.4% solvable, but only 24.8% semantically correct, and small open models are known to be weak formalizers without inference-time scaffolding. Our transition-exact check is a strict test of the same kind.

The planner leaves success on the table

Every Zoo-Unseen-D machine was admitted only if an exact oracle, a policy solved offline from the rules with no privileged view of hidden state, succeeds at least 0.95 of the time. That floor was fixed in the family gate on 2026-10-12, before the test set was assembled under it (2026-10-13; the preregistration had defined the test populations the day before). V2 scores 0.854 and the same search with no core 0.857: at least 0.096 below the oracle's mean on the same machines (V2's score is an estimate, the oracle's is exact).

The shortfall is concentrated. The Rotorwash-like stratum scores 0.484. Of the 16 domains, 3 score below 0.60 (cargo airdrop 0.146 · avalanche control 0.333 · rail hump yard 0.458), all of them Rotorwash-like, and they hold 88.4% of the failed test episodes. The open explanations: V2 cannot plan to gather information (it averages its lookahead over the possible hidden states), its lookahead is too shallow, or its leaf values are too crude. E1 is designed to tell them apart.

Where it sits

V2 is a model-based planner: it is told the rules and searches them. That family is well studied, and in it generalization to unseen tasks comes from search on a given model, which is what C8 found for V2. Our own review says it plainly: every part that produces V2's unseen-task success is textbook material, and what is worth showing is the evaluation method.

• Planning languages and planners. RDDL already expresses everything mz-1x can. PROST, the UCT-based planner for RDDL (source), ships with pyRDDLGym, the official evaluation system of the planning competition (IPPC). Fast Downward is a domain-independent planner for classical PDDL. These planners are domain-independent by construction, so they apply to unseen machine kinds with no learning at all.
• Hidden state. POMCP and DESPOT are the standard online POMDP solvers, and both can plan to gather information. V2 averages its lookahead over the possible hidden states (QMDP-style), which cannot.
• General game playing. GGP players get the full rules as a logic program and play games they have never seen, through search. GVGAI agents play hidden test games with a forward model and 40 ms per tick.
• Learned planning. ASNets, STRIPS-HGN, GOOSE and SymNet learn from the formal description and report gains where search alone is too expensive, mostly on larger instances. V2's core is the same idea, tested where search is cheap.
• Closest prior work. Code World Models for General Game Playing (ICLR 2026): an LLM writes the game model once, from the rules text and example trajectories, then tree search plays. V2 has the same split (rules, then an exact model, then search), with an exact parser for a small language in place of the LLM. The external-LLM reader planned for V2.1 would put V2 in the same pattern.

What is narrowly ours: the learned prior can only reorder the planner's exact ties, so it can never pick a move the planner proves worse (safe by construction, and the reason it could not help here); the C8 rule that every unseen-task number carries how much of the state space the search saw; and the protocol below. The full review lists 57 references; on this page, works the review could not re-check are named without venue or year.

What comes next

• E1 · Where the planner stands. Run standard planners on the already-opened test set at the same per-decision CPU budget: the exact oracle as the ceiling, POMCP (and DESPOT if feasible), PROST, a GVGAI-style tree search, and V2 itself, with every setting fixed on development machines first. Prediction: POMCP beats V2 on machines with hidden variables, because V2 cannot plan to gather information. If it does not, the gap is depth or leaf value. Numbers on the opened set are diagnostic only. The design was written down on 2026-10-14 (research commit 5a5b3fec) and will be frozen by hash before any run.
• E2 · Learned guidance on large machines. Fresh sealed machines with at least 10⁶ reachable states, far beyond the search budget, and a low-coverage share of at least 80% under the C8 rule. The core guides the search with priors and leaf values instead of breaking ties. The test is the preregistered G+ test again: refuted if core-guided search does not beat the same search alone at equal latency. A positive result would be the claim V2 could not make: a learned prior that transfers to unseen rules and improves search.
• E3 · Unseen Game Arena: agent alone vs agent + Nagi. The same coding agent plays unseen games, with and without Nagi as its decision tool, against a Jev decision baseline and an exact-oracle ceiling. Prediction: the agent with Nagi succeeds more often; refuted if it does no better than the agent alone. Planned: the preregistration is in progress; no results.

The Zoo-Unseen benchmark itself will be released with the Nagi Machine Zoo data (coming), so others can run these comparisons too.

No result is claimed for any of these. Each gets a preregistration with its refutation rule before it runs.

05 / Method

Why you can check the numbers.

The release followed one fixed order, and every step left a dated, hashed receipt.

• Preregistered · 2026-10-12 18:42Gates, test populations, statistics and the wording of every claim were frozen in the preregistration (sha256 9691f1e6) before any result existed.
• Candidate frozen · 2026-10-13 22:07One model, one search configuration and the evaluation harness were pinned by hash in CANDIDATE.json.
• Sealed single look · 22:08, same dayThe unseen test machines and the Arena evaluation seeds were opened once, for that candidate. Every gate and claim number comes from this run.
• Recount (in-house) · ~23:40A separate agent that had seen no result re-implemented the statistics from the preregistration text and recounted every number from the raw receipts: MATCH.
• Published · 2026-10-13 23:57SDK v0.7.0 and model revision 803cdcbb, with the receipts below.

From the preregistration freeze to publication took about 29 hours (times UTC+7). Cloud GPU spend for all of V2-general: $25.16, billed as finalized provider bills over 4 closed ledgers, with $0.00 still reserved; the frozen evaluation itself cost $0.20.

Dated errata and deviations

Departures from the plan, each dated in the run book and checked by the in-house recount, which found that the errata change no number and that the deviation favours the comparator:

• Deviation, comparator budget. The search-only comparator's budget bracket was 2.9% wide instead of the preregistered 2%, because the host was never quiet enough for the last timing run. Its budget was set to the upper point, 109,375 simulations, which favours the comparator. No gate uses it.
• Erratum, latency harness. One harness file was fixed after the freeze to add the Arena game interface. Gate L (every population) and gate I on unseen machines ran the pinned file; only gate I on the Arena games used the fix, which also changes a Rotorwash/Booster timing route that no gate uses. The recount found the diff byte-identical to the dated erratum.
• Erratum, prose cell (descriptive). On the prose path only, a move the exact machine rejects counts as a failure, never as a void. The parser path that ships is unchanged.
• Process note, order of R. The prose-reader run (gate R) ran alongside the sealed policy runs instead of before them. It reads only the reader's outputs, so no policy result could enter it.
• Plumbing notes. Two earlier run-book notes (the episodes file, an explicit configuration): the recorded hashes match in every receipt.

Sources: AUDIT_M4.md (errata and process notes), CANDIDATE.json (dated deviation), timeline.json (commit times), budget_m4.json (closed ledgers), zoo_d_admission.json (the admission rule above) and RELATED_WORK.md.

Every number on this page is stamped from the files below by the page builder, which re-derives them and fails on any mismatch. data.json maps each number to its file, JSON key and sha256.

06 / Use it

Install. Describe. Decide.

Burst V2 ships in the Nagi SDK v0.7.0 as the module nagi.burst2. The core is one small numpy file. It downloads from Hugging Face at a revision pinned in the SDK and is checked against its sha256 before use.

# the SDK (module nagi.burst2), pinned to this release
python -m pip install "nagi-decisions @ git+https://github.com/nagisanzenin/nagi.git@v0.7.0"

Write the machine as text, then ask for a decision. The quickstart from the README:

from nagi.burst2 import load_core, operate

RULES = """machine mz-1
vars:
  x in [0, 6], start {3}, out of range: clamp
controls:
  @m: DEC -1, KEEP 0, INC 1
random $w: none
rules (in order, each tick):
  1. x := x + @m
crash if any holds:
  1. all(x <= -1)
goal: all(x == 6)
"""
core = load_core()   # nagisanzeninz/Nagi-Burst-V2, pinned revision, sha256-checked
out = operate(RULES, {"x": 3}, {"core": core, "session": "episode-1", "step": 0})
print(out["choice"], out["probabilities"])   # {'m': 'inc'} {'m': {'dec': 0.0, 'keep': 0.0, 'inc': 1.0}}

The output is {"choice", "joint", "probabilities", "joint_probabilities", "stats"}. The defaults are the released configuration; changing them gives a configuration that was not evaluated. Pass a session and an increasing step to make every draw replayable.

Example: a delivery robot

Your own game stays your own code; Nagi only needs its rules. A robot on a small grid must pick up a parcel and deliver it before its battery runs out, and standing on a charger adds battery. With these rules and session robot-1, Nagi delivers after 9 ticks.

machine mz-1
vars:
  x in [0, 4], start {0}, out of range: clamp
  y in [0, 4], start {0}, out of range: clamp
  battery in [0, 10], start {8}, out of range: clamp
  parcel in [0, 1], start {0}, out of range: clamp
controls:
  @dx: DEC -1, KEEP 0, INC 1
  @dy: DEC -1, KEEP 0, INC 1
random $w: none
rules (in order, each tick):
  1. x := x + @dx
  2. y := y + @dy
  3. battery := battery - abs(@dx) - abs(@dy)
  4. if all(x == 4, y == 0): parcel := 1
  5. if all(x == 2, y == 2): battery := battery + 4
crash if any holds:
  1. all(battery <= 0)
goal: all(parcel == 1, x == 0, y == 4)

• It found the charger stop. At tick 6 it waits on the charger (battery 4 → 8). No rule says "wait": the lookahead saw that every way home would otherwise crash.
• It plays for the goal, not for battery. At tick 0, 3 moves tie and the draw steps into the wall; leftover battery is not part of the goal.
• No way to win: it stops instead of crashing. Without the charger rule no goal is reachable (116 reachable states, none a goal). All 9 joint moves tie at the no-goal value −33.1, it drifts while moving is safe, and from tick 6 it stands still.

The full example: your game class, the loop, every tick, and how to read out["stats"] ↗

Open data: the Nagi Machine Zoo

The machines, their prose, the exact-oracle labels and the opened Zoo-Unseen-D benchmark are public. V2 scores 0.854 on Zoo-Unseen-D, where an exact oracle reaches at least 0.95 on every machine. Can you close the gap?

Know the edges

• CanDecide every tick for a small machine you can write in mz-1 or mz-1x: discrete controls, integer state, random inputs, reply delays and hidden variables, with a visible probability for every option.
• CanRun on one CPU thread with numpy only (on the measured Apple M2 it stays inside the latency gate), and replay every draw exactly when you pass a session and a step.
• CanTell you how much it saw: stats["exhausted"] and stats["visited"] report how much of the machine the lookahead covered for each decision.
• Cannot yetRead rules in plain English. Write the machine language; the prose reader comes in V2.1.
• CannotPlan for a rule you left out. The decision is only as good as the machine you wrote.
• Not shownLarge machines. Bigger machines run, but the lookahead sees less of them, and that regime was not tested: the sealed set had 0 families with machines larger than the search budget.
• Not measuredLatency on other hardware than the Apple M2 serving class above.

07 / FAQ

Straight answers.

@misc{nagi_burst_v2,
  author  = {{Nagi}},
  title   = {Nagi Burst V2: exact lookahead on rules you write},
  year    = {2026},
  version = {v0.7.0},
  url     = {https://github.com/nagisanzenin/nagi},
  note    = {Model: https://huggingface.co/nagisanzeninz/Nagi-Burst-V2, revision 803cdcbb384c81c0a7411aa65fe058b933a4545b}
}