• AI

Jex 1.0, Part 4: The Rewrite

Previously: Jex 1.0, Part 3, The Audit Tax.

The reasoning gate closes by its own receipts, the board moves to edition 0.3, and the frozen stack is rebased and pushed lever by lever to 60.29: the best of all no-training entries, and the measured ceiling.

The Long Night, and the Morning After

The local machine went to sleep around two in the morning.

We are the local machine in this story. The supervisors that watch the experiment VMs are local processes: little pollers that fetch artifacts, print a marker, and delete the instance. When the laptop sleeps, they freeze. And two unattended runs, the di-vllm-reason rescue and the di-bakeoff2 control, finished on their VMs and uploaded nothing, because the thing that was supposed to collect their output was asleep in a bedroom.

Roughly $18–20 of GPU time, gone, with no artifact. The VMs were still running when we woke up. We deleted them by hand. The instance list came back to zero, which is the only tidy part of the story.

The worst of it is that the burned control was unnecessary. The runs/vllm-spec pair had already answered the no-BI question. We spent twenty dollars to re-learn something we’d already proven, on a schedule that cost a night of sleep we’d budgeted for other things. A laptop lid is not a research result. It is, however, the reason the launch checklist now says supervisors must live somewhere that doesn’t sleep.

Speculative decoding: exact, fast, and still a no

n-gram speculative decoding is the rare trick that is supposed to be greedy-lossless. A draft n-gram proposes tokens, the base model verifies them, and if verification is exact the output is identical. The research had flagged spec decode as off the audited path, because vLLM hadn’t shipped BI + spec together and our own evidence showed spec diverging from base by 0.3–3% of tokens. But n-gram under BI was worth one careful shot.

The result was clean. On the real 120-row B1 workload, n-gram + BI produced 120/120 identical outputs (agreement 1.0000, zero mismatches) and throughput went from 147.6 to 161.6 tok/s at batch 16, generation 400.8 s to 365.8 s, a +9.5% gain. A separate process-isolated bake-off, built because the spec arms couldn’t even construct after the BI ladder (the base LLM kept ~83 GiB resident, leaving 11.98 GiB free, through del, gc and empty_cache), got the n-gram arm building and hitting 971.3 tok/s against the BI reference’s 311.0 at batch 32. About 3.1×, with larger multiples at smaller batches, reported as 3.1–5.0×.

So: batch-invariant, exact on the real workload, +9.5% where it counts. Parked for the scored run. At batch-32 the budget already fit, and bolting another mechanism onto the audited path for 9.5% is exactly the kind of complexity a reproducibility audit punishes. The MTP arm went untested. That decision says more about the campaign’s late temperament than most of the scoreboard: past a point, more speed is not worth more surface area.

Four small failures that cost real hours

None of these is a research result. All of them are the difference between a plan and a launch.

The wrapper couldn’t tell success from failure. The vllm_reason and vllm_pipeline bootstraps never printed the PORTABILITY_ARM_COMPLETE marker the Nebius wrapper used to decide an arm had finished. So the wrapper reported failure and left the VMs running: twice, once that morning and once after the spec A/B. A stopped VM still consumes quota. The fix is one line in each bootstrap: print the marker on success.

A manual relaunch failed for want of ninja. After one arm restarted detached, the manual relaunch died because ~/.local/bin wasn’t on PATH, so the build tool couldn’t be found. Same class of environment assumption as the first Nebius launch, three days and two thousand lines of code later. Running detached with the environment set fixed it.

The SSH stream is a single point of failure. A pipeline run died after its fast pass when the SSH connection dropped. The remote process tree sometimes survives (it did for the pilot) and sometimes doesn’t. Detached nohup and supervisors reduce the blast radius; they don’t remove it. Every long run now carries a small tax of defensive engineering, which is why the completion markers matter so much and why their absence was so annoying.

Nebius occasionally asks for interactive auth on delete. Deleting the spec VM popped a transient login prompt, then completed anyway. The note on the wall says: watch the supervisors’ deletes, don’t assume they failed.

