t2ance/atlas-25-sequential-tool-runtime-upgrade

ATLAS report 25: the sequential tool runtime on verl V1

1. Question and links

Read this first. Every stage of the bring-up ran to its evidence; the report is complete for the correctness acceptance of issue 59 and for its performance stack (a second pass: the call parser fixed after an independent judgement, a boundary rollout at a 1024-token cap, one stacked performance ladder whose first tier, a48k, is now the campaign's default) and for its first research use: both 40-step trainings of report 24's question (the shaped training and the zero-potential baseline, in parallel on the four cards) are complete, with every trajectory, validation dump, checkpoint and export here and the reading in report 24's Experiments section. A reader who cannot fetch files from the Hub finds a reading copy of this whole data root, everything except the saved training steps under checkpoints/ and the two initial adapters' weight files (checkpoints/*_adapter_init/adapter_model.safetensors), in the private GitHub repository t2ance/atlas-experiments, directory 25-sequential-tool-runtime-upgrade/ (same layout, same file names, this page included, minus the per-token arrays of every trajectory record and the tensors.npz archives, section 3); the arrays are on the Hub only, no saved step is in either copy except the step-20 adapters the user shared (section 5), and every adapter_config.json, init_report.json and README.md beside a weight is on both. The six tables of tables/ are exposed through the Hub's dataset viewer as the configs named in this page's front matter.

Training from the base model, r25-base-2gpu (ended at step 29; the report is closed). The run trains report 15's base Qwen3.6-27B, without SFT and without the KL term, with the same LoRA actor and critic, the same joint GPQA and LiveCodeBench rows and the same 32 x 8 batch as the run from the SFT merge below; its launcher is training/training/base_2gpu.sh in report 25's folder (named train_base_nokl_2gpu.sh when the run started, commit 7ad5004), on the two-card instance atlas-2a100. GCP stopped the instance at its 48-hour Flex Start limit at 20:15:25 UTC on 2026-09-11, inside step 30: steps 1 to 29 closed and saved, step 30's 256 trajectories generated and never trained (artifacts/r25-base-2gpu/train/step_30/, no manifest); the report was closed the same day and the continuation from the step-29 adapters is report 28's; validations at step 10 (GPQA 154 of 198, LiveCodeBench 86 of 175) and step 20 (165 of 198, 94 of 175) against the step-0 reading of the base model (79.80 and 55.43 per cent); no protocol violation on any step. It is one W&B run, y9jzqbgc, in three segments (steps 1 to 10 from 03:24 UTC on 2026-09-10, an empty resume at 15:30, steps 11 onward from 16:01), so runs/r25-base-2gpu/y9jzqbgc/history.csv holds one row for each of steps 1 to 9 and 11 to 28 (27 rows; W&B marked the run crashed and never received step 29), and the rows of steps 10 and 29 are in outputs/r25-base-2gpu/main_ppo.segment-1-steps-1-10.log and outputs/r25-base-2gpu/main_ppo.log only. The exports of three earlier launches (s3398vx0, t0psu5r8, e2e7u9pc) sit beside it, and wandb/ holds the local W&B directories of every launch, including the five whose W&B runs no longer exist (a25u1fxd, notqsty9, s1849gkn, jeq83p8s, e2e7u9pc). Its checkpoints (global_step_10 to global_step_29, about 8.9 GB each) stay on the node's disk; here are global_step_20 and global_step_29 whole, the step-29 adapters of both roles exported from the shards (global_step_29/{actor,critic}/lora_adapter/), checkpoints/r25-base-2gpu/val_dumps/{10,20}.jsonl, every trajectory of every step (artifacts/r25-base-2gpu/), the whole run log with the two earlier segments' logs beside it (outputs/r25-base-2gpu/), and the logs of the seven launches before the eighth (outputs/r25-base-2gpu.<suffix>/, outputs/r25-base-2gpu-memory.<suffix>/; their trajectories stay on the node). The run it is read against, r25-sft-2gpu (the same training from report 26's SFT merge, 35 steps, validations every 5 steps to 30), has its trajectories, validations and export here as artifacts/r25-sft-2gpu/ and runs/r25-sft-2gpu/leg4olc4/.

New ordered-split SFT to RL: complete. Run ljc570gb completed three PPO steps from report 26's new three-epoch SFT result on two A100 80GB cards. All 24 trajectories submitted, across 50 generations, with no protocol violation. The final optimizer states record four actor updates and three critic updates. The fixed generation probe is unchanged after critic warmup and changes after both actor updates. Sampled device-memory peaks were 58.58 and 61.54 GiB (61 samples per GPU). Each step took 100.5 to 112.3 seconds excluding checkpoint writing; the two writes took 288.9 and 312.0 seconds. The longest sequence had 3035 prompt-plus-response tokens. This is a test of the complete LoRA RL path on short GPQA training trajectories. Longer runs, full-length RL batches and reserved-question accuracy remain untested.

The new SFT-to-RL test used the retained instance atlas-sft27-first80-3ep-0908 in us-central1-c. It is stopped, and its 800 GB boot disk is retained with the full saved states. The verified environment and new SFT base are saved in READY image atlas-envs-sft-rl27-a100-20260908, project caramel-theory-145119, family atlas-training-a100. Runtime credentials were removed before capture. The instance ran for 59 minutes 17 seconds, about 1.98 GPU-hours including preparation and transfers. Currency charges are not visible to this account. The launch source is d738666; the tested adapter exporter and report are in 116a513.

27B hardware check, 2026-09-08 (complete for the stated tests). The two A100-SXM4-80GB GPUs in GCP completed three RL steps: three critic optimizer steps and four actor optimizer steps. All 24 trajectories submitted with no protocol violation. The sampled device memory maxima were 60.83 and 60.62 GiB. The final step took 236.9 seconds excluding its 277.6-second checkpoint write. Run ptcro2d8 uses FSDP2, bf16, LoRA rank 64 / alpha 128, Liger, gradient checkpointing, padding removal, the Triton output head, and CPU storage for both models between phases. Optimizer states stay on the GPUs; per-layer CPU offload is disabled. The step-two adapter has 992 finite tensors and nonzero B parameters. Its SHA-256 matches after transfer home. The generation probe is unchanged after the critic-only step and changes after the actor update. Both saved adapters were checked, and their hashes match the remote copies. Separate actor and critic engines also completed a 24576-token forward, backward and update, one synthetic row per GPU, using native PPO losses. Their allocated peaks were 55.16 and 51.32 GiB per rank. Their update times were about 63.4 and 29.7 seconds. The real RL trajectories reached 7992 tokens; a full RL batch of 24576-token rows remains untested. There is no matched 27B speed control. The later trainable-only saving test below reduces checkpoint cost.

The old SFT trial kjpggd7u failed its token budget and mixed XML parameters with repeated JSON calls. The base-model trial l694bls1 lacked the remote GPQA cache. With that cache fixed, on27y3ao passed generation, grading and probability computation, then ran out of GPU memory in critic backward while the actor stayed on the GPU. These three trials completed no optimizer step. The passing trial adds actor phase offload. It measures runtime and memory on four fixed questions, not task accuracy. Exports are under runs/r25-probe-*/, runtime artifacts under artifacts/r25-probe-*/, and logs and fixed-input provenance under data/rl_memory_probe/. Initial trial configs keep their original report 26 paths. The base model is report 15's Qwen3.6-27B; the old SFT and initial adapters are report 26 inputs.

The GCP instance atlas-r25-probe-flex-0908-wait in us-central1-c is stopped. Its tested environment is saved as image atlas-envs-rl27-a100-20260908 in project caramel-theory-145119 (READY). Runtime credential files were removed before the image was created. The two saved actor adapters are under checkpoints/r25-probe-phase-offload/global_step_2/actor/lora_adapter/ and global_step_3/actor/lora_adapter/.

Does the replacement RL runtime (verl at upstream commit 23af6a7a2e8d6efeeb2adbe5d1689c7a24f503a3, V1 synchronous PPO with FSDP2; vLLM 0.26.0; XGrammar 0.2.3) execute exactly what the policy generates and reward exactly what was executed? The runtime constrains every generation to free text followed by exactly one call of a tool the episode's state allows (a structural tag compiled by XGrammar and enforced by vLLM), writes one typed execution record per episode as the tools run, scores the reward from that record alone, and places the per-action rewards on the recorded action tokens. Accuracy is not a criterion of the report.

• Report source: .claude/skills/atlas-experimenting/experiments/rl-training/25-sequential-tool-runtime-upgrade/main.tex in https://github.com/t2ance/ATLAS, branch main, original acceptance issue https://github.com/t2ance/ATLAS/issues/59 (the pull request is linked from the issue). The Methodology section pre-registers the readings S (the runtime holds), F (a boundary the runtime cannot hold) and B (the budget ends first).
• Launchers: the training/ directory next to main.tex (common.sh with the shared bindings and one launcher per stage). Runtime code: Experiment/core_code/training/rl/ on the branch (source commits 4681ae0 to d8abf72; the report names the commit of every fix).
• W&B, project pqin/atlas-grpo, all finished:
  • smoke rollout https://wandb.ai/pqin/atlas-grpo/runs/tz17hf2x
  • boundary rollout (1536-token response cap, a labelled intervention) https://wandb.ai/pqin/atlas-grpo/runs/cb78s3lf
  • training smoke https://wandb.ai/pqin/atlas-grpo/runs/dul8fxf0 and its resume https://wandb.ai/pqin/atlas-grpo/runs/bwqhn1vo
  • the resume check without shaping (r25-resume-sft8b-2gpu) https://wandb.ai/pqin/atlas-grpo/runs/y831fpi8 and its resume https://wandb.ai/pqin/atlas-grpo/runs/jt9mr5dw
  • the resume check with shaping (r25-resume-sft8b-shaped-2gpu) https://wandb.ai/pqin/atlas-grpo/runs/gfcihdyt and its resume https://wandb.ai/pqin/atlas-grpo/runs/j3zej2tx
  • dose step (batch 32 x 8) https://wandb.ai/pqin/atlas-grpo/runs/bdci5w4q
  • full validation (198 GPQA + 175 LiveCodeBench) https://wandb.ai/pqin/atlas-grpo/runs/vj3c8qim
  • the research rerun of report 24's question, both trainings 40 steps at 32 x 8 with validation before training and every 5 steps and checkpoints every 10: the shaped training (r25-sft8b-shaped-2gpu) https://wandb.ai/pqin/atlas-grpo/runs/9ter1d02 (cards 2 and 3, 05:56 to 11:59 UTC on 2026-09-06); the the resume check without shaping (r25-resume-sft8b-2gpu) https://wandb.ai/pqin/atlas-grpo/runs/zud7g3zw (cards 0 and 1 from 07:34 UTC; steps 0 to 14, dead at its step-15 validation when one LiveCodeBench grading exceeded the grader's child time bound, fixed in commit b9727b1) and its resume from global_step_10 https://wandb.ai/pqin/atlas-grpo/runs/c0jfud2t (steps 11 to 40, 09:58 to 15:52 UTC; identical overrides, resume_mode=auto). The unshaped training's canonical curve is zud7g3zw up to step 10 and c0jfud2t from step 11; the step-10 validation exists in both (the same weights, two samples).
  • attempts that did not reach their evidence, kept as records: training smoke attempts https://wandb.ai/pqin/atlas-grpo/runs/tuguao2p (crashed at step 1, a temporary file name), https://wandb.ai/pqin/atlas-grpo/runs/az5oqff9 (crashed at the first critic update, the reference pass's adapter flag leaking into the critic), https://wandb.ai/pqin/atlas-grpo/runs/lb62eidk (finished, superseded because its checkpoints carry no update counters); full validation https://wandb.ai/pqin/atlas-grpo/runs/2mhh4hg1 (aborted by design at 372 of 373 when one LiveCodeBench grading failed on filelock's fork audit).
• Status: complete. Reading S holds on every run: 717 trajectories, 2460 generations, each exactly one call, 0 protocol violations, every reward row on a recorded action token, the warmup probes unchanged and the resume probes equal, one 32 x 8 step in 618 s, 373 of 373 validation trajectories. Six boundaries were met and named (two upstream verl defects, one filelock defect under the LiveCodeBench grader, three of ours); each was fixed and the stage re-run. The research rerun (both trainings 40 steps, 28.7 GPU-hours) kept the invariants on all 80 steps and met one more boundary, the grader's child time bound (b9727b1, fixed and the training resumed). Its reading is report 24's: the shaped training's window-mean GPQA utility is 2.02 pp above the baseline's over steps 15 to 40, carried entirely by the baseline's step-40 validation, where 13 of 198 GPQA trajectories looped on whitespace to the cap inside an unclosed submit call with the answer already written; the credit question stays unresolved on a policy that closes its calls.

The checkpoint timing follow-up finished: https://wandb.ai/pqin/atlas-grpo/runs/k0kna2nk (r25-sft-check-adapter-save). All three steps and 24 trajectories completed, across 47 model generations, with no protocol violations. Both saved steps contain every trainable actor and critic tensor, including the value-head weight and bias. The final optimizer states show four actor updates and three critic updates on each rank. CPU checks and two-card FSDP2 checks passed on small models, including exact optimizer, scheduler and random-state restoration.

Step	Compute and other step work (s)	Save (s)	Total (s)
1, critic only	94.9	0.0	94.9
2, actor and critic	99.2	21.7	120.9
3, actor and critic	102.2	22.3	124.5

The model shards decreased from 110.03 GB to 3.15 GB per saved step; optimizer and RNG state remain. Mean saving time decreased from 300.46 to 21.98 seconds (92.68%). The three steps took 340.26 seconds. Startup took another 748.41 seconds; launch through exit took 1097.62 seconds. Mean GPU utilization over the three step intervals was 71.91% and 76.64% (22 samples per card); sampled memory peaks were 61.54 and 61.56 GiB. The baseline had 50 model generations and overlapping file transfers; the new run had 47 generations on another node of the same GPU type. The file-size reduction is exact; total times are not a matched-work throughput comparison.

Full-batch timing: complete. Run j6t7ucte, r25-sft-check-batch256-one-step, completed one step at 32 questions x 8 trajectories. All 256 trajectories submitted, across 551 generations, with no protocol violation. Each rank made two actor optimizer updates and one critic update. The saved tensors and exported adapter passed their checks. The step took 1461.64 seconds (24 minutes 21.64 seconds), including 21.99 seconds to save. Generation took 240.73 seconds; actor updates took 658.34 seconds and the critic update took 221.69 seconds. Startup added 457.74 seconds. The rollout server allowed 32 active sequences. Mean device utilization during the step was 91.32% and 93.59% (97 samples per card), with sampled memory peaks of 66.42 and 66.15 GiB. These timing probes do not measure evaluation speed or learning quality. Their launch sources and checks are in the matching outputs/ directories. The source change is a6282ce.

The two timing tests used atlas-rl27-save-2a100-0908 in us-central1-a, started from image atlas-envs-sft-rl27-a100-20260908. The instance is now stopped (TERMINATED); its 800 GB boot disk remains with autoDelete=false, including the complete saved training states. Runtime credentials were removed, and the three exported actor adapters and both runs' records were copied home and checked. The instance ran for 63.84 minutes, about 2.13 GPU-hours including preparation and transfers. The original us-central1-c instance also remains stopped. Report source: d58b3eb.

Memory scope. The full batch reached 5154 tokens in its longest trajectory, below the 24576-token cap. Earlier isolated actor and critic checks used one synthetic full-length row per card with the base 27B model. They did not test the complete runtime with several full-length gradient-accumulation microbatches or 32 concurrent full-length rollout sequences. The initial prompt is limited to 8192 tokens; generated tokens and tool observations share a further 16384-token allowance. An observation over that allowance is not appended, and the trajectory ends. Each training microbatch has a 24576-token budget per GPU. These bounds control length but do not prove the complete worst-case memory peak.

Four hours. From one full-batch measurement, startup and saving every ten steps plus a final save, the estimate is nine actor-and-critic steps before evaluation and final transfer. Keeping the old ten critic-only steps gives an estimated 14 outer steps but only four actor-enabled steps. The critic-only duration is inferred by subtracting actor-update time, not measured. That estimate leaves only about 327 seconds for evaluation and transfer. A 40-step plan with ten critic-only steps and four saves is about 14.32 hours plus nine unmeasured 27B evaluations. These are projections, not guaranteed budgets. Four checkpoint saves do not make 40 training steps into 44.

Reapplying the native splitter to the saved full-batch lengths gives 11 microbatches per GPU, each with 11 or 12 trajectories. The reconstructed partition token sums match the native logs. These are reconstructed counts, not runtime instrumentation. At 24576 tokens per trajectory, the same per-GPU budget permits one trajectory per microbatch, so one optimizer update would accumulate 128 microbatches per GPU. The actor repeats that update twice on the same 256 trajectories.

The new output records are validation.json (trajectory counts, protocol checks, weight probes and stack), compact_checkpoint_validation.json (trainable names, critic head keys, file sizes and finite-value checks by step/role/rank), checkpoint_validation.json (optimizer counts and exported adapter hashes), cpu_roundtrip.json and distributed_roundtrip_rank_*.json (restore checks), batch_math.json (question, trajectory and update units), and timing_analysis.json (native stage times and sampled GPU readings). Each count names its unit. The 40-step launcher now selects the new 27B SFT result and current prompt. Its global batch is 256 trajectories. RL now trains jointly on GPQA (158 questions) and LCB (140 questions), with HLE excluded. The native loader concatenates GPQA then LCB, retains their question order, and combines single-row fetches into 32-question batches across the 298-question boundary. A CPU run verified all 1280 ordered question inputs: four full passes plus the first 88 questions. They comprise 720 GPQA and 560 LCB occurrences, producing 5760 and 4480 trajectories. Restoring the saved dataloader position reproduced the boundary batch. See outputs/r25-sft-2gpu/joint_data_check.json. The older data_check.json describes the superseded GPQA-only plan. The maximum-length production-stack capacity check and the formal 40-step run are pending.

Current-prompt 40-step follow-up: formal run leg4olc4 started. The formal run will train only GPQA and LiveCodeBench, using the first 158 and 140 questions in dataset order. HLE is excluded. Each step uses 32 questions and eight responses per question. The 373-question full validation includes SFT training questions and does not measure reserved-question accuracy alone. The completed validation in attempt ttmksn2m took 521.71 seconds.

The split stress check uses eight synthetic 24576-token rows for two consecutive steps, then a separate 256-row data check and 32 distinct 24512-token contexts with 64 new tokens each. Run mbbwabv5 completed both training steps, both saves and both weight-version probes. Computation took 495.35 and 488.24 seconds; saving took 22.67 and 22.61 seconds; weight transfer and its probe took 16.65 and 16.59 seconds. The twelve worker records show four backward passes per update, gradients present after the first pass, and optimizer states present in the second step. Per-GPU backward-pass peaks were 59.39 GiB allocated and 63.34 GiB reserved.

The separate GPU data check passed in run smzox57n: 128 full-length rows and 128 single-row micro-batches on each rank, including GPU transfer, padding and concatenation, in 7.12 seconds. The resumed run loaded the second-step models and optimizers and exercised the repaired checkpoint save, including ATLAS counters, in 43.79 seconds. The older counters were recovered from the saved weight probes and both ranks' update records; their provenance is retained in outputs/r25-sft-2gpu-memory/attempts/resume-counters-init/recovered_counters.json.

The user canceled the remaining generation test and requested immediate formal training. The formal process r25-sft-2gpu started from report 26's original SFT result, with no synthetic updates. No completed 32-request generation result or long-run memory guarantee is claimed. The generation cache can hold about 9.87 full-length requests, so 32 submitted requests can queue. The run remains under report 25's data root; rl27 denotes the model's 27B size, not experiment 27. Experiment 27 is the separate cache and run-record report. The earlier 40-step time estimate used GPQA alone; joint-training timing remains to be measured. Read artifacts/r25-sft-2gpu-memory/memory_check.json, run.resume_2.json beside it, and outputs/r25-sft-2gpu/launch.json.

2. Directory tree

The new run uses artifacts/r25-sft-check-smoke/, outputs/r25-sft-check-smoke/, runs/r25-sft-check-smoke/ljc570gb/ and checkpoints/r25-sft-check-smoke/. Its initial adapters are checkpoints/r25-sft-check-{actor,critic}-init/. The data and merged SFT base are linked inputs from report 26.

README.md                      this page
FILES.txt                      every file of the repository with its byte size (the complete index)
report/                        report25.pdf and report25.tex, the report source at e34af74 of 2026-09-11 (20 pages,
                               the execution appendix through step 20 of the training from the base model);
                               report 24's copy is in its own data root
data/                          the rows every run read: grpo_gpqa_overall/{train,val}.parquet (396 and 198),
                               grpo_lcb_overall/{train,val}.parquet (350 and 175), smoke_val.parquet (12 rows,
                               six GPQA including report 24's two degenerate questions and six LiveCodeBench),
                               tool_config_{gpqa,lcb}.yaml (the tool surface each benchmark's rows name)
grammar/                       the six compiled structural tags (three states x two benchmarks) and
                               cases.json: 42 token-level cases on the SFT merge's tokenizer and
                               12 parser cases (the loop's reading of a decoded generation)
checkpoints/actor_adapter_init/, checkpoints/critic_adapter_init/
                               the initial LoRA adapters (fp32, rank 64, alpha 128) both runs load, with init_report.json
checkpoints/<run>/global_step_N/
                               verl's saved steps of the training runs (the adapter goes up, see section 5)
artifacts/<run>/run.json       the run manifest: package versions, the resolved config, the potential binding,
                               the grammar hashes, the protocol token ids (run.resume_N.json for a resumed run)
artifacts/<run>/weight_sync/   the sentinel probes: init, after_step_N, before_validation_N, resume_N
artifacts/<run>/train/step_N/  one JSON per training trajectory, manifest.json, tensors.npz (values, returns,
                               raw and whitened advantages, policy mask per row)
artifacts/<run>/val/step_N/    one JSON per validation trajectory and manifest.json
artifacts/<run>.<suffix>/      the attempts that did not reach their evidence (crashed-attempt-1, crashed-attempt-2,
                               attempt-3-precounters, attempt-1-grader-fork, perf-stack-a48k.crashed-attempt-1-fused),
                               same layout; the validation attempt killed at boot wrote nothing and is in
                               logs/gpu_budget.log only. The runs of the second pass: boundary-rollout-1024 (12
                               trajectories at a 1024-token cap), perf-stack-a48k (three steps at 32 x 8 with the
                               performance stack, the campaign's default since), frozen-potential-40 and
                               zero-potential-40 (the two 40-step trainings of report 24's question on this runtime:
                               train/step_1 to step_40 with the rows the run kept, every fourth training row by
                               uid digest (train_fraction 0.25) plus every row whose terminal reason is not
                               submitted, 24 to 115 files per step, and tensors.npz with all 256 rows' tensors;
                               val/step_0 to step_40 every 5 steps, 373 each; run.json and, for the unshaped training,
                               run.resume_10.json. The unshaped training's train/step_11 to step_15, val/step_10 and
                               val/step_15 hold both attempts' files: the first attempt's were written before
                               09:58 UTC on 2026-09-06 (written_at), the resumed run's after, and tensors.npz
                               there is the resumed run's; val/step_10 holds two validations of the same weights)
artifacts/r25-base-2gpu/   the training from the base model (live): train/step_1 to step_28 with all 256 rows of
                               every step (train_fraction 1), manifest.json and tensors.npz (Hub only); step_11 holds
                               464 rows, the 256 of the eighth launch (manifest.json, written_at >= 1789056540) and 208
                               of two stopped launches; val/step_10 and val/step_20, 373 each; run.json and
                               run.resume_10.json; weight_sync/ probes; val_figures/
artifacts/r25-sft-2gpu/
                               the training from the SFT merge it is read against: train/step_1 to step_35 (256 rows
                               each), val/step_0 to step_30 every 5 steps, run.json, weight_sync/
checkpoints/r25-base-2gpu/val_dumps/
                               10.jsonl and 20.jsonl: one row per validation trajectory with its scalar readings
outputs/r25-base-2gpu/     main_ppo.log (the live log at the snapshot: one 'step:N - key:value - ...' line per
                               closed step, the vLLM engine lines every 10 s during generation, the ATLAS wake trace
                               lines), main_ppo.segment-1-steps-1-10.log, main_ppo.segment-2-step-11-partial.log,
                               the exit codes of those two segments, .hydra/; outputs/r25-base-2gpu.<suffix>/
                               and outputs/r25-base-2gpu-memory.<suffix>/ hold the logs of the seven launches
                               before the eighth and of the memory checks
runs/r25-base-2gpu/        y9jzqbgc (the run, three segments), s3398vx0, t0psu5r8, e2e7u9pc (earlier launches)
logs/gpu_watch/                samples.csv (two NVML samples a minute per card: memory, power), verdict.json (the
                               occupancy gates over the last ten minutes), cron.err; the samples stop at 06:07 UTC on
                               2026-09-11, when an unattended driver upgrade broke NVML until the next boot
analysis/reward-replay/        issue 66's proof that the reward refactor changed no reward: replay_old.jsonl.gz and
                               replay_new.jsonl.gz (91,975 rows each, gzip), compare.json, corpus_manifest.json,
                               the GAE checks and the round-trip checks with their artifacts
runs/<run>/<wandb id>/         the W&B exports: config.json, history.csv, summary.json, system_metrics.csv, run.json
logs/                          one log per stage (both boots of a stage in one file), gpu_budget.log (the stage
                               stamps), the check outputs (*_check.txt), the checking programs (check_*.py;
                               check_train_run.py checks a 40-step training's artifacts, probes and checkpoints), the
                               consoles of the two 8B trainings r25-sft8b-shaped-2gpu.log, r25-sft8b-2gpu.log (the
                               resume) and r25-sft8b-2gpu.crashed-attempt-1-lcb-grader-timeout.log,
                               step_metrics_by_run.tsv, r25-validation-2gpu_metrics.txt, aggregate_check.txt,
                               critic_engine_probe.py and critic_engine_probe_disabled_adapter.log (the standalone
                               reproduction of the critic defect), wandb_exports.log
tables/                        step_metrics_by_run.csv (the per-step metrics of every training run, from the logs),
                               validation_views.csv (the two-view validation recomputed from the trajectory files),
                               perf_stack.csv (the dose-step control against the perf-stack-a48k steps: seconds per
                               stage, peak memory, MFU, the invariants), and the three tables of the research rerun:
                               validation_curve.csv (every validation of both trainings), step_metrics_by_training.csv
                               (every training step of both trainings, the W&B step line joined with counts from the
                               trajectory files), call_advantage.csv (the mean advantage on the tokens of each
                               executed call, steps 11 to 40)
outputs/<run>/<timestamp>/     hydra's run directories (the resolved overrides of every launch)
wandb/                         the local W&B run directories

3. How to read each kind of file

For the new run, start with outputs/r25-sft-check-smoke/validation.json (24 trajectories, question order, finite arrays and generation probes), checkpoint_validation.json (optimizer steps, rates and adapter hashes), and metrics_validation.json (timings and sampled memory). launch.json records the source and cloud instance. The saved actor adapters were exported with python -m training.scripts.lora export, using each saved step's actor/ directory and the run's initial adapter. The 992 FP32 tensors in each exported file match the full FSDP2 shards exactly. They load against report 26's new merged SFT base, with rank 64 and alpha 128. The new tensors.npz records use response_mask for sampled model tokens. The run finished and synchronized all three W&B history rows before an ignored BrokenPipeError in W&B's exit callback.

• Text, CSV, TSV, JSON and log files: https://huggingface.co/datasets/t2ance/atlas-25-sequential-tool-runtime-upgrade/raw/main/<path>, for example raw/main/artifacts/r25-validation-2gpu/val/step_0/manifest.json or raw/main/logs/r25-validation-2gpu_check.txt.
• Parquet: https://huggingface.co/datasets/t2ance/atlas-25-sequential-tool-runtime-upgrade/resolve/main/<path> (raw/ returns only the LFS pointer), for example resolve/main/data/smoke_val.parquet; pandas.read_parquet reads it.
• A trajectory JSON (artifacts/<run>/<train|val>/step_N/<uid>_<session>.json) is one episode; section 4 lists its keys. tensors.npz beside the training trajectories is a numpy archive keyed <uid>_<session>/{values,returns,raw_advantages,advantages,policy_mask}, one vector per response token.
• The initial adapters: snapshot_download("t2ance/atlas-25-sequential-tool-runtime-upgrade", repo_type="dataset", allow_patterns="checkpoints/actor_adapter_init/*"), then PeftModel.from_pretrained(<the SFT merge>, <local path>) (the critic's the same way with AutoModelForTokenClassification(num_labels=1) as the base); init_report.json beside each carries the task type, the target modules, the dtype at initialisation and the file digests. A saved training step (checkpoints/<run>/global_step_N/actor/) holds on the Hub only huggingface/ (config and tokenizer), fsdp_config.json and lora_train_meta.json: verl at this commit writes the trained adapter inside the FSDP model shards, which the exclusion list keeps off the Hub, so the diagnostic steps' adapters are not published (section 5).
• The W&B export's history.csv: step, the timing columns timing_s/gen, timing_s/old_log_prob, timing_s/ref, timing_s/values, timing_s/update_critic, timing_s/update_actor, timing_s/update_weights, timing_s/step; the invariants process_reward/mapping_sum_error_max, process_reward/decomposition_error_max, process_reward/mapped_slots_minus_events_max, process_reward/explore_negative_fraction, process_reward/first_explore_reward_mean, process_reward/later_explore_reward_mean, process_reward/terminal_reward_mean, process_reward/trajectory_sum_mean, protocol/violations_in_batch, capmask/capped_row_fraction, capmask/policy_tokens, adv/raw_mean_policy_mask, adv/whitened_var_policy_mask, training/actor_updates; the batch readings train/acc/mean, train/utility/mean, train/num_explores/mean, train/did_submit/mean, train/length_capped/mean; the validation views <gpqa|lcb>/<overall|subset>/{count,acc,cost,reward,explores,utility,has_answer,did_submit,overlong,length_capped,invalid_call,protocol_violations,model_tokens,response_tokens,submitted_after_correct,terminal/<reason>} and the matrices val/prefix_matrix/k<k>/{stop,continue,unresolved,stop_rate}, val/outcome_matrix/<found|not_found>/<submitted_correct|submitted_wrong|no_submit>.
• The training from the base model: runs/r25-base-2gpu/y9jzqbgc/history.csv is its step table (dedupe by _step; the critic in critic/vf_explained_var, critic/values/mean, critic/values/min, critic/returns/mean, critic/vf_loss, critic/grad_norm; the actor's movement in actor/entropy, actor/grad_norm, training/rollout_probs_diff_mean; the batch in train/acc/mean, train/has_answer/mean, train/num_explores/mean, train/length_capped/mean, response_length/mean; the phases in timing_s/gen, timing_s/old_log_prob, timing_s/values, timing_s/update_critic, timing_s/update_actor, timing_s/save_checkpoint, timing_s/step; the validations in the val/* columns of the rows of steps 10 and 20). outputs/r25-base-2gpu/main_ppo.log carries the same metrics in its step:N - lines and, between them, the engine lines (Running, Waiting, GPU KV cache usage every 10 s) and the ATLAS wake trace rank 0: After resume kv_cache lines (device memory after each wake-up, against 79.25 GiB). A validation's per-trajectory rows are checkpoints/r25-base-2gpu/val_dumps/<step>.jsonl; its trajectory files are artifacts/r25-base-2gpu/val/step_<step>/. In the reading copy a trajectory JSON is without response_logprobs, response_ids, prompt_ids and response_mask, and tensors.npz is absent: read those on the Hub.
• logs/gpu_budget.log: one stamped line per stage start, end, crash and relaunch (UTC). logs/<stage>.log: the tmux pane of that stage, every boot of it in one file.

4. Row fields

Trajectory JSON, top level: file_version, run_id, uid, session_id, attempt_id, benchmark, question_id, permutation_id, candidate_fingerprint, data_source, partition (train or val), global_steps, num_turns, prompt_ids, response_ids, response_logprobs (the rollout server's logprob of every sampled token), response_mask (1 on a sampled model token, 0 on a token the runtime appended), reward_score (the training reward), reward (the fixed numeric breakdown, keys score, training_reward, utility, overlong_penalty, overlong, acc, num_explores, cost, penalty, has_answer, did_submit, discovery, integration, grader_gap, subset, potential_stop, potential_defined, explore_reward_1 to explore_reward_8, terminal_reward, terminal_reason_code, protocol_violations, invalid_call, length_capped, observation_dropped, num_turns, prompt_tokens, response_tokens, model_tokens, first_correct_k, found_correct, submitted_after_correct, process_mode_code), reward_placement (a list of {offset, value}: the reward placed at that response offset), ground_truth, written_at, and episode, the execution record.

episode: schema_version, run_id, uid, session_id, attempt_id, benchmark, question_id, permutation_id, candidate_fingerprint, submission_field, max_explores, weight_versions, prompt_tokens, response_tokens, model_tokens, num_turns, terminal_reason (submitted, submitted_observation_dropped, explore_observation_dropped, budget_exhausted, length, no_call, invalid_call, multiple_calls, max_turns), terminal_offset, explores_executed, submit_executed, protocol_violations, and three lists:

• generations, one per turn: turn_id, request_id, weight_version, response_offset, num_sampled, max_tokens, finish (eos or length), finish_source (derived_from_tokens), tail_token_ids, grammar_hash, allowed_tools, sampling, num_cached_tokens;
• proposed_calls, one per turn: turn_id, name, arguments, raw_text, valid, reason, extra_calls;
• events, one per executed tool action: index, turn_id, kind (explore or submit), action_start_offset, action_end_offset, explore_k, candidate_idx, prefix_before, prefix_after, charged_cost_usd, payload, payload_nonempty, tool_response, observation_appended, observation_offset, observation_length.

tables/step_metrics_by_run.csv: log, run (the W&B id), step, then one column per metric named as in the W&B export. tables/validation_views.csv: benchmark, view (overall, subset, rest), n, acc, utility, explores, cost, has_answer, did_submit, overlong, length_capped, model_tokens, response_tokens (means over the view's trajectories, recomputed from the files).

tables/validation_curve.csv, one row per validation of the two 40-step trainings: step, training (shaped, zero), wandb_id, attempt (the unshaped training's 1 before the crash, 2 after the resume), canonical (0 marks the resumed run's repeat of the step-10 validation on the same weights), then per benchmark (gpqa_, lcb_) the W&B validation means acc, utility (acc minus 0.01 times explores), explores, cost, model_tokens, response_tokens, length_capped, has_answer, did_submit, first_correct_k, found_correct. tables/step_metrics_by_training.csv, one row per logged training step: step, training, wandb_id, attempt, canonical (0 marks the crashed run's steps 11 to 13, re-sampled by the resume), the W&B step line (timing_*, actor_updates, actor_lr, the process_reward means and invariants, protocol_violations_in_batch, actor_entropy, actor_kl_loss, actor_grad_norm, actor_pg_loss, actor_ppo_kl, actor_pg_clipfrac, critic_*, adv_*, capped_row_fraction, policy_tokens, response_length_*, train_*), and from the step's trajectory files (canonical rows only) rows, resp_tokens_p50, resp_tokens_p90, resp_tokens_p99, resp_tokens_max, resp_tokens_mean, rows_acc_mean, rows_explores_mean, rows_length_capped and one terminal_<reason> count per terminal reason. tables/call_advantage.csv, one row per training and step 11 to 40 over the rows in the gradient: rows_in_gradient, then the mean over calls of the per-call mean raw advantage (*_raw, returns minus values) and whitened advantage (*_whiten, the quantity the policy loss uses) on the tokens of the submit call (submit_), the first explore (explore1_), the later explores (later_) and the tokens outside every call (other_), with the mean return and value on the submit and first-explore tokens (submit_ret, submit_val, explore1_ret, explore1_val).

data/*/{train,val}.parquet: verl's row format, data_source, prompt (the chat messages), agent_name (atlas_sequential), reward_model (ground_truth), extra_info (benchmark, question_id, tools_kwargs with the cached candidates the explore tool reveals in order, need_tools_kwargs).

5. Weights and inputs

Both copies hold the same small files. The saved steps of every run stay on the instance's disk (atlas-2a100, global_step_10 to global_step_29 of r25-base-2gpu and the steps of the earlier runs) and, for the steps that came home, in the home data root; they are in neither copy, with one exception the user named:

Shared on the Hub	What it is
checkpoints/r25-base-2gpu/global_step_20/actor/lora_adapter/ (1.87 GB, 992 tensors, fp32)	the actor's adapter after step 20 of the training from the base model, the first policy the actor had moved (ten updates), whose validation read 165 of 198 GPQA and 94 of 175 LiveCodeBench; load it with PeftModel.from_pretrained(<Qwen3.6-27B>, <this directory>)
checkpoints/r25-base-2gpu/global_step_20/critic/lora_adapter/ (1.28 GB, 514 tensors, with the value head)	the critic's adapter after the same step, for continuing the training

Both were exported from the two-rank FSDP2 shards with training/scripts/lora.py export (values equal to the shards) and shared on 2026-09-12 at the user's request.

GitHub alone leaves out, by kind of file and never by run:

Left out of the reading copy	Why
the per-token arrays inside a trajectory record (response_logprobs, response_ids, prompt_ids, response_mask)	one number per token; the record's text, tool calls, answer, scores and reward trace stay; the Hub keeps the original record
tensors.npz beside the trajectories, any .npz or .npy, and tokenizer.json	per-token tensors and a tokenizer, read by no reviewer; on the Hub

Inputs produced by earlier experiments (linked, not copied):

Input	Source
new ordered-split SFT base and GPQA training questions	Report 26: https://huggingface.co/datasets/t2ance/atlas-26-pattern-teacher-sft-on-qwen3-6-27b ; checkpoints/sft_qwen3_6_27b_demonstrations_mixed_first80_lora_merged/ and data/first80/demonstrations_gpqa/rl/train.parquet. SFT adapter SHA-256: bc849a6fccc510782de1227c20902bcd4478fb1b15303c3cc7e891f434a2dfe6.
the SFT merge every run starts from, the actor's and the critic's base	https://huggingface.co/t2ance/atlas-sft_qwen3_8b_pattern_teacher_gpqa_firstcall_noconf_merged (a merged Qwen3-8B; report 02)
the training and validation rows before this report's rebuild (the candidate caches embedded in them)	report 03's data root Experiment/analysis/rl-training/03-cost-aware-exploration-collapse/data/, rebuilt here by training/rl/prepare_data.py with the loop's agent name; the candidates and their order are unchanged
the frozen potential table of the shaped training	https://huggingface.co/datasets/t2ance/atlas-24-frozen-prefix-potential-shaping, potential/gpqa_train.parquet (sha256 f95de04b2051470835b8cde8cffa14a4950790d3f1d5b1c36556eab8a2d1e3a9, recorded in that training's run.json); built under the old runtime, not bound to candidate fingerprints, see the report's Conclusion
the environment lock	Experiment/core_code/training/rl/env/requirements.lock.txt on the branch; verl 23af6a7, vLLM 0.26.0, XGrammar 0.2.3, torch 2.11.0+cu130, transformers 5.9.0, flash-attn 2.8.3, TransferQueue 434f8c4