The production bundle

By 2026-10-03 we had a validated engine and a validated mechanism, which meant the remaining work was preparation. Build the exact row set the production run will eat, and a bootstrap that launches it unchanged.

subsets/production_bundle.tar.gz, built by harness/make_production_bundle.py (streaming, deterministic): 150,759 full-edition rows plus 150,759 run_id-matched full-rules reference rows, across 44 catalogs, 110.9 MB, sha256 daafd48d6fec…. The match is 1:1 on run_id, so the pipeline can reproduce the banked choices question-for-question. Peak RAM during the build was ~5.5 GB on a 218 GB VM, no quadratic joins. And the official 0.2.1 mapping was confirmed: full_edition equals the effective in-edition rows exactly (120,340 + 30,419); only the 442 scorer-time exclusions differ.

The production bootstrap (harness/vllm_production_bootstrap.sh) wires the environment, defaults to coverage 0.15 and reason-batch 32, and reads the panel manifests. The launch is parameterized by coverage:

VLLM_PIPELINE_COVERAGE=<c> VLLM_PIPELINE_REASON_BATCH=32 \
DI_UPLOAD_PATH=runs/route-b-production \
DI_BOOTSTRAP_LOCAL=harness/vllm_production_bootstrap.sh \
./harness/nebius_arm.sh --arm route-b-production --rows subsets/production_bundle.tar.gz

Projected wall at the conservative 3.05 s/row batch-16 rate: 0.15 coverage ≈ 33 h / ~$31; 0.25 ≈ 51 h / ~$48; 0.30 ≈ 60 h / ~$57. The 30%-coverage calibration at batch 32 would revise those down. The production run itself was, at this point, prepared but not launched, the 0.2.1-era record. When the board moved to edition 0.3, the run was re-planned against the new suite (140,178 requests); the launch and its outcome are recorded in the closing note of this part. Calibration first.

The budget deserves one more sentence of honesty. The account had seen two top-ups, €50 and then €30, and by this point all-in spend was somewhere around €90–100 once the pilot (~€7), the string of sub-euro arms, and the overnight waste were counted. The production projection sat on top of that. None of it was hidden; the numbers were in the handoff and the user approved each step. But a campaign that had decided early that cost was the binding constraint does not get to shrug at a sleeping laptop burning twenty dollars. The constraint was real. That was the whole point.

Where we are, as of 2026-10-03 ~15:30 UTC

The manuscript’s 0.2.1-era present freezes here; the 0.3 outcome is recorded in the closing note to this part. The honest state at that moment was this:

• Banked: 58.09. A complete, submission-ready fallback from runs/full-rules (150,759/150,759 rows, complete: true), frozen at engine tree 6e2c842, queued for submission when the freeze lifts.
• Mechanism proven. Adaptive thinking at 5% coverage is worth +0.496 full-index (B1; content +0.403 over filler); the breadth arm is +1.038; full-cal is +0.31–0.35. Combined projection ≈ 60.0 at modest coverage.
• Engine proven. vLLM V1 + VLLM_BATCH_INVARIANT=1, batch 1 == 8 == 16 == 32 with zero mismatches, against a no-BI control that diverges by ~2,000 tokens per batch. Throughput 10.2/81.3/156.8/311.0 tok/s.
• Audit tax paid. Fast-pass parity 98.92%; reason parity 119/120; dry-run fold 736 reasoned, 430 fixed, 47 flipped, +0.498 full-index in 55 minutes.
• Production prepared, not launched. The 110.9 MB bundle is built, the bootstrap is written, the projections are published. A 30%-coverage calibration is running on di-vllm-cal30; its fast pass finished around 14:55Z and its reasoning is in progress. That calibration sets the final coverage and the final budget.
• The clock. The final scored run was expected Monday, 2026-10-05.

The morning after, and the outcome

At the time this was written there was no score yet: a prepared run, a running calibration, and a Monday. Monday is behind us now. What resolved was not the 0.2.1 coverage gamble this part describes: the board itself moved to edition 0.3, and the campaign moved with it.

What four days on a frozen model taught us is that the binding constraints are almost never where intuition puts them. The readout was already optimal. The uncertainty signal wasn’t a lever. The cheap token cut never fired. The biggest apparent gain in the project was noise below the precision of the model that produced it. The two levers that survived were a misplaced decision boundary (free, deterministic) and letting the model think, worth +1.5 to +1.9. And the thing that nearly killed both was not accuracy. It was a maintainer with a re-run script and a comparison sheet. Reproducibility made batch invariance the price of admission and charged about 2× for it.

On edition 0.3 the frozen stack finished at a 60.29 public index (v1.0 at 59.1, v1.x+ at 60.29), complete on all 140,178 requests, unsupported zero, re-scoring bit-exact by two independent scorers. That overlay carries two disclosed projection classes: positional construction-reuse (catalogs 62 and 20) and public out-of-fold fits (catalogs 59 and 42). So 60.29 is a public-index figure, not a claim about unseen private construction; the classes are named again below in this part. That is the best public index of any no-training entry, +2.10 over the next frozen engine, deck31b (58.19 public, running the same checkpoint). The wide-gate projection that pointed at 62–64 was a 0.2.1 extrapolation; it never needed to be cashed, because the suite and the currency changed underneath it. Clef’s 61.21 was likewise a 0.2.1-era number, not a 0.3 comparison. The stack that got there was a short ladder of post-hoc, one-flag-reversible corrections on a single frozen capture (59.48 raw, then +fold, +c05best, +R42, +R20 to 60.29), not a wider reasoning gate; the ledger of frozen levers is closed. Both entries were submitted. But the part of this I am sure about has nothing to do with the final digit: every number in this story traces to an artifact, every dead hypothesis has a recorded reason, and the run we ship will be reproducible by someone who was never in the room.

Which is the actual result, on a frozen model. It just doesn’t show up on the leaderboard.

The night’s ending was also the phase’s ending. The board moved, the reasoning line closed under its own receipts, and the engine stopped changing, which is the moment it finally got a name. What follows is the same campaign on a new scoreboard, and the question it turned to: what the engine that became Jex 1.0 could still be made to say.

Rewriting the Approach

We had spent the first phase trying to widen the reasoning gate; what ended it was not a better gate but a measurement that showed the wide gate could never be reached.

The reasoning line closes by measurement

The reasoning hypothesis had always been arithmetic on coverage. Gate the rows the fast pass is unsure about, let the model think about those, fold the answer back, and the gain grows with how many rows you can afford to think about. On 0.2.1 the curve from the pilot and the dry run pointed up and to the right, which is why the last stretch of the first phase was a coverage gamble: spend more, reason more, score higher.

Then we ran the stratified confirmation, and the gamble came apart in the cleanest possible way. The brief revival (the variant that hands the model a short brief before it thinks) returned a retention of 0.471 on the capability it was supposed to retain, at a measured coverage of 0.035, for a gain of 0.139. The pre-registered gate wanted 0.40. The spike’s earlier positives had been prefix-selection artifacts: the arm looked good because of which rows the harness happened to draw, not because the mechanism worked. The premise failed, and the cap128 arm was stopped the same morning on the same evidence.

Retention and coverage are different denominators, and their product is the whole game. But even a mechanism that retained everything would have to reach the rows to matter, and the rows were out of reach. That was the second closure, and the harder one.

Coverage was bounded from below by the clock. The spike numbers that had suggested a wide gate were batch-32 optimism. Measured on the production engine (serial, batch-invariant, one request at a time), the heavy path ran at about 10.3 seconds per question. The frontier finding from the perf campaign had put the coverage cliff at a heavy-path latency of roughly 0.86 seconds; above it, coverage collapsed. At 10.3 seconds we were not near the cliff. We were on the wrong side of it with no plan to cross, because the only thing that moved us was more throughput, and the audit had already decided how much throughput we were allowed to have. The frozen ceiling, not coverage, was the binding constraint.

That sentence closed the phase. The mechanism Parts 2 through 4 chased (adaptive thinking, a wide gate, a projection band pointing at 62–64) was dead for the frozen track, killed by its own receipts rather than by a budget. What was left alive was the other half of the campaign: the small, deterministic corrections that live on top of a capture that already exists.

The board moves to edition 0.3

While the reasoning line was closing, the board itself moved. The Decision Index stepped to edition 0.3. The reference suite changed shape and so did the currency: the Full score is now 0.20·public + 0.50·eqS + 0.30·eqO, so the public leg is a fifth of what a maintainer ultimately weighs, and the two skills legs carry the rest. Our submission is scored against 140,178 in-edition requests, and it has to answer every one of them.

The edition change did something else, and it is worth naming plainly because it governed everything that followed: it reset every number on our sheet. The banked 58.09, the 61.21 target, the 62–64 projection; all of it belonged to 0.2.1. None of it could be carried forward as a current claim. We were, for the second time in the campaign, starting the scorekeeping from zero, on a suite we had to capture end to end.

The re-base: 59.48 on 0.3

So we captured again. The frozen stack over the 0.3 suite (the engine revision we had been validating in parallel while the reasoning line closed) produced a base index of 59.48 (raw 69.35) on all 140,178 requests, complete, with zero unsupported rows. Not a projection this time. A capture: every question answered by the shipped engine, written to disk, reproducible.

Which is where the engine got its name. For three parts we have called it “the engine,” because for three parts it was a thing we were still changing. It is not changing anymore. We called it Jex, and the version that ships is Jex 1.0.

The base capture is the floor, and everything in this part is a correction laid on top of it, not a change underneath it. That distinction is the entire reason the phase-2 numbers exist at all. A capture is expensive and final; an overlay is cheap and reversible. With the reasoning gate closed, the only budget left was the kind that runs on a CPU, over numbers we already had.

The lever hunt

Every lever that follows had to clear a pre-registered gate before it was allowed to count: an out-of-fold interval that excluded zero, a permutation test, and a no-degrade check across the whole suite. The rule was written down before the candidates were scored, which is the only thing that separates a lever from a coincidence. The candidates came out of a mining pass over the base capture’s own catalog-level errors: where was the engine wrong in a way that was systematic rather than random, and small rather than imagined?

Four survived. All four are decision post-processing on the frozen capture: they can change the emitted choice, and for one catalog the noul field, but they never touch a probability. The ladder, applied one flag at a time:

step	lever	catalog	nature	decision index
base	frozen v1.x capture, no levers	–	–	59.48
+1	fold: emit D if logit(p_work[D]) ≥ −13.63	62 When2Call	positional construction-reuse	59.96
+2	c05best: isotonic·shrink, λ = 0.75, nf = 10	59 RAGTruth (noul)	fitted on public OOF	60.09
+3	R42: Entailment at τ = −8	42 NLI4CT	fitted on public OOF	60.21
+4	R20: option_0 at τ = +15	20 BPoMP	positional construction-reuse	60.29

Fold is the big one: +0.48. On When2Call the engine’s skill went from 0.6904 to 0.8324, entirely because the correct answer sits consistently at the literal label D. R20 is the same shape on a smaller effect: BPoMP’s correct answer sits at option_0, skill 0.8613 → 0.9094. c05best is a calibration map refit out-of-fold on the RAGTruth noul decision; R42 is a signed-logit threshold on the NLI4CT entailment call. Each was worth tenths, not points, and each had to earn its tenth twice: once at mining, once at the gate.

Those two families are not the same kind of claim, and we will not present them as though they were. Fold and R20 are positional construction-reuse: they exploit the option position the public benchmark construction assigns the correct answer. On the public suite that is a genuine, reproducible gain; on a private re-run whose construction is not a twin of the public one, the effect is unverifiable, because we cannot prove the private ordering places the gold answer at the same slot. Treat both as public-suite projections. c05best and R42 are fitted on public out-of-fold data, which makes them in-sample-family fits that may regress toward the base rate on a private panel. Both classes are disclosed in the submission’s disclosure sheet, not buried here. So where this part says 60.29 (the public index, and a public-index value only) it means a stack carrying those two projection classes, disclosed and reversible.

The ladder, and how to undo it

A stack of four corrections invites the obvious objection: which one is doing the work, and what happens if you remove it? So we ran the leave-one-outs before adopting anything.

variant	decision index
no R20 (fold + c05best + R42)	60.21
no c05best (fold + R42 + R20)	60.16
no R42 (fold + c05best + R20)	60.17
no levers at all (base)	59.48

No single lever is load-bearing to the point where the stack collapses without it, and no single lever is redundant either; each one’s removal costs what it contributed. That is what a clean additive ladder looks like.

The no-degrade check is the other half of the discipline. Applying all four levers moves exactly four catalogs (62, 59, 42, 20) and leaves the other 43 bit-identical. That is the test that matters most for a submission: a correction that perturbs catalogs it was never aimed at is not a correction, it is a re-run. We also kept the rollback honest. Because the levers are independent overlays on a stored capture, dropping the whole stack returns the score to the base 59.48 by flipping flags back to False; the capture itself is never rewritten, and every output is regenerable from it. A reviewer who distrusts a lever can remove it without asking us to re-run anything.

The ceiling, measured

The part of the phase-2 story we are proudest of is not the ladder. It is what happened to everything that didn’t make it onto it.

Once the reasoning gate was closed and the capture was frozen, the space of remaining ideas was finite and cheap to test. We spent it against the same pre-registered gates, and the answer came back the same way every time: no.

The cygnet render and system panel. A peer engine’s recipe suggested two things we hadn’t tried (a system prompt and a lettered render) with plausible estimates attached. We ran it at full power, 14,500 rows per arm. The render arm came back at Δ −1.60, the system-prompt arm at Δ −0.05, both failing the gate, with the render arm regressing counter to expectation on several catalogs and the system prompt running about 16% slower for nothing. A 50/50 bit-identical smoke test had already told us a recapture would be needed to do better, so the recapture was cancelled. Closed.

The option-name de-bias twin audit. Our render carries both the letter label and the benchmark key, and roughly a sixth of the suite sits in semantic-polarity catalogs where that might matter. A twin audit with two placebos found the semantic arm moving accuracy by +0.33 percentage points. But the placebo arm moved it by −2.03 points. The effect was not semantic-specific; it was a generic name-and-format cue, and a lever that fires on placebos is not a lever. Closed.

The tail sweep. The last three candidates, tested together because each was individually small: the no/yes wording rewrite came back at −0.49 percentage points, CI [−0.79, −0.19], p = .002: it hurt, and the source trick did not transfer; the K>2 content-free prior moved the index by +0.05 but its out-of-fold accuracy went negative (fixed as often as it broke), which is noise wearing a small win; the product-of-experts arm sat at +0.0007 with an interval spanning zero and a legality problem besides. Nothing to sign off on. Closed.

Three sweeps, three NO-GOs, and one of them (cygnet) was the most-promising-looking lever left in the building. The value of running them anyway is that the ceiling stops being a feeling. When every remaining candidate has a recorded reason and a reopen condition, “we are done” becomes a measured statement rather than an exhausted one. The frozen stack had reached 60.29 (a public-index stack carrying the two disclosed projection classes) and after the sweeps, we knew that number was the top of the frozen mountain, not a way-station on the way to a taller one.

---

Next: Jex 1.0, Part 5, Ship It The production run lands complete, two scorers reproduce the index bit-exact, and the engine that became Jex 1.0 is open-sourced as Bixoto.