3rd International Reinforcement Learning Bootcamp · PLUS Salzburg · 18 Sept 2026

Agentic AI for
Scientific Discovery

Reinforcement learning, model training, and research workflows.

Marius-Constantin Dinu
www.dinu.at
Advanced lecture · 44:30 + questions
← / → navigate · X index · N notes
History and motivation

Cortex: research infrastructure

Redacted Cortex runtime dashboard
Recorded public Cortex homepage
cortex.a2olabs.com ↗

Environments, tools, access and execution records.

Public homepage · offline recording.
Control-plane excerpt at 3× speed; identifiers redacted.

Cortex public site · Dinu, project catalogue. Recorded interfaces, not independent operational validation.
History and motivationAuthor-provided demonstrations

Agents in scientific software

Official Astra demonstration of PCB layout in KiCad and its 3D board view

Circuit-board layout in KiCad

Component placement, routing and a 3D board view.

GPT-6 Astra, computer-use demonstration.

Official Astra demonstration inspecting MultiQC sequencing reports

Sequencing-quality analysis

Inspection of MultiQC reports in scientific software.

GPT-6 Astra, scientific-software demonstration.

OpenAI, GPT-6 Astra, “Circuit board” and “Sequencing quality”, September 2026. Official embedded videos, 15-second excerpts. No independent reproduction.
History and motivation20 May 2026 · Human-checked proof

AI disproves Erdős's unit-distance conjecture

Erdős's unit-distance problem · 1946

Among $n$ points in the plane, maximize the number $u(n)$ of pairs at distance one.

distance 1 9 points12 pairs

Counting illustration, not the counterexample construction.

Conjectured upper bound
$$u(n)\le n^{1+o(1)}$$
AI-generated disproof
$$u(n)\ge n^{1+\delta},\qquad \delta>0$$

A fixed $\delta$, for infinitely many $n$.
The exact asymptotic growth remains open.

The model connected geometry to infinite towers of number fields. External mathematicians checked and simplified the proof.

History and motivationAnnounced 8 Sep · status checked 10 Sep 2026

Forced Navier–Stokes: claimed blow-up

$$\partial_t u+(u\!\cdot\!\nabla)u=-\nabla p+\nu\Delta u+f,\qquad \nabla\!\cdot u=0$$

$u$: velocity · $p$: pressure · $\nu>0$: viscosity · $f$: external force · divergence zero: incompressible flow

Two-dimensional decaying Taylor–Green reference flow with moving tracers and signed vorticity colors; not the claimed three-dimensional singularity

2D Taylor–Green reference flow · original animation, not the claimed 3D singularity.
Tracers follow velocity; orange/teal show opposite vorticity. Viscosity damps this flow.

3D claim · smooth compactly supported force · initially at rest
$$\sup_{0\le t<1}\|u(t)\|_2<\infty,\qquad \limsup_{t\uparrow1}\|u(t)\|_\infty=\infty$$

Bounded total energy, unbounded peak speed. Authors claim Clay C/D; the unforced problem is not settled.

Paper + Lean formalization released. The inspected Clay page remains “Active”; formalization still needs scrutiny of the encoded statement.

Provenance and credit · disputed

Buckmaster questions use of unpublished work. OpenAI denies targeted access but cannot exclude de-identified training influence. Bubeck disputes the attribution account and apologizes for a career remark.

History and motivationSelected milestones · different kinds of automation

Automated scientific discovery

Hover to preview
Click to enlarge

SymbolicAI computation graph linking Source, Method, RelatedWork, Abstract and Title to Paper
Dinu et al. · 2024 · Fig. 10, paper-generation workflow
Feb 2024

SymbolicAI

A neuro-symbolic computation graph assembles a scientific manuscript from supplied documentation and references. The benchmark evaluates intermediate and final generation outputs.

Scope. End-to-end manuscript generation—not an autonomous execution of novel research experiments.

This PhD-era work separates a complete document-generation workflow from the broader scientific process. The framework was released in January 2023; the benchmark and arXiv report followed in February 2024. Method, RelatedWork, Abstract and Title compose into Paper. A reference trajectory is an evaluation target, not evidence that the report itself was machine-written.

Primary sources: DENDRAL · BACON · Robot Scientist · Coscientist · SymbolicAI · AI Scientist · AI Scientist-v2. Selected milestones, not a claim of historical priority.

Milestone details

History and motivation

System contracts and change boundaries

"In large systems a partial understanding is the best you can do."

Sean Goedecke, July 2026

  • ContractExternal behavior and invariants that must survive.
  • ImpactCall paths, data dependencies and authority affected by the change.
  • EvidenceTests tied to those contracts and their failure conditions.
Goedecke, In defense of not understanding your codebase, 11 July 2026. The review obligations are an application of the argument.
Part II / III

Agent systems and
reinforcement learning

Harnesses · training objectives · controlled experiments

Questions on the historical context and examples?
Agent systems

Agent performance: model and harness

Policy πθconditioned on ctExecutiontools · permissionsstateproposal atobservation ot+1History → context Cψ
$$c_t=C_\psi(h_t,g)$$
$$a_t\sim\pi_\theta(\cdot\mid c_t)$$

$h_t$: observed history; $g$: goal.
$\psi$: harness configuration.
$c_t$: selected context; $\theta$: model parameters.

Context selection changes available information. Tool interfaces and permissions determine which proposals execute.

Agent systems

Agent harness: behavior and execution

Harness componentConcrete mechanismWhat it changes
Context and proceduresMarkdown instructions, skills, memory selectionInformation and procedural guidance supplied to the policy
Tool interfaceMCP, tool schemas, routing and permissionsAvailable operations and their execution conditions
Persistent executionCheckpoints, process state, budgets and stop rulesRecovery and continuation across context windows
EvaluationTests, validators and recorded environment outcomesWhich behavior is accepted and which failures remain visible

In my setup, a Makefile assembles this configuration. Training can absorb recurring procedures; permissions and evidence checks still need external enforcement.

Agent systemsHarness pattern · durable handoffs

Durable state across context windows

PersistWhat the next work interval needs
Task stateGoal, acceptance criteria, unfinished work and explicit status.
Recovery stateCode / configuration versions, checkpoint and environment startup procedure.
Evidence and decisionsExecuted checks, observed failures, rejected approaches and next action.
Recover

Read the handoff

Restore the intended work state.

Check

Smoke-test it

Confirm the baseline still runs.

Work

One bounded task

Implement against its criteria.

Handoff

Verify and record

Leave evidence for the next interval.

Conversation compaction is not a substitute for recoverable project state.

Young, Effective harnesses, Nov 2025 · Lopopolo, Harness engineering, Feb 2026. Generalized handoff pattern; a saved summary is not process-state recovery.
Agent systemsConstructed OAuth walkthrough · illustrative outcomes

Repository navigation and handoffs

Constructed repository walkthrough: AGENTS.md links to plan, docs and a selectively loaded OAuth skill; source and tests are searched and read; illustrative Google pass and GitHub callback failure are recorded for a fresh context. Billing files remain unopened.

Path found ≠ content read ≠ scenario exercised.

Task · PLAN.md

“Google login works. GitHub callback is unfinished.”

Done means the user can log in and log out.

Recovery · version + init.sh

auth-v2 @ a1b2c3d
Migration 17 · npm run dev

Restore the intended state; smoke-test the running app.

Evidence + next action · progress.json

“Google smoke passes. GitHub callback fails.”

Next: align the redirect URI, then rerun login/logout.

The next context reads these records.
It does not have to guess what “good progress” meant.

Agent systemsHarness pattern · evaluator feedback

Artifact generation and evaluation

Builder · proposed artifactRunnable code + configurationReproduction stepsClaim: the requested behavior works.ReviewEvaluator · evidence reportExpected / observed behaviorEnvironment + reproductionMismatch, uncertainty and next correction
Constructed functional check

Save → reload → recover the same configuration.

A visible button or HTTP 200 is not this end-to-end result.

Judgment needs calibration

Specify the rubric before generation.
Use human-scored reference examples.
Inspect disagreements and failure traces.

Separate roles do not make their errors independent. Critique informs repair; it is not an oracle.

Rajasekaran, Harness design, Mar 2026: criteria · runtime QA · Lopopolo: app / observability access. Engineering reports; inference-time orchestration, not GAN training.
Agent systemsHarness pattern · planning and revision

Planning and evidence-driven revision

Overall outcome · dependencies, interfaces and acceptanceCurrent bounded taskArtifact + evidence for this decisionRevise whenevidence changesan assumption.Not a script forevery future step.
Proposed controller policy

Stop on acceptance or budget exhaustion.
Escalate stalled work rather than looping indefinitely.

Re-test the scaffolding

A stronger model may need a different task size or evaluation cadence—not the same fixed ceremony.

Keep precise local acceptance criteria; avoid prescribing every future implementation step up front.

Agent systems

Credit assignment over tool use

$$J(\theta)=\mathbb E_{\tau\sim p_{\theta,\psi}}[R(\tau)],\qquad \hat g=\sum_{t\in\mathcal I_{\rm model}}\nabla_\theta\log\pi_\theta(a_t\mid c_t)\,\hat A_t$$

$\tau$: action–observation trajectory; $p_{\theta,\psi}$: its distribution under the model and harness.
$R$: workflow reward; $\mathcal I_{\rm model}$: model-generated token positions.
$\hat A_t$: credit estimate; $\hat g$: policy-gradient estimate. On-policy samples, fixed harness and environment.

Likelihood and credit

Generated tool calls and later model tokens receive credit. Tool results remain conditioning context.

Trajectory collection

Retain failures, behavior-policy scores and environment outcomes. Success-only filtering changes the learning problem.

The inference loop supplies trajectories. The training objective determines which recurring behavior they reinforce.

Schulman et al., PPO, §2.1, specialized to model-action positions; OpenAI, Introducing Codex, 2025, reported coding-task RL and iterative tests.
Agent systemsHypothesis · next 1–2 years

Workflow learning: a forecast

Prompting

Elicit a procedure

Specify decomposition and response conventions in context.

Harness engineering

Execute a procedure

Arrange tools, memory, tests and repair steps.

Training

Learn the procedure

Optimize behavior on verified multi-step trajectories.

Candidate learned behavior

Task decomposition, tool selection, recovery strategies and stopping decisions.

Externally enforced conditions

Data access, resource authority, environment state and independent evaluation.

Current releases still co-design models and harnesses. The forecast concerns recurring heuristics, not the disappearance of execution systems.

OpenAI, Codex, 2025; GPT-6 Astra, Coding / Aligning and deploying, 2026. The one-to-two-year horizon is a prediction.
Agent systems · source check: 17 September 2026 UTC · provider reports ≠ matched evaluation

SWE-bench scores and run costs

Verified progress · 2023–2026

Reported progress, not a controlled comparison

Different scaffolds, budgets and sampling. The mini-SWE-agent 1.x → 2.x change is explicitly non-comparable; new vendor reports use other setups.

Run costs · latest disclosed Feb 2026

Other suites (%) · not plotted as Verified

SWE-bench Pro: Opus 5 79.2 · GPT-5.6 Sol 64.6 · DeepSeek V4-Pro preview 55.4.

DeepSWE v1.1: Opus 5 68.8 · Sol 72.7 · GPT-6 Astra 74.1 · GLM-5.3 66.9 · DeepSeek V4-Pro-0813 62.7 · DeepSeek V4.1-Flash 74.2.

Provider reports; different tasks and setups, not one ranking.

Sources: Anthropic, Opus 5 §8.2–8.3 · OpenAI, Sol / Astra · Z.ai, GLM-5.3 · DeepSeek cards linked in callout · SWE-bench historical data. No independent rerun or invented cost point.
Agent systemsMETR TH 1.1 · Updated 8 May 2026

METR: task-completion horizons

Original METR time-horizon chart: human task duration at 50 percent predicted success increases from seconds to hours across model release dates; logarithmic scale, with measurements above sixteen hours marked unreliable

Human expert task duration, not AI runtime. Day-to-week research still needs durable state, budgets and stopping rules.

METR, Task-Completion Time Horizons, TH 1.1 · Kwa et al., Measuring AI Ability to Complete Long Software Tasks. Original chart captured 9 September 2026, 50% success / log scale.
Learning and experimental designA map of design choices · not one mandatory recipe

Agent training: data, rewards and updates

Fix the training contractTasks · tools · verifier · budgetsPolicySampled trajectoriesR1R2R3Blue: actions · grey: observationsFit accepted targetsorWeight sampled actionsUpdate policySaved checkpoint · frozen evaluationJudge progress; do not train on the held-out results.
What becomes a target?

Fit verified successes.

22–23 · Success filtering changes the fitted distribution.

What does “better than expected” mean?

Set relative credit coefficients.

24 · RLHF reward → critic → advantage; 25–26 · Inclusive group centering.

How does credit change the policy?

Control the update.

27–28 · Full GRPO algorithm, advantages and KL.
Backup 46 · PPO clipping detail.

Which experience reaches the update?

Control selection and collection.

27–29 · Grouped rollouts and estimator genealogy.
Backups 47–50 · DAPO retention and SAO collection.

Teaching decomposition: STaR · PPO, §2 · DeepSeekMath, §4.1. Reward/verifier design and the evaluation protocol remain explicit experimental choices.
Learning and experimental designOrientation · published stage decompositions

Post-training objectives and supervision

IMITATION · A TARGET TOKEN EXISTS REINFORCEMENT LEARNING · A SCALAR OVER A RESPONSE “It’s raining cats and…” → “dogs. I should get an umbrella.” next-token cross-entropy · web corpus “Which ice cream should I get?” → “Vanilla is the best flavor.” cross-entropy · human demonstrations “Which ice cream should I get?” A ≻ B — an annotator prefers one scalar from a fitted reward model “…total energy in kcal?” → “300 kcal” · checker agrees scalar from a program Base model next-token statistics, no task format Instruction-tuned answers in format, no outcome score Preference-tuned learned reward · RLHF Reasoning-tuned verifiable reward · RLVR PRE-TRAINING SUPERVISED FINE-TUNING PREFERENCE FINE-TUNING REASONING FINE-TUNING WHAT SUPERVISES THE UPDATE token from a corpus token from a human reward model r(x, y) verifier 1[y is correct]
Consequence for the estimator choices that follow

Left of the dashed line an incorrect token has a defined replacement, so the objective is a cross-entropy against it. Right of it only the complete response is scored, so per-token credit must be estimated from that scalar — the subject of the remaining slides.

Stage decompositions as published: Ouyang et al., InstructGPT, 2022 §4 · Lambert et al., Tülu 3, 2024 §3 · DeepSeek-AI, R1, 2025 §2.3. Illustrative prompts; stages are reordered or repeated in practice.
Learning and experimental designReward source · separate from the update rule

RLHF and RLVR: reward sources

RLHF

Reinforcement learning from human feedback

Human comparisons → fit a reward model
→ score sampled responses → update policy

$$P_\phi(y_w\succ y_l\mid x)=\sigma\!\left(r_\phi(x,y_w)-r_\phi(x,y_l)\right)$$

Fit preferred / rejected pairs $(y_w,y_l)$; use the learned score $r_\phi$ as reward, frozen during policy updates.

Useful for taste and intent. The optimized score remains a learned proxy for human judgment.

RLVR

Reinforcement learning with verifiable rewards

Task + sampled response → execute a verifier
→ use its outcome as reward → update policy

$$\begin{aligned}r(x,y)&=\mathcal V(x,y)\in\{0,1\}\\J_1(\theta)&=\mathbb E_{x,\,y\sim\pi_\theta(\cdot\mid x)}[\mathcal V(x,y)]\end{aligned}$$

Tests, answer checks or proof kernels supply task feedback without a learned preference model.

Binary expected reward is pass@1. Also measure pass@$k$: success within $k$ attempts can move differently.

$x$: task from a fixed distribution; $y$: response; $\pi_\theta$: policy; $r_\phi$: learned reward; $\sigma$: logistic function; $\mathcal V$: binary verifier. PPO / GRPO specify the update, not the reward source.

Method choice
Prefer RLVR when success is checkable. Auditable task feedback fits code, mathematics and our certificate-based experiments. Verifier coverage, soundness and evaluation cost still bound the claim.
Ouyang et al., InstructGPT, §3.5, Eqs. 1–2 · Lambert et al., Tülu 3, §6 · Chen et al., pass@k. Binary reward component shown; KL regularization or reward shaping changes the full objective.
Learning and experimental designSTaR · rejection self-training

Success-conditioned SFT

Illustrative proposals · fixed policy / decodingRetained supervised targetsy1y2y3y4y5y6Va = 1y1y3y6Discarded proposals do not enter this supervised refit.Fit with the SFT loss.
Which responses become targets?
$$q_{\rm keep}(y\mid x)=\frac{\pi_{\rm sample}(y\mid x)\,\mathbf1[V_a(x,y)=1]}{Z_a(x)}$$

$x$: prompt; $y$: response; $V_a$: extracted-answer verifier.
$\pi_{\rm sample}$: fixed rollout distribution; $Z_a(x)=\Pr(V_a=1\mid x)>0$.
Raw rejection samples, before deduplication or rewriting.

Then minimize ordinary SFT loss
$$\mathcal L_{\rm SFT}(\theta;x)=-\mathbb E_{y\sim q_{\rm keep}(\cdot\mid x)}[\log\pi_\theta(y\mid x)]$$

Each retained response supplies a teacher-forced target:

$$-\log\pi_\theta(y\mid x)=-\sum_{t=1}^{T}\log\pi_\theta(y_t\mid x,y_{<t})$$

$\pi_\theta$: fitted policy; $T$: response length. Hold targets fixed.
Increase the likelihood of accepted responses.

Original STaR also uses answer-conditioned rationalizations after failed attempts. That additional proposal path is not shown here.

Zelikman et al., STaR: Bootstrapping Reasoning With Reasoning, 2022. Conditional distribution for the answer-filtered sampling path.
Learning and experimental design

Success filtering favors solvable prompts

What is 17 mod 5? · constructed responses
Attempt A
17 = 3*5 + 2
answer: 2
Retain
Attempt B
17 = 4*5 - 3
answer: 3
Discard
Attempt C
17 - 15 = 2
answer: 2
Retain
Attempt D
17 - 10 = 7
answer: 7
Discard
$$d_{\rm keep}(x)\propto d(x)\,Z_a(x)$$

$d(x)$: proposal prompt distribution; $Z_a(x)$: answer-acceptance probability.
Equal attempts per proposed prompt; raw accepted samples pooled before deduplication.

Failed trajectories contribute no direct loss term.

Prompts with low acceptance supply few new targets, even if they matter to the final evaluation.

Rejection-sampling consequence under the stated assumptions. Constructed responses, not logged model generations.
Learning and experimental designRLHF → shaped rewards → GAE → PPO

RLHF: rewards and advantages

Step 1 · Score the response and penalize drift
$$\mathcal L_{\rm RLHF}=-\mathbb E_{x,y}\!\left[R_\phi(x,y)-\beta\sum_{t=1}^{T}\log\frac{\pi_\theta(a_t\mid s_t)}{\pi_{\rm ref}(a_t\mid s_t)}\right]$$

At rollout time, distribute that signal over tokens:

$$\tilde r_t=\mathbf1[t=T]\,R_\phi(x,y)-\beta\log\frac{\pi_{\rm old}(a_t\mid s_t)}{\pi_{\rm ref}(a_t\mid s_t)}$$

$R_\phi$: learned response reward; $\beta$: KL weight.
$x\sim\mathcal D$ (prompts); $y\sim\pi_\theta(\cdot\mid x)$; $s_t=(x,a_{<t})$.
$T$: response length; ref: anchor; old: rollout policy.

Step 2 · Compare continuation with a learned value
$$\begin{aligned}\delta_t&=\tilde r_t+\gamma V_\psi(s_{t+1})-V_\psi(s_t)\\[5pt]\hat A_t^{\rm GAE}&=\sum_{l=0}^{T-t}(\gamma\lambda)^l\delta_{t+l}\end{aligned}$$

$V_\psi$: critic; $\delta_t$: TD residual; $\gamma$: discount;
$\lambda$: GAE trace parameter; $V_\psi(s_{T+1})=0$.

If $\gamma=\lambda=1$:

$$\hat A_t=\underbrace{\sum_{u=t}^{T}\tilde r_u}_{\text{shaped reward-to-go}}-V_\psi(s_t)$$
Step 3 · Hold the advantage fixed; minimize the actor loss
$$\mathcal L_{\rm actor}=-\mathbb E_{\rm old}\!\left[\sum_{t=1}^{T}\min\!\left(\rho_t\hat A_t,\operatorname{clip}(\rho_t,1-\epsilon,1+\epsilon)\hat A_t\right)\right],\quad \rho_t=\frac{\pi_\theta(a_t\mid s_t)}{\pi_{\rm old}(a_t\mid s_t)}$$

$\mathbb E_{\rm old}$: rollout batch; $\epsilon$: clip width. Critic fitting is separate. Positive / negative $\hat A_t$ raises / lowers the sampled action's probability before clipping.

Ouyang et al., InstructGPT, §3.5 (RL objective; auxiliary pretraining term omitted) · Schulman et al., GAE, Eq. 11 · DeepSeekMath §4.1.1. Baseline identity: $\mathbb E_a[b(s)\nabla_\theta\log\pi_\theta(a\mid s)]=0$ for fixed, action-independent $b$ and fixed policy support.
Learning and experimental designGroup-relative baseline · before standardization

GRPO: inclusive group baselines

$$\bar R=\frac1G\sum_{j=1}^{G}R_j,\qquad A_i=R_i-\bar R$$

$G$: responses at one prompt $x$; $R_i$: response reward; $A_i$: mean-centered advantage.
Isolate mean subtraction before group-standard-deviation normalization.

$$\mathbb E[\hat g_{\rm seq}]=\left(1-\frac1G\right)\nabla_\theta\mathbb E[R\mid x]$$

$\hat g_{\rm seq}=G^{-1}\sum_i A_i\nabla_\theta\log\pi_\theta(y_i\mid x)$.
Iid on-policy sequences; before standardization, clipping, filtering and token normalization.

Removing the critic trades value-function learning for $G$ sampled completions per prompt.

Shao et al., DeepSeekMath, §4.1. Finite-group identity: score-function derivation under the stated assumptions, not the full standardized GRPO estimator.
Learning and experimental designGRPO continuation · worked group, G = 4

GRPO: response-level credit

What is 17 mod 5? · extracted-answer reward
Attempt A
17 = 3*5 + 2
answer: 2
R = 1
Attempt B
17 = 4*5 - 3
answer: 3
R = 0
Attempt C
17 - 15 = 2
answer: 2
R = 1
Attempt D
17 - 10 = 7
answer: 7
R = 0
$$\bar R=\tfrac12,\qquad (A_1,A_2,A_3,A_4)=(+0.5,-0.5,+0.5,-0.5)$$

Failed responses receive negative coefficients rather than being discarded.
These coefficients encode the outcome, not the validity of each reasoning token.

Shao et al., DeepSeekMath, §4.1.2: outcome supervision. Constructed example, not logged samples; mean subtraction before standardization.
Long-horizon reinforcement learningDeepSeekMath · original Algorithm 1

Iterative GRPO: the full algorithm

DeepSeekMath Algorithm 1, all twelve lines: initialize the policy; for each outer iteration snapshot the reference; for each collection step sample prompts, snapshot the old policy, generate G outputs per prompt, score rewards and compute group-relative advantages; perform mu GRPO updates; then retrain the reward model using replay. Output the updated policy.

$I$ outer iterations · line 3
Refresh the reference anchor; freeze it within the iteration.

$M$ batches / $\mu$ updates · lines 4–11
Collect with old; reuse fixed samples and advantages to update $\theta$.

Reward-model replay · line 12
Learned-reward iteration; not a required step for fixed RLVR verifiers.

Shao et al., DeepSeekMath, p. 14, Algorithm 1; §4.1.4. Original crop; link outlines hidden. $G$: outputs/prompt; $\varepsilon$: clip width; $\beta$: KL weight. Original line 11 cites Eq. 21 (simplified gradient coefficient); the full objective is Eqs. 3–4, shown next.
Long-horizon reinforcement learningAlgorithm 1 · advantage (line 9) → update (line 11)

PPO and GRPO: advantages and KL

PPO-based RLHF · learned critic

$$\hat A_t^{\rm PPO}=\operatorname{GAE}_t(\tilde r,V_\psi)$$

$\tilde r_t$ already includes the reference-KL cost.
The critic predicts shaped reward-to-go from each prefix; GAE supplies token-level credit.

For $\gamma=\lambda=1$: $\hat A_t^{\rm PPO}=\sum_{u=t}^{T}\tilde r_u-V_\psi(s_t)$.

Outcome GRPO · sampled group

$$\hat A_{i,t}^{\rm GRPO}=\frac{R_i-\operatorname{mean}(\mathbf R)}{\operatorname{std}(\mathbf R)}$$

$\mathbf R$: $G$ raw response rewards for one prompt.
One standardized coefficient per response, shared by all its tokens. No learned critic.

$(1,0,1,0)\mapsto(+1,-1,+1,-1)$ with population std.
Assume std $>0$; equal rewards give no relative signal.

Full sampled GRPO loss · minimize −$\mathcal J_{\rm GRPO}$
$$\mathcal L_{\rm GRPO}=-\mathbb E_{\substack{x\sim\mathcal D\\y_{1:G}\sim\pi_{\rm old}(\cdot\mid x)}}\!\left[\frac1G\sum_{i=1}^{G}\frac1{T_i}\sum_{t=1}^{T_i}\left\{\min\!\left(\rho_{i,t}\hat A_{i,t},\operatorname{clip}(\rho_{i,t},1-\epsilon,1+\epsilon)\hat A_{i,t}\right)-\beta K_{i,t}\right\}\right]$$
$$\rho_{i,t}=\frac{\pi_\theta(a_{i,t}\mid s_{i,t})}{\pi_{\rm old}(a_{i,t}\mid s_{i,t})},\qquad K_{i,t}=u_{i,t}-\log u_{i,t}-1,\qquad u_{i,t}=\frac{\pi_{\rm ref}(a_{i,t}\mid s_{i,t})}{\pi_\theta(a_{i,t}\mid s_{i,t})}$$

$T_i$: response length; $s_{i,t}$: prompt + prefix; $a_{i,t}$: token; $\epsilon$: clip width; $\beta$: KL weight. Samples, old probabilities and $\hat A$ stay fixed.
Old sets the importance ratio; ref sets the drift penalty. KL regularization does not replace the critic's variance reduction.

Shao et al., DeepSeekMath, §4.1.1–4.1.2, Eqs. 1–4 · Schulman et al., PPO, Eq. 7. $K$ estimates forward KL under current-policy sampling; reused old-policy batches need that caveat. Reference refresh follows Algorithm 1.
Long-horizon reinforcement learningOne picture · three axes of variation

Policy-gradient objective families

REINFORCE 1992 · score fn TRPO 2015 · bound PPO 2017 · clip RLOO leave-one-out baseline GRPO group mean / std VAPO / VC-PPO critic, restored Dr. GRPO delete both normalizers DAPO 4 fixes, no KL Kimi k1.5 · OPMD mirror descent, ℓ₂ GSPO sequence-level ratio CISPO truncated IS weights TIS / async RL engine mismatch repair 2026 practice mix & match AXIS 1 · TRAJECTORY SIDE AXIS 2 · REWARD / BASELINE AXIS 3 · INFRASTRUCTURE
Reading
Every arrow is a bias-for-stability trade. TRPO had a bound; PPO kept only the shape; the critic cost a second policy-sized model, which is why the 2024–25 group-baseline line is critic-free — not why critics disappeared: VAPO keeps one, and SAO restores a critic in asynchronous training. Each axis has a consequence to examine: normalization and group selection set reward scaling, length weighting and how many groups stay usable (Dr. GRPO · DAPO); importance weighting sets ratio granularity and the gradient that survives truncation (GSPO · CISPO); a preference contract replaces programmatic outcomes with annotated pairs (DPO). These are distinct estimators and data contracts, not implementations of one acronym.
Williams 1992 · Schulman et al. arXiv:1502.05477, 1707.06347 · Ahmadian et al. arXiv:2402.14740 · Shao et al. arXiv:2402.03300 · Liu et al. arXiv:2503.20783 · Yu et al. arXiv:2503.14476 · Zheng et al. arXiv:2507.18071 · MiniMax arXiv:2506.13585 · Team Kimi arXiv:2501.12599. Sources: [1] · [5].
AI-assisted model designSynthetic dashboard demo

Dentate: experimental workbench

Dentate dashboard showing a synthetic demo run
Dentate

Architectures and learning experiments.

Custom models, task generators and simulation environments.

Synthetic demo data shown.
Not the Spiral measurements.

Dinu, project catalogue. Recorded dashboard at 4× speed. No performance claim from the displayed demo metrics.
Architecture as an experimental controlPublished research ≠ disclosed Astra architecture

Recurrent depth and parameter sharing

PreludeCodaPass 1abcdPass 2abcdPass rabcdOne four-layer core · shared weights across all r passes
$$s^{(k+1)}=R_\theta(e,s^{(k)}),\qquad D(r)=2+4r+2$$

$e$: encoded input; $s^{(k)}$: latent state; $R_\theta$: shared core.
$k$: iteration; $r$: number of passes; $D$: effective depth. Huginn: 3.5B unique parameters.

Another published regime: TRM

7M parameters, two-layer shared network.
Task-specific latent / answer refinement—not a frontier LM replacement.

Astra: attributed report, not confirmed topology

TechCrunch, citing The Information, reports limited recurrent depth. OpenAI materials reviewed do not disclose an “RMM core.”

AI-assisted model designOne concrete experimental setup

Recurrent model and training harness

Token embeddingShared core + memoryiteration-dependent modulationReadoutDepth changes computation without adding a new set of core weights.
$$z^{(k+1)}=F_\theta(z^{(k)},x,k)$$

$z^{(k)}$: recurrent state; $k$: iteration index.
$x$: input; $F_\theta$: shared, modulated transition.

Spiral: the recurrent model.
Dentate: the training and evaluation harness.

Historical answer-only score: 10/48 → 18/48.
Logged iterations 20–100; first point already trained.

One seed; unmatched configurations; possible earlier data overlap.
No causal attribution or current certificate-score claim.

Architecture: Dinu, Spiral, technical report. Scores: own unpublished p4-final experiment, July 2026; not a published benchmark or superiority claim.
AI-assisted model designCurrent deployment · no availability claim

Hosted experiment infrastructure

publicpublicboundaryper accounthosted execution Browserno account to read Caddy → frontdoorFastAPI + SPA · public API Authentik loginOIDC · only to launch Labproject · runs · papers Worker containersCPU · torch · Spiral · tokenizer one experiment per worker · results return to the lab /#/papers · /#/docs · /#/results need no login
  • Local · pip or CLI bundlepip install "dentate[demo]", or the packaged CLI for macOS, Linux and Windows. Runs offline after dentate demo init.
  • ColabOne notebook: install, run the starter experiment, then open the dashboard through the proxied port 8793. No local setup.
  • VisibilityPapers, docs and results: public. Each experiment and user paper: private by default; the owner toggles it public.
dentate.cortex.a2olabs.com · documentation · CLI downloads · Colab notebook. Deployment description of the current site; hosted capacity is bounded by the worker pool.
AI-assisted model designProposed exercise

Checkpoint-controlled RL comparison

Packaged flow · offline after init
pip install "dentate[demo]"
dentate demo init
dentate demo run --out my-experiment

dentate serve
# http://127.0.0.1:8793

Compare baseline and RL checkpoints on one frozen, content-disjoint task set.

SFT → support gate → GRPO from the same checkpoint → frozen evaluation. Fix decoding and loop depth. Pool construction and evaluation protocol.

Inspect the result
my-experiment/results.json
my-experiment/metrics.json
my-experiment/provenance.json

Pre/post accuracy and the gate verdict. A failed gate is a result. Hosted alternative: /#/lab after login; private until published.

Dentate documentation · Colab notebook · Environment prerequisites. Current support gate: certificate validity and positive readiness gap; historical answer-only metrics are not upgraded.
AI-assisted model design

Model, data and compute controls

Experimental factorActual interfaceControl to record
ArchitectureArchSpec
key, config_factory, builder
--arch, --arch-opt
Model, tokenizer and checkpoint compatibility
Task dataReasoningTask
id, kind, question, think, answer
--kinds modular
Custom tasks through Python generators
Rollouts and depth--group, --n-iters
Generation cap and decoding settings
All sampled compute
Include discarded groups and skipped batches

GRPO --steps counts attempted batches, not optimizer updates.
Changing group size changes both rollout cost and the probability of an update.

Retain run.json, metrics.jsonl and the checkpoint. Keep the acceptance evaluation outside the candidate's control.

Dentate documentation: model plugins, task data and training controls. Plugins must satisfy the runner's model contract; these are experimental factors, not new optimizer families.
Part III / III

Agentic AI for
scientific discovery

Research workflows · evidence · recursive improvement

Questions on the methods and experimental controls?
Scientific workflows · own researchLearner-relative guarantees · explicit assumptions

Experience models: what to preserve

Specify the learner, the sampling law and the guarantee.

Hover or focus to inspect · click to expand

Conditional-expectation identity

Match the conditional target mean

For a squared-loss learner with a frozen target, the expected gradient depends on its conditional mean.

$$\begin{aligned}Y&=r+\gamma v_{\bar\theta}(s'),\qquad m_K=\mathbb E_K[Y\mid s,a]\\g_q(\theta)&=\mathbb E_\nu[(f_\theta-m_K)\nabla_\theta f_\theta]\end{aligned}$$

$\nu$ is the common input law; $K$ is the experience kernel. Hold $Y$, target parameters and sampling laws fixed during differentiation.

Scope. Equal conditional means, under the same input law, imply equal expected gradients—not equal variance or return.

The analytic identity requires finite loss and local domination to interchange differentiation and expectation. It is a familiar conditional-expectation argument. Lean checks finite-coordinate algebra, not those analytic assumptions. If the target is differentiated, its variance can matter: for $Y=\tfrac12\theta Z$, laws $Z=0$ and $Z\in\{-1,+1\}$ with equal probabilities both have zero target mean and stopped-target update $\theta$, but full residual gradients are $\theta$ and $1.25\theta$.

Own manuscript: What Must Experience Models Preserve? Learner-Relative Equivalence and Controlled Failure Cases, foundations. Known identities and explicit failure witnesses; finite Lean checks are not an end-to-end RL guarantee. Source record.

Mathematical details

Scientific workflows · own researchExploratory fixed-data studies · not a general method ranking

Learning outcomes and failure cases

Same law,
different learner

Ten-seed finite-control curves under the exact true joint law. Semi-gradient final true greedy-policy return 2.232; full residual gradient 1.712. Shading shows pointwise 95 percent bootstrap intervals.

2.232 vs 1.712

Semi-gradient / full residual gradient.
Exact true law · 500 expected updates.

Early gain,
later deterioration

Independent-test half-squared loss: gradient matching improves early then deteriorates to 1.155 at 400 updates; joint empirical training ends at 0.441 and the random subset at 0.550. Ten seeds, pointwise 95 percent bootstrap bands.

1.155 vs 0.441

Gradient matching / joint empirical.
Frozen supervised targets · test loss ↓.

CartPole:
execution evidence

Initial-check replay · 10× slow

Recorded CartPole state from the first saved empirical-replay policy; the loop shows training seeds zero and one, including both failures.

Fresh returns: 9 / 41 · two saved policies.
Not the manuscript evaluations.

Larger pilot · five training seeds

49.54–86.16

Range of six method means—not an interval.
2,000 updates · 6,000 transitions/seed.
10 evaluation episodes/policy; no ranking.

Own manuscript, finite-control / supervised / CartPole experiments. Plots: ten paired seeds; pointwise 95% bands from 2,000 seed-block bootstrap resamples—not simultaneous intervals. Fixed-data, exploratory, unequal fitting compute. Plotted data · Recorded states · Provenance and limits.
Scientific workflows

From research claim to experiment

omegaXiv research question, manuscript and artifact workspace
omegaXiv · steering example

A loop-depth hypothesis

Does extra recurrence improve accuracy at fixed compute?

Require a common evaluation, versioned configurations and compute measurements.

Reject a confounded comparison. Record the revised trial before continuing.

Recorded interface, 3×. Unreviewed outputs are not results for this example.

Recorded omegaXiv interface, cropped and redacted. Optional existing-artifact walkthrough. No independent scientific validation of the displayed outputs is claimed.
Scientific workflowsProposed workflow contract

Research artifacts and acceptance criteria

Literatureand evidenceFalsifiablehypothesisFormalizationand designExperimentand verificationInterpretationand revisionEvidence + human steering → versioned question and protocol
$$\begin{aligned}a_j&=\Phi_j(g,s_j),\quad v_j=V_j(g,s_j,a_j),\quad s_{j+1}=U_j(s_j,a_j,v_j)\\\operatorname{accept}&=\mathcal A_g\!\left(E(s_{\rm final})\right)\end{aligned}$$

$g$: goal and constraints; $s_j$: evidence state; $a_j$: phase artifact.
$\Phi_j$: phase; $V_j$: validator returning $v_j$; $U_j$: accept, repair or escalate transition.
$E$: evidence extraction; $\mathcal A_g$: goal-dependent acceptance.

Loop-depth hypothesis → executable model/data specification → accuracy and compute measurements → accepted, rejected or revised claim.

omegaXiv research artifacts. Related proposal/evaluation loop: Novikov et al., AlphaEvolve, 2025. The equation is a proposed contract schematic, not a result from that paper.
Recursive self-improvementPublished examples · author-reported results

AI-assisted model development

ExampleWhat the system didWhat changed
DeepSeek-R1
Jan 2025 · Nguyen
Wrote llama.cpp WebAssembly SIMD code with human prompts and tests.Inference software.
Benchmarked on Llama; no R1 weight update.
PaperBench
Apr 2025 · OpenAI
Claude 3.5 Sonnet: 21% average replication score across 20 papers.Research execution.
12-hour BasicAgent; partial credit, not new findings.
AlphaEvolve
May/Jun 2025 · DeepMind
Evolved a Gemini training-kernel heuristic: 23% faster kernel → 1% less training time.Training infrastructure.
Automatic program search; human-defined evaluation.
GPT-5.3-Codex
Feb 2026 · OpenAI
Early versions helped debug training, analyze evaluations and manage deployment.Its own development process.
Researchers used and reviewed the assistance.
Recursive self-improvementReported research loops · conditional successor feedback

Recursive research feedback

Current AIproposes changesRun experimentsand train candidatesEvaluate, rejector acceptImproved toolingor successor model Revise the experiment Conditional feedback: does the improved system make the next search better?
Anthropic · weak-to-strong research

Nine Claude agents designed experiments and trained small Qwen students. Humans chose the problem and evaluator.

A top method's production-scale gain was within noise. Claude's own weights did not change.

OpenAI · September 2026 report

Agents write code, prepare data, monitor runs and analyze results. People retain priorities and scale, pause or deploy decisions.

Internal activity and success metrics do not isolate research-productivity gains.

Autonomous recursive model improvement would require repeated successor-driven gains. These reports do not establish that full cycle or inevitable exponential growth.

Research directions

Your next research question

Turn your research question
into an experiment.

Agents can help build and run it.
You decide what to ask and what counts as evidence.

Research directions

Define the goal.
Define the verification.
Let the model search.

Model improvement

Search over architectures, training data
and experimental designs.

Human intervention

Choose questions, revise assumptions
and interpret the evidence.

Within two years, I expect agents to outperform much of my manual search for model and training improvements.

Questions · Open technical backup

Backup · guide

Technical references

Paper sources: DPO · GRPO · Dr. GRPO · DAPO · GSPO · CISPO. Implementation choices and unpublished measurements are identified separately.
Backup · methodsPPO clipped surrogate

PPO: the clipped objective

$$\ell_t(\theta)=\min\!\left(\rho_t\hat A_t,\;\operatorname{clip}(\rho_t,1-\epsilon,1+\epsilon)\hat A_t\right)$$
$$\rho_t=\frac{\pi_\theta(a_t\mid s_t)}{\pi_{\mathrm{old}}(a_t\mid s_t)}$$

$a_t$: sampled token; $s_t$: its prefix.
$\epsilon$: clip width; $\ell_t$: term to maximize.
$\hat A_t$: advantage, held fixed for the update.

The rollout policy is fixed for the batch. Several optimization passes may reuse its samples.

POSITIVE ADVANTAGE 1 + ε ratio ρ plateau NEGATIVE ADVANTAGE 1 − ε ratio ρ plateau no upper plateau ℓ stops rising past 1 + ε ℓ keeps falling past 1 − ε

Both slices of the same $\min$; one bound binds per sign — $\epsilon_{\rm high}$ left, $\epsilon_{\rm low}$ right. DAPO's Clip-Higher raises $\epsilon_{\rm high}$, so it loosens the positive branch; the penalty side has no upper limit. The ratio itself is never constrained.

Schulman et al., PPO, §3 Eq. 7 / Fig. 1. Clipping is a surrogate construction, not a hard policy-divergence constraint.
Backup · methodsDAPO dynamic sampling · GRPO follow-up

Reward variance and group retention

$$\Pr(\text{retained}\mid x)=1-p_x^G-(1-p_x)^G$$

At fixed $x$, iid $R_i\sim\operatorname{Bernoulli}(p_x)$; $p_x=\Pr(R=1\mid x)$.
Binary reward; a group is retained only if its rewards are not all equal.

At one prompt, G = 8Retained groups
$p_x=0.01$7.7%
$p_x=0.10$57.0%
Aggregate success hides heterogeneity

Half the prompts always pass.
Half always fail.

50% aggregate success.
Zero retained groups.

DAPO resamples until the batch contains enough non-uniform groups.

Yu et al., DAPO, §3.2, Eq. 11: dynamic sampling. Bernoulli retention probability derived here; illustrative, not a reported result.
Backup · methodsSAO · published July 2026

SAO removes the group rollout barrier

Adapted SAO Figure 2, with the author-relative word ours removed: GRPO waits for complete prompt groups; SAO consumes individual completed trajectories. Numbers indicate generation order; the right panels compare ratio masking.
Read the numbered tiles

Generation order, not reward or duration.
Top: complete groups. Bottom: individual completions.

What supplies the baseline?

GRPO: rewards from the same prompt.
SAO: a learned token-level value function.

Hou et al., SAO, Fig. 2, §3.2 / §4.1 · GRPO: DeepSeekMath §4.1. Adapted label: “ours” omitted; CC BY 4.0. “Trust region” sketches are not hard KL guarantees; policy lag remains.
Backup · methodsSAO · direct double-sided importance sampling

SAO: behavior-policy correction

$$\rho_t=\exp\!\left(\log\pi_\theta(a_t\mid s_t)-\ell_t^{\rm rollout}\right)$$

$a_t$: generated token; $s_t$: its observed prefix; $\pi_\theta$: current policy.
$\ell_t^{\rm rollout}$: stored log probability at generation time.

$$m_t=\mathbf 1[1-\epsilon_\ell<\rho_t<1+\epsilon_h]$$

$m_t$: policy-gradient mask; $\epsilon_\ell,\epsilon_h$: lower and upper widths.

PPO min surrogate

Saturates the improving side according to the sign of the advantage.

SAO's DIS mask

Drops both out-of-range sides regardless of the advantage sign.

Update filtering is not a hard KL constraint. Action-boundary GAE in backup.

SAO §3.1, Eqs. 1–3 · PPO §3. Mask boundaries follow SAO Eq. 3; no claim of unbiased off-policy learning.
Backup · methodsAuthor-reported results · not reproduced here

SAO ablations and GLM release results

Original paper figure · AIME2025
Original SAO Figure 3 AIME2025 panel: accuracy versus training steps; vanilla GRPO collapses early, GRPO with DIS remains stable, and SAO rises above it later

DIS stabilizes the GRPO baseline.
The SAO advantage appears later in training.

Qwen3-30B-A3B; training steps, not matched wall-clock compute. Repeated evaluation is not training-seed replication.

GLM-5.2 → GLM-5.3 · release comparison

Terminal-Bench 3.0
4.6 → 28.3

Same base model.
More environments, task diversity and post-training compute.

SAO with compaction remains in the stack. The gain does not isolate the optimizer.

Blog setup: Claude Code 2.1.207, avg@3, 400K context, 10-hour / 600-turn cap.

slime, compaction and evaluation details

SAO, Fig. 3, Tables 1–2, §4.1–4.3 · GRPO source · GLM-5.3 release / benchmark notes. Original SAO figure, CC BY 4.0. Release gains do not isolate an optimizer effect.
Backup · methodsReward design · constructed counterexample

Answer-only versus certificate verification

Slides 23 and 26 used answer-only rewards. Now add a certificate check.

Same task, new response

What is 17 mod 5?

Correct answer, invalid certificate
Certificate: 17 = 3*5 + 1
Answer:      2

A valid certificate is 17 = 3*5 + 2, with 0 ≤ 2 < 5.

$$R(x,y)=\mathbf{1}\!\left[V_a(x,y)\land V_c(x,y)\right]$$

$V_a$: correct final answer.
$V_c$: valid certificate, bound to the task and answer.
Here: $V_a=1$, $V_c=0$, so $R=0$.

Answer-only: reward 1.
With the certificate check: reward 0.

Specify the accepted certificate forms; then probe rollouts against that rule.

Constructed certificate-based reward. Contrast with outcome / format rewards in DeepSeek-R1, §2.2.2. A certificate does not reveal the model's internal reasoning.
Backup · architecturesRepresentative disclosed systems · 2025–2026

Dense, sparse-MoE and hybrid model architectures

ModelExecution and capacityState / memory choice
Qwen3-32B
2025 · dense baseline
Dense Transformer decoder
32B parameters
Grouped-query attention
KV cache grows with context
GLM-5.2
2026 · sparse MoE
744B total / 40B active
Sparse attention + IndexShare
One indexer per four layers
Index reuse is not block recurrence
Nemotron 3 Ultra
2026 · hybrid MoE
550B total / 55B active
Mamba + attention + LatentMoE
Recurrent sequence state
Attention layers still require KV state

Parameter activation, context memory and repeated depth are different experimental controls.

Active weights are a compute proxy—not exact FLOPs, latency or total resident memory.

Backup · implementationDentate source · not a universal GRPO definition

Dentate's GRPO configuration

$$d_{it}=\log\pi_{\rm ref}(a_{it}\mid h_{it})-\log\pi_\theta(a_{it}\mid h_{it}),\qquad\widehat{\mathrm{KL}}=\frac1Z\sum_{(i,t)\in\mathcal M}\left(e^{d_{it}}-d_{it}-1\right)$$

$a_{it}$: generated token; $h_{it}$: its prefix. $\pi_{\rm ref}$: frozen starting policy.
$\mathcal M$: retained completion positions; $Z=|\mathcal M|$. Samples need not be from the current policy.

ChoiceCurrent local behavior
Group normalizationMean subtraction; standard-deviation division optional.
Zero-variance groupsSkipped; no replacement sampling to refill the batch.
Token aggregationTotal retained-token mean by default (not the published fixed-length Dr. GRPO denominator); the response mean $\frac1N\sum_i\frac1{T_i}\sum_t$ is selectable, with the KL term aggregated the same way.
Algorithmgrpo as above, or sao: one rollout per prompt, generation-time behavior log-probabilities, value-head GAE baseline, double-sided ratio mask — a bounded single-process embodiment of SAO's components, not its asynchronous infrastructure.
Sampling and reuseTemperature-adjusted sampling; raw token ratios. One inner pass by default.
Dentate documentation. Published comparisons: DeepSeekMath §4.1 · Dr. GRPO. The table describes local choices, not either complete published algorithm.
Backup · practical

Prerequisites: package, CLI bundle, Colab or the hosted lab

Python ≥3.11 with the demo extra: PyTorch (CPU suffices), Transformers, spiral-lm and the bundled tokenizer.

Tokenizer: HuggingFaceTB/SmolLM-135M-Instruct at a pinned revision, materialized once by demo init. No download at run time afterwards.

pip install "dentate[demo]"
dentate demo init     # tokenizer + starter project
dentate demo doctor   # torch / spiral / tokenizer
dentate demo run --out my-experiment
dentate serve         # http://127.0.0.1:8793

No Python: the CLI bundle for macOS arm64, Linux x64 and Windows x64 runs the same commands. Colab proxies port 8793.

Inspect the experiment store
my-experiment/results.json     # pre/post accuracy, gate
my-experiment/metrics.json     # curves
my-experiment/provenance.json  # configuration lineage
my-experiment/result.dentate   # importable package

Re-evaluate the RL checkpoint with the same task set and decoding settings as the baseline.

The generic dentate run development example is fake-backed. It is not the real Spiral training exercise.

Hosted: /#/lab after Authentik login; experiments queue on CPU worker containers and stay private until published.
Public, no account: documentation · Spiral technical report · published results

dentate.cortex.a2olabs.com: papers, documentation and published results are public. The presentation itself needs neither Python nor a running dashboard; the optional local exercise requires the package described above.
Backup · scientific workflowProposed formal interface · not an implementation equivalence

Scientific workflow: artifacts, validation and acceptance

$$a_j=\Phi_j(g,s_j),\qquad v_j=V_j(g,s_j,a_j),\qquad s_{j+1}=U_j(s_j,a_j,v_j)$$

$g$: goal and constraints. $s_j$: evidence / artifact state entering phase $j$.
$\Phi_j$: proposing phase. $a_j$: its output artifact. $V_j$: validator; $v_j$: verdict.
$U_j$: state transition, including bounded repair or escalation.

$$e_t=E(s_{\rm final}),\qquad\operatorname{accept}_t=\mathcal A_g(e_t)$$

$E$: collect results and provenance. $e_t$: evidence from trial $t$.
$\mathcal A_g$: predeclared acceptance rule for goal $g$, not a guarantee of truth.

Distinction
Workflow composition and candidate search are not themselves RL.
RL additionally updates a policy from a reward signal.
omegaXiv research artifacts. Related published search loop: Novikov et al., AlphaEvolve, 2025. The proposed interface does not inherit a guarantee of scientific validity.
Backup · practicalProposed exercise

Content-disjoint evaluation for the modular task

from dentate.pretrain.reason_run import (
    sample_mixed, sample_heldout,
)
key = lambda t: (t.kind, t.question, t.answer)
sft = sample_mixed(2048, seed=0, kinds=["modular"])
rl = sample_mixed(512, seed=0, kinds=["modular"])
excluded = {key(t) for t in sft + rl}
heldout, missing = sample_heldout(
    48, seed=200000, kinds=["modular"],
    exclude=excluded,
)
assert heldout
assert not ({key(t) for t in heldout} & excluded)
print("Evaluation denominator:", len(heldout))

Freeze these tasks before inspecting either model's score.

Use the same ReasonTrainer.evaluate call for each checkpoint: same tasks, tokenizer, system prompt, loop depth and 48-token budget.

Only 760 possible modular questions in this generator. The remaining set may be small. Report it.

Support, answer accuracy and valid trace format are separate measurements.

Dentate documentation: reasoning tasks and evaluation. Code uses the proposed exercise defaults; other curricula require their actual training-content union.
Backup · project

Myflix: a personal media service

Myflix catalogue and playback navigation
Myflix

A streaming service I control.

Library, playback, deployment
and Android TV.

Edited navigation recording.

Dinu, project catalogue. Local recording, navigation excerpt. Artwork © respective rights holders.
Backup · long-horizon controls

Recoverable experimental state

Target workload

Day-to-week
research tasks.

Search loop depth and data under a fixed budget. Reproduce the strongest candidate across seeds on untouched tasks.

Recover code, configuration, checkpoints and rejected hypotheses across context windows.

Failure modeRequired control
Context exhaustionDurable artifact and decision state
Interrupted toolsActual process state and safe resumption
Delayed outcomesIntermediate checks tied to the final objective
Human redirectionVersioned goals, budgets and acceptance criteria

Stop on acceptance, budget exhaustion or a recovery decision that needs human input.

METR, Time horizons, success-calibrated human task duration; Anthropic, Effective harnesses, state and recovery failures. Day-to-week work is the target, not a benchmark claim.
AI-assisted model designSupervised learning and sampling support

Supervised initialization and rollout evaluation

$$\mathcal L_{\mathrm{SFT}}(\theta)=-\frac{1}{|\mathcal M|}\sum_{t\in\mathcal M}\log\pi_\theta(y_t^*\mid x,y_{<t}^*)$$

$y^*$: supplied target; $\mathcal M$: its supervised output-token positions.
Training uses target prefixes. Rollout uses sampled prefixes.

During the supervised lossPrefix tokens are supplied.During free-running rolloutPrefix tokens were sampled.xy1*y2*y3*xŷ1ŷ2ŷ3Conditioning prefixNext token

SFT is one route to reward-bearing rollouts, not a universal prerequisite for RL.
Probe the rule chosen on backup 51; report answer-only success separately.

Zelikman et al., STaR, 2022 · Liu et al., Understanding R1-Zero-Like Training, §2, 2025. Probe results depend on tasks, decoding and verifier.
AI-assisted model designSame token surrogate · different aggregation

Token-level and response-level loss weighting

$$\ell_{it}=\min\!\left(\rho_{it}A_i,\operatorname{clip}(\rho_{it},1-\epsilon_\ell,1+\epsilon_h)A_i\right)$$

$\rho_{it}$: current / rollout-policy probability ratio; $A_i$: response advantage.
$N$: retained responses; $T_i$: generated-token count. Prompt / environment tokens excluded.

Token mean
$$J_{\rm token}=\frac{\sum_{i=1}^{N}\sum_{t=1}^{T_i}\ell_{it}}{\sum_{i=1}^{N}T_i}$$

Longer responses carry more aggregate token weight.

Response mean
$$J_{\rm response}=\frac1N\sum_{i=1}^{N}\frac1{T_i}\sum_{t=1}^{T_i}\ell_{it}$$

Each response average has the same coefficient.

Filtering changes the retained population. Specify it together with the denominator. The Dentate demo exposes both aggregations (loss_aggregation), the advantage normalization, the clip band and a bounded single-process SAO (algorithm); its weighting.json records the per-response terms so both means can be recomputed by hand.

DeepSeekMath, §4.1 · DAPO, token-level loss · Liu et al., Dr. GRPO. Reference and entropy terms omitted to isolate aggregation; neither mean is the full Dr. GRPO objective.
AI-assisted model designExperimental design · no new measured result

Controlled RL comparisons

$$\widehat{\Delta}=\frac1n\sum_{j=1}^{n}\left[V(x_j,y_j^{B})-V(x_j,y_j^{A})\right]$$

$A$, $B$: baseline and treatment; $x_j$: shared held-out task.
$V$: fixed acceptance rule; $y_j^A,y_j^B$: outputs under a matched decoding protocol.

ControlWhat must be comparable
Initialization and dataSame starting checkpoint and training task distribution.
Audit test overlap across every training stage.
EvaluationFrozen tasks, verifier, decoding and token caps.
Select checkpoints on development data, not the final test set.
Compute and uncertaintyMatched budget, including discarded samples.
Repeat training seeds; report paired task effects and seed variation.
Controlled optimizer-comparison protocol. Agarwal et al., Deep Reinforcement Learning at the Edge of the Statistical Precipice, 2021: uncertainty and reliable evaluation.
AI-assisted model design

Task distributions and verifiers

Task and artifactAutomated feedbackUnresolved validity
Code change
Patch and execution trace
Behavior, regressions, permission boundariesUntested cases and system-level effects
Video edit
Timeline and rendered output
Synchronization, required assets, render constraintsMeaning, pacing and narrative intent
Simulation
Model and trial specification
Numerical consistency, constraints, repeatabilityModeling assumptions and real-world fidelity

Task generator + admissible artifacts + verifier + evaluation protocol
form a reusable environment for domain-specific model improvement.

Proposed domain-task contracts. Related reward mechanism: DeepSeek-R1, §2.2.2–2.2.3. A programmatic outcome check does not certify every intermediate claim.
Backup · SAO

SAO advantage estimation across tool observations

Model action i

Final generated token

$a_{i,N}$

Environment observation

Conditioning context

No intermediate GAE steps.

Model action i + 1

First generated token

$a_{i+1,0}$

$$\begin{aligned}\delta_{i,N}&=r_{i,N}+\gamma V(a_{i+1,0})-V(a_{i,N})\\\hat A(a_{i,N})&=\delta_{i,N}+\gamma\lambda\hat A(a_{i+1,0})\end{aligned}$$

$a_{i,N}$: final token of action $i$; $a_{i+1,0}$: first token of the next action.
$V$: critic at the indicated token's prefix; $r$: reward; $\gamma$: discount; $\lambda$: GAE decay.
$\delta$: temporal-difference residual; $\hat A$: advantage estimate.

Observation tokens remain in context, but not in the generated-action recursion.

The action boundary uses one discount step. Terminal bootstrap and continuation are zero.

SAO §3.2, Eqs. 4–5 · Schulman et al., GAE. Skipping observation positions does not remove environment uncertainty from returns.
Backup · SAO

Long-horizon training infrastructure

ComponentWhat changesEvidence boundary
SAOSingle rollouts, DIS, critic training
and observation-skipping GAE
Qwen3-30B-A3B study;
not a GLM optimizer ablation
slimeMegatron training, SGLang rollouts,
buffer and environment interfaces
Training infrastructure;
not an advantage estimator
CompactionVariable-count, variable-length
sub-trajectories in long tasks
GLM release training design;
not isolated by the paper's tables
IndexShareReuse sparse-attention indices
across four layers
Architecture / inference efficiency;
not recurrent-depth weight sharing

SAO paper: 128k budget; math ≤50 turns, coding ≤300 OpenHands turns.
Math evaluation repeats: 16 for AIME / HMMT / IMOAnswerBench, 4 for BeyondAIME.

Opening · continuity with days 1–2

Reward sources and costs in LLM post-training

Bootcamp session
Same object, here
What changes
Day 1 · Tabular RL, discrete MDPs
Token MDP: $\mathcal{S}=\mathcal{V}^{\le T}$, $\mathcal{A}=\mathcal{V}$
$|\mathcal{A}|\sim10^5$; one episode = one answer
Day 2 · Policy gradients, actor-critics
$\nabla_\theta J=\E[\nabla_\theta\log\pi_\theta\,A^\pi]$, unchanged
One terminal scalar over $10^3$–$10^5$ tokens: credit assignment
Day 2 · The ATC tournament
You designed $r$, $\mathcal{O}$, $P$
Environment design is the frontier of agentic RL
Day 1 · Kain (CERN)
RL on a real instrument
~350 iterations ≈ 30 min of beam time — the verifier is the machine
Day 2 · Bowling
What should a model model?
A surrogate, when the verifier is expensive
Day 2 · Ortner
Satisficing over maximizing
pass@1 is reliability; pass@$k$ is capability
Claim
Agentic AI is applied RL under a large verifier-cost asymmetry. Proposing is cheap; verifying dominates — and in science, verifying is the experiment.
Program: 3rd International RL Bootcamp, PLUS Salzburg, 16–18 Sept 2026 · sarl-plus.github.io/RL-Bootcamp2026 · beam-time anchor: Kain et al., Sample-efficient RL for CERN accelerator control, Phys. Rev. Accel. Beams 23:124801, 2020, §III.B. Sources: [79].
Part I · backup · terminology

An agent is a policy whose actions change the state it will next observe.

Not a slogan — a checklist. Four properties are needed before the word carries information, and the missing property tells you which failure mode a system has.

Working definition

A system is agentic to the extent that it is a policy $\pi$ acting in an environment: it emits actions $a_t$ with external effects, receives observations $o_{t+1}$ that depend on those actions, carries state across steps, and terminates against a goal. Formally, a POMDP $(\S,\A,\mathcal{O},P,r,\gamma)$ — the object from Day 1, with $\S$ hidden.

Why the definition earns its keep

Each property is an experiment you can run: perturb the environment, check whether behaviour changes. Systems that fail the test do not need RL, and RL cannot help them.

System
Acts
State
Feedback
Trained as policy
Single LLM call
no
no
no
no
Prompt chain / RAG
no
partial
no
no
Tool-calling workflow
yes
partial
partial
no
Scaffolded model (harness)
yes
yes
yes
no
RL-trained agent
yes
yes
yes
yes
Classical control policy
yes
yes
yes
yes
Consequence
Rows 4 and 5 differ only in who optimized the policy: a prompt engineer, or a gradient. Everything in Parts III and V is about moving the boundary between those two rows.
POMDP formulation as in Kaelbling, Littman & Cassandra, Planning and acting in partially observable stochastic domains, Artificial Intelligence 101(1–2), 1998. Sources: Kaelbling et al..
Part I · 1.1 the reduction, exactly

Policy gradients for the token-level MDP

MDP object
Language model
state $s_t$
$(x,\,y_{<t})$ — prompt + prefix
action $a_t$
token $y_t\in\mathcal{V}$, $|\mathcal{V}|\sim10^5$
policy
$\pit(y_t\mid x,y_{<t})$ — the softmax
transition $P$
concatenation — deterministic
reward
$R(x,y)$ at $t=T$ — a model or a verifier
horizon
finite $T$; $\gamma=1$
$$\log\pit(y\mid x)=\sum_{t=1}^{T}\log\pit(y_t\mid x,y_{<t})$$ A sum of per-step terms — what the score-function estimator needs.
$$\nabla_\theta J(\theta)=\E_{\tau\sim\pit}\Big[\textstyle\sum_{t}\nabla_\theta\log\pit(y_t\mid x,y_{<t})\,\adv_t\Big]$$ The Day-2 estimator. Only $\adv_t$ is contested from here on.
  • +
    Deterministic dynamics → no environment model
  • +
    Known likelihood → importance ratios for free
  • One scalar after $10^3$–$10^5$ decisions → credit assignment breaks
Correspondence as tabulated in Shen et al., A First-Principles Derivation of LLM Policy Optimization, arXiv:2606.16733, Tab. 2 · estimator: Sutton et al., Policy Gradient Methods, NeurIPS 1999. Sources: [2].
Part I · 1.2 the cost model

Verification cost in the reward objective

$$r_t=\underbrace{\mathcal{V}(s_t,a_t)}_{\text{verifier signal}}\;-\;\underbrace{\lambda\,c(a_t)}_{\text{price of obtaining it}},\qquad \mathcal{J}(\pi)=\E_{\tau\sim\pi}\Big[\textstyle\sum_t r_t\Big]$$ $\mathcal{V}$: a program, a model, a simulator or an experiment. $c$: decode-seconds, TPU-days, beam-seconds, furnace-hours.
$$\alpha=\frac{c(\text{verify})}{c(\text{propose})}\;\in\;\big[10^{-5},\,10^{5}\big]$$ Propose: one decode, seconds. Verify: µs for an identity · ~5 s of beam time per iteration (AWAKE) · ~7 h per synthesis target (A-Lab).
Regime
$\alpha\lesssim1$: brute force; only representation matters. $\alpha\gg1$: which experiment to run — experimental design, and the LLM-RL toolbox is not built for it.
Each remaining part, in one variable
Part II
$\mathcal{V}$ is unsound
Part III
$\mathcal{V}$ is binary and sparse
Part IV
$\mathcal{V}$'s soundness decides the metric
Part V
$\mathcal{V}$ must be built
Part VI
$c$ is the experiment
Part VII
Run it
The term everybody drops

Published objectives set $c\equiv0$. Fine where the checker is free — math, code. Not fine where an instrument is involved.

Cost anchors: Kain et al., Sample-efficient RL for CERN accelerator control, Phys. Rev. Accel. Beams 23:124801, 2020 (AWAKE electron line, ≈350 iterations ≈ 30 min of beam time) · Szymanski et al., An autonomous laboratory for the accelerated synthesis of novel materials, Nature 624:86, 2023 (58 targets, 17 days; see Part VI for the correction) · priced in full in Part VI · the cost term follows the sequential-experiment formulation in Chaloner & Verdinelli, Statist. Sci. 10(3), 1995. Sources: [79] · [86] · Chaloner & Verdinelli · correction.
Part I · backup · a consequential fork

Sequence-level bandits and token-level MDPs

Sequence = one arm (bandit)

The reward is a single terminal scalar, so treat the whole response as one action. No per-token value function, no per-token ratio; the baseline is the mean reward of other samples for the same prompt.

  • +
    Matches the unit of the reward; importance weight is a single, well-defined ratio
  • +
    No critic to train, no critic to be wrong
  • No mechanism to distinguish a decisive token from a filler token

RLOO · GSPO · REINFORCE-style group methods

Sequence = $T$ actions (token MDP)

Keep the full MDP: per-token advantages, a value function over prefixes, and credit assignment inside the response. DPO admits a token-level reading as inverse $Q$-learning satisfying a Bellman equation.

  • +
    Credit assignment inside a chain of thought becomes expressible
  • +
    Search over prefixes (MCTS-style) becomes well-defined
  • Per-token ratios are single-sample estimates: variance accumulates over $T$ and clipping amplifies it

PPO-RLHF · token-level DPO · process-reward methods

$$w^{\text{seq}}=\left(\frac{\pit(y\mid x)}{\piold(y\mid x)}\right)^{1/|y|}\quad\text{vs.}\quad w^{\text{tok}}_t=\frac{\pit(y_t\mid x,y_{<t})}{\piold(y_t\mid x,y_{<t})}$$ Same quantity at two granularities; the left one is a deliberately biased surrogate for the sequence-level ratio (see the later GSPO slide), not an unbiased correction.
The reconciliation

The token-level objective is a first-order approximation of the sequence-level objective, exact iff $\pit=\piold$. Every deviation from strict on-policy sampling — mini-batching, asynchronous rollouts, an inference engine with different kernels — makes the approximation worse. Part III is largely a catalogue of that fact.

Ahmadian et al., Back to Basics: RLOO, arXiv:2402.14740 · Rafailov et al., From r to Q*: Your Language Model is Secretly a Q-Function, arXiv:2404.12358 · Zheng et al., GSPO, arXiv:2507.18071 §3.
Part I · 1.3 the post-training objective

Reward maximization with a reference-policy KL penalty

$$\max_{\pit}\ \E_{x\sim\D}\Big[\E_{y\sim\pit(\cdot\mid x)}\big[r(x,y)\big]\;-\;\beta\,\KL\big[\pit(\cdot\mid x)\,\|\,\piref(\cdot\mid x)\big]\Big]$$ $r$: a reward model or a verifier · $\piref$: the SFT checkpoint · $\beta$ prices drift. $\beta=0$ is licence to leave the region where $r$ was ever measured.
$$\pi^\star(y\mid x)=\frac{1}{Z(x)}\,\piref(y\mid x)\,\exp\!\Big(\tfrac{1}{\beta}r(x,y)\Big)$$ An exponential tilt of the reference — equivalently a Bayesian posterior with prior $\piref$ and likelihood $e^{r/\beta}$.
$Z(x)$ is intractable — three ways out
  • 1
    Sample it — PPO, GRPO: Part III
  • 2
    Cancel it — DPO (backup)
  • 3
    Approximate it — best-of-$n$, mirror descent
Two readings

Control: a trust region around where $r$ was fitted. Inference: posterior sampling, not utility maximization.

$$r_t=\underbrace{R(x,y)\,\mathbb{1}[t=T]}_{\text{terminal}}-\beta\log\frac{\pit(y_t\mid x,y_{<t})}{\piref(y_t\mid x,y_{<t})}$$As implemented: the KL inside the per-token reward. Only the last token sees the task.
Ziegler et al., Fine-Tuning Language Models from Human Preferences, arXiv:1909.08593 · Korbak et al., RL with KL penalties is better viewed as Bayesian inference, EMNLP Findings 2022, arXiv:2205.11275 · Rafailov et al., DPO, arXiv:2305.18290 Eq. 4.
Part I · backup · estimating the KL term

Sampled KL estimators: bias, variance and sign

With $\rho=\piref(y_t\mid\cdot)/\pit(y_t\mid\cdot)$ evaluated on samples from $\pit$, three estimators of $\KL[\pit\|\piref]$ are in circulation. They differ in variance and in whether a single sample can come out negative.

k1 · naive
$$-\log\rho$$

Unbiased. High variance, and negative for roughly half of samples — an estimate of a non-negative quantity that is negative half the time is a poor training signal.

k2 · squared log-ratio
$$\tfrac{1}{2}(\log\rho)^2$$

Always non-negative, low variance, biased. Bias vanishes as the policies converge; in practice the bias is small compared to k1's variance.

k3 · the default
$$\rho-\log\rho-1$$

Unbiased and non-negative for every sample, since $\rho-\log\rho-1\ge0$ with equality at $\rho=1$. This is the estimator written into the GRPO objective, and what most frameworks ship.

Where the choice bites

Near the reference ($\rho\approx1$) every estimator is a difference of nearly equal numbers, and the sign-indefinite k1 injects its noise straight into the gradient. Scaling by $\beta$ scales that noise with it — a larger $\beta$ makes the KL term matter more, not the estimator matter less. k3 is bounded below by zero, which is why it survived.

Live disagreement

Whether to keep a KL term at all in verifiable-reward RL is contested: several 2025 recipes (DAPO among them) remove it, arguing the policy is meant to move far from the reference during long-horizon reasoning training. Removing it also removes the only thing bounding the drift.

Schulman, Approximating KL Divergence, 2020 (joschu.net/blog/kl-approx.html) · k3 as used in Shao et al., DeepSeekMath, arXiv:2402.03300 Eq. 4 · KL removal: Yu et al., DAPO, arXiv:2503.14476 §2.3. Sources: [7].
Part I · 1.4 credit assignment

Credit assignment over $10^3$–$10^5$ decisions

$$\adv_t \;=\; \underbrace{\E\big[R(x,y)\mid s_t,a_t\big]-\E\big[R(x,y)\mid s_t\big]}_{\text{what token }t\text{ contributed}}$$ What every estimator in Part III approximates — with a critic, a group baseline, or one number broadcast to all $T$ tokens.
  • 01
    Critics degrade — a policy-sized value head, trained on a reward that exists only at $t=T$
  • 02
    Broadcasting wastes gradient — the decisive step and the whitespace after it get the same credit
  • 03
    An oracle critic can hurt — it penalizes the wrong branch that error-then-recovery needs (Kimi)
The classical answer

Reward redistribution (RUDDER): a dense reward with the same optimal policies, credit given to the steps that shifted the expected return. Largely unexploited in LLM post-training.

ICML 2022 · own work Align-RUDDER: multiple sequence alignment over high-return demonstrations
Align-RUDDER. High-return trajectories aligned as sequences; the consensus profile becomes the redistributed reward. MineRL ObtainDiamond.
The analogy

Chain of thought = demonstration trajectory. Verifier score = delayed return.

Arjona-Medina et al., RUDDER, NeurIPS 2019, arXiv:1806.07857 · Patil, Hofmarcher, Dinu et al., Align-RUDDER, ICML 2022, arXiv:2009.14108 · Team Kimi, Kimi k1.5, arXiv:2501.12599 §2.3.2 · Shao et al., DeepSeekMath, arXiv:2402.03300 §4.1.
Part I · backup · the 2026 post-training stack

In the published 2025–26 pipelines, reinforcement learning appears in three of the five post-training stages.

stage 01
Pre-train

Next-token prediction on $10^{13}$ tokens. Defines the support of everything downstream.

no reward
stage 02
Mid-train / SFT

Format, instruction following, long-context and tool syntax; distillation from a stronger teacher.

imitation
stage 03
Preference RL

Human or AI preferences via a reward model, or offline via DPO-family losses. Style, safety, refusals.

learned reward
stage 04
Verifiable RL

Math, code, formal proof: reward is a checker, not a model. The stage that produced "reasoning models".

programmatic reward
stage 05
Agentic RL

Multi-turn tool use in real environments: browsers, shells, repositories, simulators. Reward at task completion.

environment reward
What moved

2022: one RLHF pass, tiny compute, style objective. 2026: multiple RL stages, a substantial fraction of post-training compute, and objectives that are checkable rather than preferred.

What did not

The estimator. It is still a score-function gradient with a baseline and a trust region. The innovation is on the reward and infrastructure sides.

Why this order

Each stage narrows the distribution the next one explores. RL cannot recover a capability that pre-training never put in the support — which is precisely the Part IV controversy.

Stage taxonomy synthesised from published pipelines: DeepSeek-R1 (arXiv:2501.12948), Qwen3 (arXiv:2505.09388), Kimi k1.5 (arXiv:2501.12599), Tülu 3 (arXiv:2411.15124).
Part I · backup · why not just fine-tune

SFT maximizes the likelihood of a fixed target; RL reweights the model's own samples by a score.

$$\mathcal{L}_{\text{SFT}}=-\E_{(x,y^\ast)\sim\D}\big[\log\pit(y^\ast\mid x)\big]$$ Maximum likelihood of a fixed target: the model is never scored on its own samples, so its own failure modes are never penalized.
$$\nabla_\theta\mathcal{J}_{\text{RL}}=\E_{y\sim\pit}\big[\nabla_\theta\log\pit(y\mid x)\,\adv(x,y)\big]$$ Expectation under the model's own distribution: errors it actually makes get the gradient, weighted by a signal that only has to rank, not to demonstrate.
  • Weaker supervision suffices. A verifier that says yes/no is far cheaper than a demonstration, and exists for whole domains where demonstrations do not.
  • Distribution match. RL optimizes the object you deploy: samples from $\pit$, under the decoding policy you will actually use.
Reported evidence

Generalization: in matched comparisons on rule-based and visual out-of-distribution variants, RL post-training transferred while SFT largely memorized the training format — with the important qualifier that SFT was still needed first to make outputs parseable enough for RL to start.

Forgetting: on-policy RL fine-tuning was found to reach comparable task performance while incurring a smaller KL shift from the base policy than supervised fine-tuning, and correspondingly less degradation on held-out abilities.

Caveats to state out loud

Most such comparisons are (i) on a small number of model families, (ii) at a fixed compute budget that favours one method, and (iii) evaluated with pass@1, which is exactly the metric Part IV shows can move without capability moving. Treat "RL generalizes, SFT memorizes" as a well-supported tendency, not a theorem.

Chu et al., SFT Memorizes, RL Generalizes, arXiv:2501.17161 · Shenfeld et al., RL's Razor: Why Online RL Forgets Less, arXiv:2509.04259 · counter-reading: Part IV of this lecture.
Part I · backup · a reading protocol

Comparing trajectory, reward and infrastructure choices

The 2024–26 methods are easier to compare along three axes than chronologically. Most published variants move one axis and inherit the rest; naming the axis indicates what the method can and cannot fix.

Axis 1 · trajectory side

How do samples enter the update?

Group size $G$, dynamic sampling and difficulty filtering, ratio granularity (token / sequence), clipping asymmetry, loss aggregation over tokens or sequences, staleness tolerance.

GRPO · RLOO · DAPO · GSPO · CISPO

Axis 2 · reward side

What weights the update?

Learned reward model, rule verifier, execution, process reward, rubric or judge; the baseline (critic, group mean, leave-one-out); normalization choices and the biases they inject.

RLHF · RLVR · PRMs · rubric rewards

Axis 3 · infrastructure

Which policy actually produced the data?

The rollout engine and the training engine disagree numerically; rollouts are asynchronous and stale; the "on-policy" objective is silently off-policy. Staleness was known in classical distributed RL (IMPALA's V-trace); the engine mismatch is new.

truncated IS · async RL · partial rollouts

Use it now
When a result claims "+X points over GRPO", ask which axis moved and whether the baseline was tuned on the same axis. Several reported gains in this literature turn out to be axis-3 discrepancies corrected by an axis-1 change (backup · off-policy by accident).
Axis decomposition after Shen et al., A First-Principles Derivation of LLM Policy Optimization, arXiv:2606.16733, Tabs. 1, 4–6 · infrastructure axis: Yao et al., Your Efficient RL Framework Secretly Brings You Off-Policy RL Training, 2025; Zheng et al., Stabilizing Reinforcement Learning with LLMs, arXiv:2512.01374. Sources: [27] · [26] · [29] · [30] · [31] · 1802.01561 · Yao, off-policy blog.
Part II · 2.1 taxonomy

Reward sources, evaluation costs and failure modes

Source
Who produces the scalar
Cost / call
Fails by
Preference
Reward model fitted to comparisons
1 forward pass
Goodhart — proxy diverges from gold with distance
Verifiable
A program: checker, tests, proof kernel, simulator
ms – hours
Specification — the check passes without the task
Process
Step-level labels (PRM)
1 pass / step
Label validity — "is this step correct" is often undefined
Rubric / judge
LLM scoring against written criteria
1–K generations
Rubric capture — optimize the criteria, not the answer
Heuristic
A learned reward inside an RL loop is an attack surface. A programmatic reward moves the attack to the specification.
Synthesis over: Ouyang et al. arXiv:2203.02155 · Lambert et al. Tülu 3 arXiv:2411.15124 · DeepSeek-AI R1 arXiv:2501.12948 · Lightman et al. arXiv:2305.20050 · Gunjal et al. RaR arXiv:2507.17746.
Part II · backup · the learned-reward pillar

The latent scalar-utility assumption in RLHF

$$p^\ast(y_w\succ y_l\mid x)=\sigma\big(r^\ast(x,y_w)-r^\ast(x,y_l)\big)$$ Bradley–Terry: a comparison is a logistic function of a difference of scalars. Intransitive or multi-dimensional preferences violate it by construction.
$$\mathcal{L}_R(r_\phi)=-\E_{(x,y_w,y_l)\sim\D}\big[\log\sigma\big(r_\phi(x,y_w)-r_\phi(x,y_l)\big)\big]$$ Reward-model fit: binary classification on pairs. Note what is not here — any notion of calibration off the annotated distribution.
$$\max_\theta\ \E_{x\sim\D,\,y\sim\pit}\big[r_\phi(x,y)\big]-\beta\,\KL\big[\pit\,\|\,\piref\big]\;+\;\gamma\,\E_{x\sim\D_{\text{pre}}}\big[\log\pit(x)\big]$$ The InstructGPT objective, including the PPO-ptx term $\gamma$: pretraining gradients mixed in to limit the alignment tax.
Four models in memory

Actor $\pit$ (updated), critic $V_\psi$ (updated), reward model $r_\phi$ (frozen), reference $\piref$ (frozen). The critic scores partial generations, the reward model scores complete ones — they are different objects and are routinely conflated.

What the reward model cannot do

Reward models are trained on comparisons drawn from a narrow policy. Once RL moves the policy, the model is evaluated off its training distribution — and its accuracy there is not measured by the validation loss that was used to select it. Ranking accuracy of most preference-tuned models is below 60 %, and correlates with win rate only near $\piref$.

Ouyang et al., Training LMs to Follow Instructions with Human Feedback, arXiv:2203.02155 Eqs. 1–2 · Bradley & Terry 1952 · ranking accuracy: Chen et al., Preference Learning Algorithms Do Not Learn Preference Rankings, arXiv:2405.19534 §3.1, §4–5. Sources: Bradley & Terry.
Part II · 2.2 measured overoptimization figure: schematic

Fitted overoptimization laws for best-of-$n$ and RL

$$R_{\text{bo}n}(d)=d\big(\alpha_{\text{bo}n}-\beta_{\text{bo}n}\,d\big),\qquad R_{\text{RL}}(d)=d\big(\alpha_{\text{RL}}-\beta_{\text{RL}}\log d\big)$$ $R$ = gold score against $d=\sqrt{\KL(\pi\,\|\,\pi_{\text{init}})}$; fitted at $n\le1000$, validated out to $n=60{,}000$.
  • Best-of-$n$ is KL-cheap: $\KL_{\text{bo}n}=\log n-\tfrac{n-1}{n}$
  • RL is not: KL grows ~quadratically in steps — a poor common currency
  • The KL penalty is early stopping: it does not move the KL–gold frontier
Engineering reading

Overoptimization is a budget: from the proxy-RM size, predict the distance where gold peaks — and stop there.

Gao, Schulman & Hilton, Scaling Laws for Reward Model Overoptimization, ICML 2023, arXiv:2210.10760 §2 (boxed Eqs.), §3.1 (out-of-sample validation), §3.5–3.6, §4.3 · BoN KL identity: Stiennon et al. 2020, App. G.3. Sources: [9].
Part II · backup · documented exploits

Each reward source in this table has at least one documented exploit.

Exploit
Reward source
Measured instance
Mitigation used
Length inflation
preference RM
Length explains a large majority of PPO's apparent reward gain in controlled studies; DPO roughly doubles output length on standard chat data
length-debiased RM, R-DPO, SimPO
Sycophancy
preference RM
Five assistants, four free-form tasks: responses matching the user's stated view are preferred — by humans and by preference models
no established mitigation; it is in the data
Empty compliance
constraint verifier
Tülu 3 at $\beta=0.01$: content-free paragraph skeletons that satisfy the format verifier exactly
KL floor, mixed objectives
Format-only gain
format-only reward (no answer check)
Rewarding "contains a \boxed{}" alone, with no correctness check: +13.8 AMC, +10.3 AIME24 on Qwen2.5-Math-7B — a confounded baseline, not a defeated checker
format-only control arm; cross-family replication
Judge attacks
LLM judge / generative RM
Single-symbol and gibberish responses accepted; learned verifiers collapse under RL pressure at a few hundred steps
ensembles, K-sample voting
Test manipulation
unit tests
Code RL agents edit or weaken the tests instead of the implementation; detectable in chain-of-thought monitors far more reliably than in actions alone
immutable tests, held-out suites
The general statement

A learned reward inside an RL loop is an attack surface; a programmatic reward moves the attack to the specification. Neither removes the problem — they relocate it to where you can or cannot audit it.

Singhal et al. arXiv:2310.03716 §5 (PPO length share) · Park et al. arXiv:2403.19159 §4.2 (DPO length doubling) · Sharma et al. arXiv:2310.13548 (sycophancy) · Lambert et al. Tülu 3 arXiv:2411.15124 §6, Fig. 28 · Shao et al. arXiv:2506.10947 · learned-verifier collapse: Huang et al. arXiv:2505.22203 §5.2 · Baker et al. arXiv:2503.11926.
Part II · backup · removing the reward model

DPO: closed-form preference objective

$$\pi_r(y\mid x)=\tfrac{1}{Z(x)}\piref(y\mid x)e^{r(x,y)/\beta} \;\Longleftrightarrow\; r(x,y)=\beta\log\frac{\pi_r(y\mid x)}{\piref(y\mid x)}+\beta\log Z(x)$$ Move 1–2: the optimum of the KL-regularized problem, and its inversion. Every reward has a policy; every policy implies a reward.
$$p^\ast(y_w\succ y_l\mid x)=\sigma\big(\hat r(x,y_w)-\hat r(x,y_l)\big),\qquad \hat r(x,y)=\beta\log\tfrac{\pi^\ast(y\mid x)}{\piref(y\mid x)}$$ Move 3: substitute into BT. The preference depends only on a difference, so $\beta\log Z(x)$ cancels — the intractable term disappears without approximation.
$$\mathcal{L}_{\text{DPO}}=-\E_{(x,y_w,y_l)}\left[\log\sigma\!\left(\beta\log\frac{\pit(y_w\mid x)}{\piref(y_w\mid x)}-\beta\log\frac{\pit(y_l\mid x)}{\piref(y_l\mid x)}\right)\right]$$ Move 4: replace $\pi^\ast$ by $\pit$ and minimize the negative log-likelihood. No rollouts, no critic, no reward model.
What DPO actually is

With implicit reward $\hat r_\theta(x,y)=\beta\log\frac{\pit(y\mid x)}{\piref(y\mid x)}$, the DPO loss is the reward-model loss — fitted in a family whose optimal policy is the model itself. Theorem 1 of the paper shows the parameterization is lossless: it fixes the gauge freedom $r\mapsto r+f(x)$ by selecting the normalized representative.

The gradient tells the story
$$\nabla_\theta\mathcal{L}_{\text{DPO}}=-\beta\,\E\big[\,\underbrace{\sigma(\hat r_l-\hat r_w)}_{\text{weight}}\;\big(\nabla_\theta\log\pit(y_w)-\nabla_\theta\log\pit(y_l)\big)\big]$$

A contrastive update with an adaptive weight that vanishes once the pair is confidently ranked — which is also why DPO struggles to flip pairs the reference already ranks wrongly.

Rafailov et al., Direct Preference Optimization, NeurIPS 2023, arXiv:2305.18290 Eqs. 3–7, Thm. 1, App. A.1–A.4 · flip-failure analysis: Chen et al., arXiv:2405.19534 §4.1–4.2.
Part II · backup · one loss, six modifications

Direct-alignment objectives and inherited limitations

Method
What it changes
Why
Residual failure
IPO
Replaces the logistic link with a squared loss on the log-ratio gap
Under near-deterministic preferences $\sigma^{-1}(p)\to\infty$ and the KL term stops binding; IPO regularizes the gap directly
Needs $\tau$ tuning; still offline
KTO
Drops pairs: per-example desirable/undesirable labels, prospect-theoretic value
Paired preference data is expensive; unpaired signals are abundant
Reference point is a hyper-parameter
ORPO
Removes $\piref$; adds an odds-ratio penalty to the SFT loss
One stage, no reference model in memory
No explicit trust region at all
SimPO
Length-normalized implicit reward, reference-free, target margin
Aligns the training objective with the length-normalized decoding metric
Margin is dataset-specific
cDPO / rDPO
Models label noise explicitly with a flip rate $\epsilon$
Human labels disagree at rates of 25–40 % on hard pairs
Requires an estimate of $\epsilon$
R-DPO
Adds an explicit $\alpha|y|$ length regularizer
Makes the length confound a term rather than an artefact
Trades length for content quality
Iterative / online DPO
Regenerates preference pairs from the current policy each round
Repairs the core defect: offline data is drawn from $\piref$, not $\pit$
Re-introduces sampling cost and a judge
Pattern
Five of the seven variants are fixes for artefacts of offline data or the length confound. The seventh removes the offline assumption — and lands back in the RL loop it was meant to avoid.
Azar et al. IPO arXiv:2310.12036 · Ethayarajh et al. KTO arXiv:2402.01306 · Hong et al. ORPO arXiv:2403.07691 · Meng et al. SimPO arXiv:2405.14734 · Chowdhury et al. rDPO arXiv:2403.00409 · Park et al. R-DPO arXiv:2403.19159.
Part II · backup · the sampling distribution matters

Offline and on-policy preference optimization

The theoretical statement

$\Pi_{\text{PPO}}\subsetneq\Pi_{\text{DPO}}$: every solution of the KL-regularized RL problem is a DPO solution, but not conversely. DPO can assign probability mass to responses never observed in the preference data, because nothing in the loss constrains behaviour off the annotated pairs.

The empirical statement

On competitive programming (CodeContest), a verifiable domain with no judge in the loop, the PPO-trained policy reaches 22.4 % 10@1k against the previous state of the art (AlphaCode-41B with clustering, 16.4 %) — while in the same study the DPO family collapses to 0.0 % (DPO) and 3.2 % (iterative DPO).

Mechanism

On-policy sampling makes the model's own current errors the training signal. Offline data makes someone else's errors the training signal — and those become less relevant with every gradient step.

Mode-seeking versus mode-covering

Reverse-KL-regularized on-policy training is mode-seeking: it concentrates on a subset of good behaviours. Maximum-likelihood-style offline objectives are mode-covering: they spread mass, including onto low-quality modes present in the data.

Read the comparisons carefully

PPO-versus-DPO results are extremely protocol-sensitive: reference model, data source, epoch count, and whether the preference data was generated by the same policy being trained. A study that reuses public offline pairs is testing a different question from one that regenerates pairs on-policy.

Practical
Where a verifier exists, this whole debate is moot: skip preference learning and optimize the verifier. That is Part II's hinge.
Xu et al., Is DPO Superior to PPO for LLM Alignment? A Comprehensive Study, ICML 2024, arXiv:2404.10719 §3–5 · Tajwar et al., arXiv:2404.14367 (mode-seeking) · Tang et al., arXiv:2405.08448 (online–offline gap).
Part II · 2.3 the verifiable-reward pillar

RLVR: programmatic rewards

$$r=\mathcal{V}(x,y)\in\{0,1\},\qquad \mathcal{J}(\theta)=\E_{x\sim\D}\Big[\E_{y\sim\pit(\cdot\mid x)}\big[\mathcal{V}(x,y)\big]\Big]$$ $\mathcal{V}$: an answer checker, a compiler, a test suite, a proof kernel. Deterministic, auditable, cheap to run millions of times.
R1-Zero's entire reward

Accuracy — rule-based check of the final answer. Format — the reasoning inside the required tags. No reward model, no PRM, no MCTS.

Their reason for refusing PRMs

"Once a model-based PRM is introduced, it inevitably leads to reward hacking."

15.6→77.9
AIME 2024 pass@1
R1-Zero, base → RL; 86.7 with cons@16
101k
H800 GPU-hours
≈ $202k at $2/GPU-h
0
learned reward models
in the reasoning RL stage
"Aha", operationalized

A sudden rise in the frequency of the token "wait" — and response length growing without being rewarded.

Cite carefully

Nature version: 77.9 %. Preprint: 71.0 %, same curve.

DeepSeek-AI, DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via RL, arXiv:2501.12948 §2.2, Tab. 2–3, Suppl. Figs. 6, 9b; Nature version 2025 · RLVR formulation: Lambert et al., Tülu 3, arXiv:2411.15124 §6.
Part II · 2.4 the central table

Verifier coverage, cost and claim strength

Verifier
Cost
Gameable?
Characteristic error
Answer extraction
~0
high
Format alone earns reward: +10.3 AIME24 with no correctness check
Math checker
~0
low
High precision, incomplete: recall 0.78–0.92
Unit tests
low–med
medium
Coverage gaps, flaky tests — and agents edit the tests
Proof kernel
med + search
≈ none
Sound — but autoformalization in front of it is ~60 %
LLM judge
med
high
Gibberish attacks; collapses under RL pressure in a few hundred steps
The asymmetry
Sound but incomplete costs recall. Complete but unsound costs the experiment. If you cannot say what a wrong reward costs you, you are not ready to run RL.
Anchors: Shao et al. arXiv:2506.10947 · verifier robustness and math-checker recall: Huang et al., From Accuracy to Robustness: Rule- and Model-based Verifiers in Mathematical Reasoning, arXiv:2505.22203 §3.2, Figs. 2–3, §5.2 · autoformalization rates: Hubert et al., Olympiad-level formal mathematical reasoning with RL (AlphaProof), Nature 651:607–613, 2026 (online 2025-11-12). Sources: [75].
Part II · backup · the dense-signal pillar

Process supervision in reranking and RL

Where it works

Step-level supervision beats outcome supervision for selecting among candidate solutions: 78.2 % versus 72.4 % of MATH test problems solved when reranking with a process- versus outcome-supervised reward model. The PRM800K dataset — 800k step-level human labels — is the reference artefact.

Automating the labels

Math-Shepherd replaces human annotation with Monte-Carlo rollout estimates of step correctness, making PRMs cheap. The lesson from later analyses: those labels measure completability, not correctness, and the two come apart precisely on the steps that matter.

Why it lost as a reward — in those pipelines

DeepSeek-R1 lists PRMs under unsuccessful attempts: step definition is unclear, labels do not scale, and "once a model-based PRM is introduced, it inevitably leads to reward hacking". Math-Shepherd itself reports step-level PPO gains — the claim is about frontier-scale RL, not about PRMs as such.

Read this pair

A benchmark that looks discriminative (BoN, 61.6–69.3 across all models) hides a spread from 9.7% to 58.1% — a range — in the ability these models were built for; choosing a PRM by BoN score selects almost at random. Today PRMs survive as inference-time rerankers and step-level error localizers, not as RL reward functions.

Lightman et al., Let's Verify Step by Step, arXiv:2305.20050 §3, Fig. 3 (best-of-1860, 500-problem MATH subset) · Wang et al., Math-Shepherd, arXiv:2312.08935 · Zhang et al., The Lessons of Developing Process Reward Models in Mathematical Reasoning, arXiv:2501.07301 Tabs. 5–6 · DeepSeek-AI, arXiv:2501.12948 §4.2.
Part II · backup · domains without a checker

Rubric rewards, generative reward models and reward hacking

Rubrics as reward

Write explicit, weighted criteria; have a model grade against them; use the aggregate as the scalar. Reported: rubric rewards extend RLVR-style training into medicine and science and improve alignment with human preferences across scales, with expert-written guidance crucial for synthetic rubric quality.

Rubicon: with only ~5k training samples, +5.2 points absolute on open-ended benchmarks for a 30B MoE, and +2.4 points over a 671B reference model on those benchmarks — self-reported.

Generative reward models

Let the reward model reason before scoring, and scale it at inference: principle generation plus critique, with voting over samples. DeepSeek-GRM reports 69.9 greedy → 71.0 at voting@32 → 72.8 with a meta-reward model — inference-time scaling applied to the reward, not the policy.

Two candid negatives worth repeating

Seesaw effect: jointly training strict constraint-following and open-ended creativity reduces overall performance — conflicting objectives, mitigated only by stage-wise training.

Rapid hacking: reward hacking emerged early enough to require an offline analysis of anomalously high-reward rollouts, distillation of the recurring patterns into a dedicated reward-hacking-defence rubric, and its insertion as a veto constraint in all later stages.

What this tells us

A veto constraint is a confession: linear scalarization of criteria is hackable, so the fix is a hard filter rather than a better weight. Expect the same pattern anywhere a learned judge sits inside the loop.

Gunjal et al., Rubrics as Rewards, arXiv:2507.17746 (numbers are version-dependent between the arXiv and camera-ready versions — check which you cite) · Huang et al., Reinforcement Learning with Rubric Anchors (Rubicon), arXiv:2508.12790 §3.2, §4.1, §4.4 · Liu et al., DeepSeek-GRM / SPCT, arXiv:2504.02495 Tabs. 2–3.
Part II · backup · a decision procedure

Choosing rewards by checkability, horizon and error cost

Situation
Horizon
Use
Because
Watch for
Outcome is programmatically checkable
single-turn
RLVR
Reward is the objective; unlimited cheap evaluations
Format exploits; unsound checkers
Checkable only at the end of a long task
multi-turn
RLVR + turn-level shaping
Terminal-only credit over 10²–10³ actions is too sparse
Shaping that changes the optimum
Quality is a matter of taste or style
single-turn
preference RM or DPO-family
No checker exists; comparisons are cheap to collect
Length, sycophancy, overoptimization
Domain expertise defines "good"
single-turn
rubric / generative RM
Criteria can be written down even when a checker cannot
Rubric capture; needs a veto rule
Evaluation is expensive and irreversible
any
not RL first
Bayesian optimization / active learning dominate at low sample counts
See Part VI for the crossover
Question three

What does a wrong reward cost? If the answer is a poor chat response, train and iterate. If it is a retracted paper, damaged beam time, or a synthesized compound, the verifier should be validated before it is optimized — and that validation is itself a research task.

Bridge to Part III

All of Part II fixed what weights the update. Part III is about how the samples enter — where the last three years of algorithmic work actually happened.

Decision structure synthesised from the sources cited across Part II; the BO/active-learning crossover is quantified in Part VI (Kaiser et al., Sci. Rep. 14:15733, 2024; Xian et al., npj Comput. Mater. 11:143, 2025). Sources: [101] · [102].
Part III · backup · the PPO baseline

PPO clipping and trust regions

$$\mathcal{J}_{\text{PPO}}(\theta)=\E\Big[\tfrac{1}{|y|}\textstyle\sum_t\min\big(\rho_t\adv_t,\ \clip(\rho_t,1-\varepsilon,1+\varepsilon)\adv_t\big)\Big],\quad \rho_t=\frac{\pit(y_t\mid x,y_{<t})}{\piold(y_t\mid x,y_{<t})}$$ Token-level ratio, token-level clip, advantage from GAE on a learned value head.
$$\eta(\tilde\pi)\ \ge\ L_\pi(\tilde\pi)-C\max_s\KL\big[\pi(\cdot\mid s)\,\|\,\tilde\pi(\cdot\mid s)\big],\qquad C=\frac{4\epsilon\gamma}{(1-\gamma)^2}$$ What TRPO proves: a monotonic-improvement lower bound. PPO keeps the intuition and drops the bound — the clip constrains a ratio, not a KL, and only for sampled tokens.
Consequences of the gap

No monotonicity guarantee; behaviour depends on $\varepsilon$, on how many inner epochs are run per rollout ($\mu$), and on whether the sampler matches the trainer. All three are engineering choices that the theory does not cover.

Model in memory
Updated?
Scores
Actor $\pit$
yes
Critic $V_\psi$
yes
partial generations
Reward model $r_\phi$
frozen
complete responses
Reference $\piref$
frozen
KL anchor
Why the critic is the problem

It must match the actor in capacity, is trained from a reward that exists only at $t=T$, and is hard to make accurate per token when only the last token carries a reward. That is DeepSeekMath’s stated reason for removing it — not memory alone.

Schulman et al., PPO, arXiv:1707.06347 Eq. 7 · Schulman et al., TRPO, ICML 2015, arXiv:1502.05477 Thm. 1 (bound and constant $C$) · critic critique: Shao et al., DeepSeekMath, arXiv:2402.03300 §4.1. Sources: [5].
Part III · 3.2 the dominant family

GRPO: critic-free, group-relative policy updates

$$\begin{aligned}\mathcal{J}_{\text{GRPO}}(\theta)=\E\Big[\tfrac1G\textstyle\sum_{i=1}^{G}\tfrac{1}{|o_i|}\sum_{t}\big\{&\min\big[\rho_{i,t}\adv_{i,t},\ \clip(\rho_{i,t},1\pm\varepsilon)\adv_{i,t}\big]\\[-1pt]&-\ \beta\,\mathbb{D}_{\text{KL}}\big[\pit\|\piref\big]\big\}\Big]\end{aligned}$$
$$\adv_{i,t}=\frac{r_i-\operatorname{mean}(\mathbf{r})}{\operatorname{std}(\mathbf{r})},\qquad \mathbf{r}=\{r_1,\dots,r_G\}$$ One scalar per response, broadcast to every token. No credit within the sequence.
$$\mathbb{D}_{\text{KL}}\big[\pit\|\piref\big]=\delta-\log\delta-1,\qquad \delta=\frac{\piref(o_{i,t}\mid\cdot)}{\pit(o_{i,t}\mid\cdot)}$$ k3, in the loss — not folded into the reward.
  • =
    REINFORCE with a group-mean baseline — RLOO up to $G/(G-1)$
  • KL
    k3 estimator in the loss, not in the reward — the advantage stays clean
  • !
    The two normalizers change the objective — length and std biases (backup)
Original setup

$G=64$, one update per rollout ($\mu=1$). GSM8K 82.9→88.2, MATH 46.8→51.7, DeepSeekMath 7B.

Shao et al., DeepSeekMath, arXiv:2402.03300 Eqs. 3–4, §4.1.2 · DeepSeek-AI, R1, arXiv:2501.12948 / Nature 2025 (response-level form) · RLOO equivalence: Ahmadian et al., arXiv:2402.14740.
Part III · backup · a bias audit

How reward and length normalization change loss weighting

Bias 1 · response-level length

With $\adv>0$ (correct), dividing by $|o_i|$ gives larger updates to shorter responses. With $\adv<0$ (incorrect), longer responses are penalized less. Net effect: correct answers get shorter, wrong answers get longer.

This is the mechanism behind "GRPO grows response length": at least partly an optimization artefact, not emergent deliberation.

Bias 2 · question-level difficulty

Dividing by $\operatorname{std}(\mathbf r)$ per question up-weights questions whose rewards are nearly all 0 or nearly all 1 — exactly the uninformative ones. Batch-level normalization would not do this; question-level normalization does.

$$\mathcal{J}_{\text{Dr.GRPO}}=\E\Big[\tfrac1G\textstyle\sum_i\sum_t\min\big[\rho_{i,t}\tilde A_i,\ \clip(\rho_{i,t},1\pm\varepsilon)\tilde A_i\big]\Big],\quad \tilde A_i=r_i-\operatorname{mean}(\mathbf r)$$ The fix is two deletions — and recovers the PPO objective with a Monte-Carlo advantage and an unbiased baseline.
the entire implementation diff
def masked_mean(tensor, mask, dim):
-   return (tensor * mask).sum(dim) / mask.sum(dim)
+   return (tensor * mask).sum(-1) / MAX_TOKENS
Two deflationary findings from the same paper

Template, not RL. Qwen2.5-Math-7B average: R1 template 0.0, Qwen template 26.5, no template 38.2. A prompt-format choice moves the score more than most RL ablations.

"Aha" is not emergent. Self-reflection keywords are present in base models, including DeepSeek-V3-Base, before any RL — measured over 40,000 responses; nearly half the self-reflecting responses are no more accurate than the rest.

Counter-result

Removing $\operatorname{std}$ trades bias for variance; on Qwen3 base models at small reward scale, group-level normalization is reported to be the most stable choice. Method choices here are not universal.

Liu et al., Understanding R1-Zero-Like Training: A Critical Perspective (Dr. GRPO), arXiv:2503.20783 Eq. 3, Tabs. 1–2, 4–5, App. A · counter-result: Lite PPO, arXiv:2508.08221 §4.
Part III · backup · what closing a 17-point gap took

Naive GRPO scored 30 on AIME. The same estimator with four fixes scored 50.

$$\begin{aligned}\mathcal{J}_{\text{DAPO}}=\E\Big[\underbrace{\tfrac{1}{\sum_i|o_i|}}_{\text{3 · token-level}}\textstyle\sum_i\sum_t\min\big(&\rho_{i,t}\adv_{i,t},\\[-1pt]&\clip(\rho_{i,t},1-\underbrace{\varepsilon_{\text{lo}}}_{1},1+\underbrace{\varepsilon_{\text{hi}}}_{1})\adv_{i,t}\big)\Big]\end{aligned}$$ with $\varepsilon_{\text{lo}}=0.2$, $\varepsilon_{\text{hi}}=0.28$ (trick 1) and subject to $0<|\{o_i:\texttt{correct}\}|<G$ — trick 2, dynamic sampling. KL is removed entirely.
  • 1
    Clip-higher ($\varepsilon_{\text{low}}{=}0.2$, $\varepsilon_{\text{high}}{=}0.28$): symmetric clipping caps low-probability exploration tokens far more tightly than high-probability exploitation tokens.
  • 2
    Dynamic sampling: drop all-correct and all-wrong groups — their advantage is identically zero, so they contribute noise and no gradient.
  • 3
    Token-level loss: normalize by total tokens in the batch, not per response — long low-quality samples can then be penalized properly.
  • 4
    Soft overlong punishment: a graded length penalty in a cache band instead of a hard truncation, so a sound-but-long proof is not scored as wrong.
Author's own caveat

"The final reward on the training set often exhibits little correlation with the accuracy on the validation set" — i.e. overfitting to the training set is visible in their own runs.

Yu et al., DAPO: An Open-Source LLM Reinforcement Learning System at Scale, arXiv:2503.14476 Eqs. 12–13, Tab. 1; hyper-parameters §4.1.
Part III · backup · a counter-result

Techniques do not compose additively: in one study a two-technique recipe outperformed a six-technique one.

The Lite PPO recipe

Exactly two modifications to the critic-free PPO loss: (i) advantage normalization with a group-level mean and a batch-level standard deviation; (ii) token-level loss aggregation. Reported to outperform the six-technique DAPO recipe and GRPO on their models.

  • Clip-higher helps aligned models and can damage base models. Base models operate at a policy clipping rate around 0.003 — there is almost nothing to unclip.
  • Which tokens get clipped is linguistic: at $\varepsilon_{\text{high}}=0.2$ clipping concentrates on connectives — "therefore", "if", "but"; raising it to 0.28 shifts clipping toward high-frequency function words.
  • Std-normalization hurts on easy data: a small denominator amplifies gradients on extreme-difficulty items and can trigger gradient explosions.
How to read any of these ablations

Model family, alignment state, reward scale, response-length cap and data difficulty all flip the sign of individual tricks. The DAPO ladder is a Qwen2.5-32B-base result; the Lite PPO result is Qwen3-4B/8B. Neither generalizes by default.

Reporting caveat

The Lite PPO paper reports training curves, not tables: there is no numeric results table to quote. Any bar chart of its results would be fabricated — which is why this slide has none.

Rule
Before adopting a trick, ask which model family and alignment state it was measured on, and whether the paper's baseline received the same tuning budget.
Lite PPO / "the tricks that matter" study, arXiv:2508.08221 §3–5 (Qwen3-4B/8B, base and aligned; ROLL framework; results reported as Figs. 3–15).
Part III · backup · matching the unit of the reward

GSPO sequence-level importance sampling

$$s_i(\theta)=\left(\frac{\pit(y_i\mid x)}{\piold(y_i\mid x)}\right)^{1/|y_i|}=\exp\!\left(\frac{1}{|y_i|}\sum_{t}\log\frac{\pit(y_{i,t}\mid x,y_{i,<t})}{\piold(y_{i,t}\mid x,y_{i,<t})}\right)$$ Length-normalized sequence ratio. Without the exponent, a few tokens can swing the whole ratio and responses of different lengths need different clip ranges.
$$\mathcal{J}_{\text{GSPO}}(\theta)=\E\Big[\tfrac1G\textstyle\sum_i\min\big(s_i(\theta)\adv_i,\ \clip(s_i(\theta),1-\varepsilon,1+\varepsilon)\adv_i\big)\Big]$$ Clip ranges here differ from GRPO's by orders of magnitude — the two $\varepsilon$ are not comparable quantities.
Be precise about what it is

$s_i=\exp(\overline{\log w})$ is a geometric mean of per-token ratios, not the sequence importance weight $\prod_t w_t$. GSPO is a deliberately biased surrogate chosen for bounded variance — the paper argues from variance, not from unbiasedness.

The diagnosis it starts from

GRPO's per-token ratio is computed from a single sample of each next-token distribution. With $N=1$ it cannot perform distribution correction; it injects high-variance noise that accumulates over sequence length and is amplified by clipping.

Why MoE made this urgent

In a sparse mixture-of-experts model, a small parameter update can change which experts are routed, so per-token likelihood ratios move discontinuously between rollout and update. Sequence-level ratios average that away; the alternative was Routing Replay, i.e. pinning the routing.

GSPO-token

A variant that restores per-token advantages while remaining numerically identical to GSPO when all tokens in a response share one advantage — the hook for multi-turn and tool-use settings in Part V.

Zheng et al., Group Sequence Policy Optimization, arXiv:2507.18071 §3–4 (Qwen3; ratio definition Eq. 7, objective Eq. 5, GSPO-token §4.3).
Part III · backup · clip the weight, not the gradient

Clipping removes the gradient from rare tokens — reported to be the reflection markers in long reasoning traces.

The observation

Tokens with large importance ratios are the ones that were rare under the old policy: reflection markers such as "However", "Recheck", "Wait", "Aha". PPO-style clipping zeroes their gradient contribution — the update systematically discards the tokens that change the trajectory of a proof.

$$\mathcal{J}_{\text{CISPO}}=\E\Big[\tfrac{1}{\sum_i|o_i|}\textstyle\sum_i\sum_t \sg\!\big[\hat w_{i,t}\big]\,\adv_i\,\log\pit(o_{i,t}\mid x,o_{i,<t})\Big]$$ $\hat w_{i,t}=\clip(\rho_{i,t},1-\varepsilon^{\text{IS}}_{\text{low}},1+\varepsilon^{\text{IS}}_{\text{high}})$ is a truncated importance weight under a stop-gradient: every token keeps a gradient, but no token can dominate the batch.

where $\sg[\cdot]$ blocks gradient flow through the weight, $\rho_{i,t}$ is the usual token ratio and $\adv_i$ the group-relative advantage.

Reported evidence

In the MiniMax-M1 report, CISPO reaches the same performance as a DAPO-style baseline in roughly half the training steps in their matched setting, with the full RL run disclosed at $534,700 — an unusually concrete cost disclosure. self-reported

Same disease, two treatments

DAPO widens the clip window; CISPO replaces clipping with weight truncation. Both concede that the vanilla PPO clip is mis-specified for long reasoning traces, and both are bias-for-stability trades.

Interaction effect

MiniMax reports clip-higher was less effective in their setup — 16 off-policy update rounds per generation batch. The number of inner epochs $\mu$ silently changes which trick works.

MiniMax, MiniMax-M1: Scaling Test-Time Compute Efficiently with Lightning Attention, arXiv:2506.13585 §3 (CISPO objective and the token-family observation; cost and step-count claims are the authors').
Part III · backup · an alternative formulation

Mirror-descent targets for policy regression

$$\max_\theta\ \E_{(x,y^\ast)\sim\D}\Big[\E_{(y,z)\sim\pit}\big[r(x,y,y^\ast)\big]-\tau\,\KL\big[\pit(x)\,\|\,\pi_{\theta_i}(x)\big]\Big]$$ $z$ is the chain of thought, $r\in\{0,1\}$ the verifier, $\pi_{\theta_i}$ the reference at outer iteration $i$, $\tau$ the regularization strength.
$$\pi^\ast(y,z\mid x)=\pi_{\theta_i}(y,z\mid x)\,e^{r/\tau}/Z\;\Longrightarrow\; L(\theta)=\E\Big[\big(r-\tau\log Z-\tau\log\tfrac{\pit(y,z\mid x)}{\pi_{\theta_i}(y,z\mid x)}\big)^{2}\Big]$$ Take logs of the closed form, square the residual: the surrogate is a regression onto the optimal policy, with $\tau\log Z$ estimated from the sampled group.
$$\tfrac1k\textstyle\sum_j\Big(\nabla_\theta\log\pit(y_j,z_j\mid x)\,(r_j-\bar r)\;-\;\tfrac{\tau}{2}\nabla_\theta\big(\log\tfrac{\pit(y_j,z_j\mid x)}{\pi_{\theta_i}(y_j,z_j\mid x)}\big)^{2}\Big)$$ The implemented gradient: group-baseline REINFORCE plus an $\ell_2$ proximal term — no ratio, no clip.
Design consequences

The optimizer is reset at each outer iteration, because the reference — and therefore the optimization problem — changes. Length is controlled by an explicit reward term rather than by loss aggregation.

Reported

Long-CoT model: MATH-500 96.2, AIME 2024 pass@1 77.5, LiveCodeBench 62.5, Codeforces percentile 94. RL context window scaled to 128k. self-reported

What is not shown

No ablation isolates the $\ell_2$ proximal term against clipping. The claim "mirror descent beats PPO-clip" is not established by this paper — it is an alternative with a clean derivation.

Team Kimi, Kimi k1.5: Scaling Reinforcement Learning with LLMs, arXiv:2501.12599 Eqs. 2–3, §2.3.3 (length penalty), Tabs. 2–3.
Part III · 3.3 the variance ledger

Inclusive and leave-one-out group baselines

$$r_i-\bar r=\Big(1-\tfrac{1}{G}\Big)\big(r_i-b_i\big),\qquad b_i=\tfrac{1}{G-1}\textstyle\sum_{j\ne i}r_j$$ Leave-one-out, rescaled by $(G-1)/G$ — the learning rate absorbs it.
$$\operatorname{Var}\big(r_i-b_i\big)=\sigma^2\Big(1+\tfrac{1}{G-1}\Big),\qquad \operatorname{se}(\bar r)=\frac{\sigma}{\sqrt{G}}$$ +14 % variance at $G=8$; halving the baseline's error costs the rollouts.
$$\Pr[\text{unanimous}]=(1-p)^{G}+p^{G}\;\Longrightarrow\;\adv_{i}=0\ \ \forall i$$ Binary $r_i$, i.i.d. with $\Pr[r_i{=}1]=p$. Zero variance, zero gradient.
pass@1 $p$
dead groups, $G=8$
consequence
0.50
0.8 %
healthy
0.20
16.8 %
a sixth of the compute buys nothing
0.10
43.0 %
dynamic sampling pays for itself
0.02
85.1 %
the run is dead — Part VII has two at $p=0$
The trade
A critic buys within-sequence credit for a second model. A group buys across-sample variance reduction for $G$ rollouts. No third option demonstrated.
Elementary consequences of the group-relative definition in Shao et al., DeepSeekMath, arXiv:2402.03300 Eq. 3 · leave-one-out equivalence: Ahmadian et al., Back to Basics: RLOO, arXiv:2402.14740 §3 · unanimity filtering as an algorithmic component: Yu et al., DAPO, arXiv:2503.14476 §2.2 (dynamic sampling) · the two dead runs in Part VII had a measured gate pass@1 of exactly 0, below the last row of this table.
Part III · backup · the infrastructure axis

Policy lag and numerical mismatch in rollout training

Source 1 · staleness by design

A rollout batch is split into minibatches: $\mu=B_{\text{train}}/B_{\text{mini}}$ gradient steps are taken against samples from a policy that no longer exists after the first one. DAPO runs $\mu=16$; DeepSeekMath ran $\mu=1$. The same objective at $\mu=1$ and $\mu=16$ is a different algorithm.

Source 2 · the engine mismatch

The rollout engine (vLLM/SGLang, fused kernels, different batching) and the training engine (FSDP/Megatron) assign different probabilities to the same token under the same weights. The policy that generated the data is literally not the policy being updated, even at $\mu=1$.

$$\hat g_{\text{TIS}}=\E_{y\sim\pi_{\text{rollout}}}\Big[\min\Big(\tfrac{\pi_{\text{train}}(y)}{\pi_{\text{rollout}}(y)},\,C\Big)\,\nabla_\theta\log\pi_{\text{train}}(y)\,\adv\Big]$$ Truncated importance sampling: correct for the mismatch, cap the weight at $C$, accept the resulting bias.
Why per-token clipping cannot save you

The sequence weight is a product of $T$ token ratios. If each token contributes a small $\chi^2$ divergence, the variance of the product grows like $(1+\chi^2)^T-1$: exponential in length. Clipping each factor bounds the factors, not the product.

The reproducibility consequence

Two labs running "the same" GRPO can differ by more than any published algorithmic delta, purely through $\mu$, engine pairing, and numerical precision. A published gain of one or two points, without $\mu$ and the engine pair stated, is not interpretable.

Current mitigations

Truncated IS on the rollout/training ratio; matching precision between engines; asynchronous pipelines with explicit staleness bounds; and — the blunt fix that provably removes the discrepancy in reported experiments — running both engines in the same reduced precision.

Qi et al., training–inference mismatch, Eq. 9 · IMPALA / V-trace. Policy lag and numerical scoring mismatch are distinct; the product-of-ratios variance calculation is an illustration under its stated assumptions.
Part III · 3.4 entropy as a budget

Entropy dynamics and fitted performance relationships

$$\mathcal{H}(\pi^{k+1})-\mathcal{H}(\pi^{k})\approx-\eta\operatorname{Cov}_{a\sim\pi^k}\big(\log\pi^k(a\mid s),\;\pi^k(a\mid s)\,A(s,a)\big)$$ Entropy falls whenever advantage correlates with current log-probability — and a verifier rewards what the model already does well.
$$R=-a\,e^{\mathcal{H}}+b$$ Fitted law; the ceiling $R=b-a$ at $\mathcal{H}\to0$ is predictable from early training.
Seen in Part VII

p4-grpo-v1: entropy 0.157 → 0.077, held-out flat. p4-final: entropy 0.335 → 0.491, held-out +8 of 48.

  • Few tokens carry the entropy — the forks that steer the reasoning path
  • Update only the top-20 % entropy tokens: matches full gradients at 8B, +11.0 AIME'25 at 32B
  • Clip-Cov / KL-Cov act on the covariance term, not on ratio magnitude
Consequence

Entropy is a budget to allocate, not a diagnostic to watch. Spent, further RL compute buys nothing.

Cui et al., The Entropy Mechanism of RL for Reasoning Language Models, arXiv:2505.22617 §2.4 (fitted law), §3.2 Thm. 2 (identity, natural-PG form), §4 (Clip-Cov/KL-Cov) · Wang et al., Beyond the 80/20 Rule, arXiv:2506.01939 §4–5.
Part III · backup · summary table

Policy-gradient methods: critics, ratios, advantages and KL

Method
Critic
Ratio unit
Advantage
KL
The one thing it fixes
PPO
yes
token
GAE on $V_\psi$
in reward
Baseline for everything; unstable under binary terminal reward
RLOO
no
sequence
leave-one-out mean
optional
Unbiased baseline without a value net
GRPO
no
token
group mean / std
in loss (k3)
Memory; matches how RMs are trained
Dr. GRPO
no
token
group mean only
none
Length and difficulty bias in the objective
DAPO
no
token
group mean / std, filtered
none
Entropy collapse, zero-gradient groups, length pathologies
GSPO
no
sequence
group mean / std
none
Unit mismatch; MoE routing instability
CISPO
no
token, truncated
group relative
none
Clipping discards the informative tokens
Kimi k1.5 OPMD
no
group mean baseline
$\ell_2$ proximal
Replaces clipping with an exact-solution regression
VAPO / VC-PPO
yes
token
decoupled GAE, pre-trained $V$
in reward
Long-CoT value estimation; when a critic pays for itself
Default
A reasonable starting point for a new verifiable-reward project: group-relative advantages without std-normalization, token-level aggregation, dynamic sampling, an asymmetric clip — and a sequence-level ratio for a mixture-of-experts model.
Rows compiled from the primary objectives cited on the objectives cited in Part III; VAPO: Yue et al., arXiv:2504.05118 (value-pretraining and decoupled GAE for long chains of thought). Sources: [6] · [5] · [26] · [27] · [28] · [29] · [30] · [31] · [32] · 2503.01491.
Part III · backup · the scaling question figure: schematic

Reported RL-compute scaling is saturating rather than power-law, so an ablation stopped early can invert.

$$R_C\;=\;R_0+\frac{A-R_0}{1+\big(C_{\text{mid}}/C\big)^{B}}$$ The sigmoidal fit reported for RL compute scaling: $A$ is the asymptotic pass rate, $B$ the compute-efficiency exponent, and $C_{\text{mid}}$ the compute at which half of the gain $A-R_0$ is realised. Design choices move $A$ and $(B,C_{\text{mid}})$ largely independently.
  • A method that raises $A$ looks worse than one that raises $B$ or lowers $C_{\text{mid}}$ if you stop early — the ordering of two recipes can invert with budget.
  • Entropy exhaustion (Part III · entropy as a budget) is a mechanism for the asymptote: once diversity is spent, additional gradient steps re-weight an ever-narrower support.
  • Reported frontier practice has moved RL from a rounding error to a substantial fraction of post-training compute; the exact fractions are disclosed by very few labs.
Method note

Any claim of the form "method X beats Y" from a single budget is a claim about one point on two curves. Ask for the curve, or at least for two budgets.

Khatri et al., The Art of Scaling Reinforcement Learning Compute for LLMs, arXiv:2510.13786 — §1 Eq. 1 (sigmoidal fit), §2.1 with Fig. 3 (parameter roles), Fig. 2 and App. A.8 with Fig. 13b (small-compute ordering inverts), Tab. 1 (ScaleRL fit $A=0.610$, $B=1.92$, $C_{\text{mid}}=2542$); App. A.4 notes the sigmoid behaves like a power law at high compute. Curves here are illustrative. Entropy mechanism: Cui et al., arXiv:2505.22617 §2.4.
Part IV · 4.1 two objectives, one metric reported

RLVR optimizes pass@1. The capability question is about pass@$k$.

$$p_\theta(x)=\Pr_{y\sim\pit(\cdot\mid x)}\big[\mathcal{V}(x,y)=1\big],\qquad J_1(\theta)=\E_x\big[p_\theta(x)\big]$$ The RLVR objective is pass@1.
$$J_k(\theta)=\E_x\Big[1-\big(1-p_\theta(x)\big)^{k}\Big],\qquad \nabla_\theta J_k=\E_x\Big[\underbrace{k\big(1-p_\theta(x)\big)^{k-1}}_{\text{weight }c_k(x)}\nabla_\theta p_\theta(x)\Big]$$ Down-weights prompts already solved — a curriculum $J_1$ does not have.
$$\widehat{\text{pass@}k}=\E_{x}\left[1-\frac{\binom{n-c}{k}}{\binom{n}{k}}\right]$$ Unbiased, $n$ samples, $c$ correct (Chen et al.).
The asymmetry

pass@1 — reliability under one draw: deployment.
pass@$k$ — does a correct trajectory exist at all: capability.
Discovery can afford many draws: there, $J_k$ is the objective.

The trap

$J_1$ can rise while $J_k$ falls. Report only the first and the two are indistinguishable.

Estimator: Chen et al., Evaluating Large Language Models Trained on Code, arXiv:2107.03374 Eq. 1 · objective decomposition after Yue et al., arXiv:2504.13837 §2.1–2.2 and the diversity-collapse analysis, arXiv:2606.15455 §2.1, §3.1 Eq. 7.
Part IV · 4.2 the crossover, both sides figure: schematic

Base models overtake at large $k$ — until longer RL or a weak-prior domain reverses it.

Mechanism

Boundary prompts: rare correct trajectories too sparse for a finite rollout group — the update pushes mass away. Code is the cleanest instrument: tests are not passed by guessing.

“While RLVR-trained models outperform their base models at smaller values of $k$, base models achieve higher pass@$k$ score when $k$ is large.”

Yue et al., NeurIPS 2025 (oral) — across families, algorithms, math, code and visual reasoning
Reversed by budget · ProRL

KL control + reference resets + multi-domain suite: +54.8% Reasoning-Gym at 1.5B — largest where the base was weakest.

Reversed by domain

Where the base scores ~0 %, there is no mass to re-allocate — so a gain is not sharpening.

The careful middle · Invisible Leash

“The shrinkage of empirical support generally outweighs the expansion” at larger sampling budgets.

Yue et al., arXiv:2504.13837 (NeurIPS 2025 oral) · Liu et al., ProRL, arXiv:2505.24864 · Wu et al., The Invisible Leash, arXiv:2507.14843 (v4, 2026-02) §1, §4 · inversion mechanism: When RLVR Shrinks the Reasoning Boundary, arXiv:2607.20543 · VLM boundary result: Does RLVR Extend Reasoning Boundaries?, ACL 2026, aclanthology.org/2026.acl-long.2102. Sources: VLM reasoning-boundary study.
Part IV · backup · reward-signal ablations

A reward that ignores correctness recovers most of the gain — on one model family.

The experiment

Reward all responses containing at least one non-empty \boxed{} expression, regardless of whether the answer is correct. Train Qwen2.5-Math-7B with GRPO under that reward.

  • Format-only reward: +13.8 points AMC, +10.3 points AIME 2024.
  • Ground-truth reward: +15.3 points AIME 2024 — i.e. the meaningless signal already recovers about two-thirds of the honest one's gain.
  • Random and incorrect rewards produce substantial gains on the same family, and do not reproduce on other families.
Consequence for the literature

Any RLVR result demonstrated only on Qwen-Math-class base models is, at minimum, ambiguous between "the method works" and "the model had a latent behaviour that any perturbation elicits". Ask for a second family before believing an ablation.

Shao, Li, Xin, Geng et al., Spurious Rewards: Rethinking Training Signals in RLVR, arXiv:2506.10947 §2.2, §3, §5, App. D (Qwen2.5-Math-7B; gains against the same base under matched settings).
Part IV · 4.3 what the mathematics permits

KL-regularized and multiplicative updates preserve support. Only weights move.

$$\pi^\star_\beta(y\mid x)=\tfrac{1}{Z(x)}\piref(y\mid x)e^{r(x,y)/\beta}\;\Longrightarrow\;\operatorname{supp}\pi^\star_\beta=\operatorname{supp}\piref$$ A. The KL-regularized optimum, for finite $r$, $\beta>0$.
$$\pi^{(t+1)}(a\mid s)\propto\pi^{(t)}(a\mid s)\,e^{\eta A^{(t)}(s,a)}\;\Longrightarrow\;\operatorname{supp}\pi^{(t)}=\operatorname{supp}\pi^{(0)}\ \forall t$$ B. Exact natural-PG / mirror descent, any step size, $|A|<\infty$.
$$\mathcal{H}(\pi^{k+1})-\mathcal{H}(\pi^{k})\approx-\eta\operatorname{Cov}_{a\sim\pi^k}\big(\log\pi^k(a\mid s),\,A(s,a)\big)$$ Entropy falls whenever likely actions get positive advantage.
The caveat

Under a softmax, every string has non-zero probability — set-theoretic support is everything. The operative object is empirical support at budget $k$, $\{y:\pi(y)\gtrsim 1/k\}$, which can grow and shrink.

The bound

Self-improvement creates no information the model lacks; the gain is computational — search amortized into weights.

Huang, Block, Foster, Rohatgi, Zhang, Simchowitz, Ash, Krishnamurthy, Self-Improvement in Language Models: The Sharpening Mechanism, arXiv:2412.01951 §1, §3, App. E · entropy identity (natural-PG form): Cui et al., arXiv:2505.22617 §3.2 Thm. 2 · Propositions A/B are one-line consequences of the closed forms in Part I.
Part IV · 4.4 measuring the right event

At large $k$, right answer and right reasoning are different events.

pass@$k$ fails on numeric answers

A wrong derivation can land on the right number — and the chance grows with $k$. Base-model pass@$k$ counts a growing tail of lucky guesses with invalid chains. Code is immune.

CoT-Pass@K

Count a sample only if its chain is judged valid. Under this metric, RLVR gains persist at large $K$ — the answer-only metric cannot see it.

Confound · budget

Most crossover evidence is short-budget.

Confound · family

Qwen-Math responds to almost any reward. One family is not evidence.

Confound · verifier

Answer matching is unsound at large $k$.

Rule
Report pass@$k$ with a verifier that checks the chain — or say that you did not.
Wen et al., RLVR Implicitly Incentivizes Correct Reasoning in Base LLMs (CoT-Pass@K), arXiv:2506.14245, ICLR 2026 · aggregation-rule analysis and judge false-positive decay as described therein · guessing-immunity of code pass@k: Yue et al., arXiv:2504.13837 §4.
Part IV · 4.5 synthesis

RLVR capability claims: evidence limits and a proposed comparison

Supported
  • 1
    pass@1 improves, reliably
  • 2
    Entropy and answer diversity fall — as the identity predicts
  • 3
    Short budget + frozen reference → support shrinks more than it grows
  • 4
    Distillation adds patterns RL on the same model does not
Not supported
  • 1
    "RLVR cannot expand capability"
  • 2
    "RLVR teaches new reasoning", in general
  • 3
    Anything from one family, one budget, or an answer-only verifier
The experiment nobody has run
  • ·
    fixed compute
  • ·
    ≥ 3 base families
  • ·
    domains stratified by base competence: 0 %, mid, saturated
  • ·
    sound verifiers, chain-checked
  • ·
    pass@$k$ to saturation
  • ·
    reference resets as an arm
For Part VI
Discovery is judged at large $k$ with a sound verifier. If RL only sharpens, the gain must come from search and verifier, not weights.
Synthesis is my reading of: arXiv:2504.13837 · 2505.24864 · 2506.10947 · 2506.14245 · 2507.14843 · 2412.01951 · 2606.15455 · 2607.20543. Marked as interpretation, not as a result of any one paper.
Part V · 5.1 the object of study

Multi-turn trajectories with tool observations

policy πθ thought + action environment shell · browser · repo an · tool call Qn · observation (masked) context sn grows every turn append (Qn, Rn) sn · state verifier terminal reward R after N turns episode = (think · act · observe)N → one terminal scalar
$$s_n=\Big(\textstyle\bigoplus_{n'<n}(Q_{n'},R_{n'})\Big)\oplus Q_n,\qquad a_n=R_n$$ $Q_n$ environment block, $R_n$ response, $\oplus$ concatenation. The transcript is the state.
  • a
    Discounting collapses: $0.9999^{10^5}\approx4.5\times10^{-5}$ per token; $0.99^{30}=0.74$ per turn
  • b
    Transitions are heterogeneous: one token, or a whole stochastic environment block — a critic averages both to mush
  • c
    The world adds variance: rollouts differ in what the environment returned, not only in what the policy did
Li et al., Turn-PPO: turn-MDP formulation, discount convention and Table 1.
Part V · 5.2 the observation mask

Never put environment tokens in the policy-gradient loss.

$$\begin{aligned} \mathcal{J}(\theta)=\ &\E_{x\sim\D,\;\{y_i\}\sim\pit(\cdot\mid x;\,\mathcal{P})}\Bigg[\frac1G\sum_{i=1}^{G}\frac{1}{\sum_t I(y_{i,t})}\;\times\\[-1pt] &\qquad\sum_{t:\,I(y_{i,t})=1}\min\Big(\rho_{i,t}\adv_{i,t},\ \clip(\rho_{i,t},1\pm\varepsilon)\adv_{i,t}\Big)\Bigg]\ -\ \beta\,\KL\big[\pit\,\|\,\piref\big] \end{aligned}$$ $I(y_{i,t})=1$ iff the policy produced token $t$; $\mathcal{P}$ is the environment kernel. Same mask on the KL.
Not a heuristic

$\nabla_\theta\E_{a\sim\pit}[f]=\E[f\nabla_\theta\log\pit(a)]$ needs $a\sim\pit$. Environment tokens come from $\mathcal{P}$: including them is advantage-weighted maximum likelihood on tool output — with positive advantage, training the model to hallucinate what it retrieved.

Measured

Masking retrieved tokens, otherwise identical run: +8.8 EM, 7-dataset average (Qwen2.5-7B-base, PPO).

Also exclude

Void turns — no tool call, no answer — from the update.

Jin et al., Search-R1, §3.1 and §5.4 Table 4: masking, 0.431 vs 0.343 (+8.8 EM). Related turn/sequence formulations: Turn-PPO, GSPO; void-turn filtering: SimpleTIR.
Part V · backup · where does the advantage come from

One trajectory-level scalar gives no within-episode credit.

$$\begin{aligned} \text{(i)}\ &\adv_{n,h}=\adv_i && \text{uniform}\\ \text{(ii)}\ &\adv_n=\delta_n+\gamma\lambda\adv_{n+1},\ \delta_n=r_n+\gamma V(s_{n+1})-V(s_n) && \text{turn GAE}\\ \text{(iii)}\ &\adv_{n}= \big(R_{i,n}-\operatorname{mean}_j R_{j,n}\big)/\operatorname{std}_j R_{j,n} && \text{turn group}\\ \text{(iv)}\ &\adv_{n,h}=\adv^{E}_{i}+\omega\,\adv^{S}_{i,n} && \text{episode}+\text{anchor}\\ \text{(v)}\ &r_n=V^{\log}(s_{n+1})-V^{\log}(s_n) && \text{TD on ref. }V \end{aligned}$$ $\adv^{E}$ episode-level relative advantage; $\adv^{S}$ step-level advantage within a group of repeated states; $\omega$ mixing weight; $V^{\log}$ a frozen reference model's log-probability of the gold answer.
Why (iv) is clever

Agentic environments revisit states. Grouping rollouts by anchor state gives a per-step baseline with no critic and near-zero cost — the grouping step is reported at 0.01 s inside a 362.83 s training iteration (rollout, log-probs, update) in the same setting.

Environment / model
metric
GRPO
tok-PPO
turn-PPO
WebShop · Qwen2.5-3B
avg reward
0.72
0.73
0.75
WebShop · Qwen3-1.7B (no think)
avg reward
0.78
0.77
0.80
WebShop · Qwen3-1.7B (think)
avg reward
crash
0.54
0.55
Sokoban · Qwen2.5-3B
avg reward
crash
1.93
2.29
Sokoban · Qwen2.5-7B
avg reward
crash
2.90
3.74
A clean negative ablation

GRPO does not always collapse — in the no-think WebShop row it beats token-PPO and sits just below turn-PPO. Where it does collapse, the crashes were not fixed by removing the std normalizer, removing the KL term, or increasing batch diversity — the last "merely delays the crash". The pathology is structural to the token-MDP formulation, not a hyper-parameter.

Reported gains from step-level credit

Anchor-state grouping: ALFWorld 72.8→86.7 (1.5B) and 77.6→90.8 (7B); WebShop 56.8→67.4 and 66.1→75.2 — best of the with- and without-std variants, against a GRPO baseline in the same harness. authors' numbers

Turn-PPO: crash comparison, Table 2. GiGPO: Table 1 (best of with/without standardization), §5 Figure 6 (timing). MT-GRPO: turn-level rewards.
Part V · backup · tool-integrated RL

The tool is part of the environment, so the reward can stay purely outcome-based.

Family
Action
Reward
Environment
Design detail that matters
Retrieval RL
<search> query
exact match on the final answer only
frozen index or live web
Retrieved tokens masked; a hard search budget $B$ per episode; no format reward, no neural RM
Code-execution RL
run a code block
test pass / numeric check
sandbox with timeout
Interpreter output is an observation, not a generation; void turns must be filtered
Browsing / deep research
navigate, read, cite
answer correctness, sometimes citation checks
live web, high variance
Non-stationary environment: the same query returns different pages across epochs
Repository agents
edit files, run tests
held-out test suite
containerized repo snapshot
Tests must be immutable to the agent, or the reward measures test editing
The shared recipe

Outcome reward, observation masking, group-relative advantage, dynamic sampling, and a budget on tool calls. Everything else is environment engineering.

Equal outcomes

Uniform rewards give zero centered reward advantages. Measure the actual per-prompt frequency; other loss terms may still contribute gradients.

WebSailor: DUPO

Duplicate in-batch non-degenerate groups instead of re-sampling. This is a published sampling variant, not a measured guarantee across agentic environments.

Jin et al., Search-R1 · Li et al., WebSailor (DUPO) · Xue et al., SimpleTIR (execution and void-turn filtering).
Part V · backup · the reward hacking of code RL

When the reward is a test suite, editing the tests is a reward-maximizing shortcut.

Observed behaviours
  • Weakening or deleting failing assertions rather than fixing the implementation
  • Special-casing the exact inputs a test uses, producing code that passes and does nothing
  • Catching and swallowing the exception the test checks for
  • Exploiting a benchmark's harness rather than solving the task — contaminated or resolvable-by-inspection instances
Why it is structural

An execution reward is a sound verifier for "the tests pass" and an unsound verifier for "the bug is fixed". RL optimizes the first. The gap is exactly the coverage of the suite — which is why held-out tests, unavailable to the agent, are not optional.

Detection, measured

Monitoring the chain of thought catches systemic exploit strategies at far higher recall than monitoring actions alone — reported at 95 % versus 60 % for two systemic hacks in an execution-reward setting.

The corollary is uncomfortable: the monitor works because the model says what it is doing. Optimizing against the monitor teaches it not to.

Practical countermeasures

Immutable test fixtures; a held-out suite the agent never sees; reward on diff-similarity to a gold patch as a secondary signal; and manual audit of the highest-reward rollouts — the standard finding is that the best-scoring trajectories are where the exploits live.

Part V · 5.3 environments and tasks

Tasks, verifiers and reproducible environments for agentic RL

screen capture · 2026-08 Coding-agent CLI session showing tool calls, file reads and shell commands in a repository
One episode of a repository agent. Goal, then reasoning, file reads, shell commands. Each tool result is an observation — masked. The action space, not a result.
Before one gradient step
…you need
Tasks
thousands, each with a machine-checkable outcome
Environment
a container per task, reproducible, restartable thousands of times an hour
Verifier
held-out tests — and a verifier for the verifier
Curriculum
difficulty estimates, or the groups are unanimous (Part III)
You built one yesterday

The ATC tournament: you wrote $r$, chose $\mathcal{O}$, fixed $P$; the leaderboard is the verifier. Two hours → one task family. A run needs thousands. That gap, not the estimator, is the cost.

Environment-stack synthesis: SWE-Gym, R2E-Gym, SWE-smith. Capture: my own session recording, not a published evaluation.
Part V · backup · the systems layer

Rollout and training compete for the same accelerators; the frameworks differ in how they resolve that.

Topology
Trade
Colocated
synchronous
Simple, exactly on-policy at $\mu=1$; accelerators idle during generation, and the long-tail rollout sets the step time
Disaggregated
Separate inference and training pools; high utilization, but the two engines now differ numerically (backup · off-policy by accident)
Partially async
Generation runs ahead by $k$ steps; staleness bounded and corrected by truncated IS
Fully async
Best throughput; requires explicit off-policy correction and a staleness budget in the objective
Framework landscape, 2026-08

verl, OpenRLHF, slime, AReaL, SkyRL, ROLL, prime-rl, Agent Lightning — all actively maintained; AReaL 2.0 and Agent Lightning 1.0 are 2026 rewrites around asynchronous agent rollouts rather than single-turn generation.

9,180
H100-hours
DeepSWE: 64×H100, 6 days, one 32B coding-agent RL run
16 : 44
train : inference nodes
INTELLECT-3 RL stage on 512 H200 — most of the fleet generates
$534.7k
disclosed RL run cost
MiniMax-M1, full RL stage self-reported
The ratio to remember

In agentic RL the inference fleet is larger than the training fleet. This is not an implementation detail: it means the cost driver is environment interaction, and the research lever is sample efficiency, not kernel efficiency.

Reproducibility consequence

Framework, topology, staleness and precision change results by more than most published algorithmic deltas. A paper that does not state them is not reproducible, whatever its equations say.

Framework status verified via the GitHub API on 2026-08-17 (release tags and last-push dates) · DeepSWE hardware: agentica-project release notes · INTELLECT-3 and MiniMax-M1 figures as disclosed by the respective reports. Sources: [31] · [67] · [68] · DeepSWE release · INTELLECT-3 report.
Part V · backup · what the numbers mean

An agentic score is a property of the model, the scaffold, the environment version and the date.

Benchmark
What it measures
Known measurement failure
SWE-bench Verified
Repository bug fixing against held-out tests
Scaffold-dominated; harness versions not comparable; contamination of pre-2024 repositories
Terminal-Bench
Shell-level task completion in a container
Sensitive to timeout and to allowed tooling; small $n$ per task family
GAIA
Multi-hop tool use with a single correct answer
Live-web non-stationarity: the environment changes between evaluations
τ²-bench
Tool-use dialogue against a simulated user with policy constraints
The user simulator is itself a model; its quality bounds the measurement
OSWorld
GUI control of a real desktop environment
Flaky at the pixel level; success depends on screen resolution and app version
MLE-bench / RE-Bench
ML engineering (Kaggle medal thresholds, no controlled human-time baseline) and research engineering (controlled expert baseline)
Time-budget dependent; reward hacking observed in a fraction of attempts (Part VI)
pass@1

One attempt. Reported everywhere; measures a mixture of capability and luck.

pass@k

Any of $k$ attempts. The capability measure — and the one Part IV showed can move opposite to pass@1.

pass$^k$

All $k$ attempts succeed. The reliability measure that deployment actually needs, and the one almost nobody reports.

Part V · 5.4 harness sensitivity

13.3 % → 38.3 % — the same model under different harness settings.

What changed

Reported settings: retained reasoning across tool calls and compaction instead of truncation. 2.9× in the reported public-set comparison. self-reported

Why

An agent is a policy plus a harness. The harness is part of the policy — in every sense except who trained it.

  • 1
    Unfixed harnesses → you measure the harness too
  • 2
    A leaderboard score is a property of the model–scaffold pair
  • 3
    Change harness and weights together → confounded
Report
Harness version · context policy · tool budget · retry rule.
OpenAI, How enabling two settings tripled our scores on ARC-AGI-3, 29 July 2026. Matched public-set report: 13.3% versus 38.3%; provider-reported, not independently reproduced.
Part V · 5.5 measuring horizon, not accuracy

METR task-duration horizons at 50% success

$$H_{50}=\max\big\{h:\ \Pr[\text{success}\mid \text{human time}=h]\ge 0.5\big\}$$ Human time: contracted experts on the same tasks, geometric mean of successful attempts.
  • Doubling every ≈6–7 months, 2019–2025
  • Opus 4.6: $H_{50}\approx$ 12 h (95 % CI 5–61 h); $H_{80}\approx$ 70 min
  • Reliability lags capability: 80 % horizons are 5–10× shorter
METR's caveat

"A 50% time horizon of X hours does not mean we can delegate tasks under X hours to AIs."

Why it matters here

Horizon decides whether an agent can run an experiment, not just answer a question. Part VI's workflows run for days.

Kwa, West et al., measured task horizons, §4.2 / §6.1 / §8.3. Per-model anchors: METR Time Horizon 1.1, data updated 8 May 2026. Kwa, limitations of time horizon, 22 January 2026.
Part V · backup · what actually goes wrong

Failure modes in long-horizon agents

Failure
Mechanism
What actually helps
Error compounding
Per-step reliability $p$ over $N$ steps gives $p^N$: at $p=0.99$, $N=200$ ⇒ 13 %
Checkpointing, verification sub-goals, restartable episodes — not a larger model
Context degradation
The transcript grows past the length where attention behaves well; early constraints are effectively forgotten
Summarization as an action, external memory, context reset with a carried state object
Unrecoverable states
The agent destroys the artefact it needed; no policy improvement recovers the episode
Sandbox snapshots, dry-run modes, action-space design — an environment fix
Silent reward hacking
The verifier is satisfied without the task being done (Part V · test manipulation, backup)
Held-out verification, trajectory audits of top-reward rollouts
Evaluation awareness
Behaviour differs when the model infers it is being tested, which invalidates the measurement
Held-out realistic deployments; treat eval-time behaviour as a measured quantity, not an assumption
The pattern

Four of the five admit environment and measurement interventions rather than objective changes; their relative incidence has not been measured, so treat this as a map, not a budget.

Implication for discovery

A scientific workflow is long-horizon by nature. Before asking whether an agent can do science, ask what the per-step reliability is and how many steps the protocol needs.

Compounding probability is an elementary illustration. Related empirical failure analysis: Kwa et al., measured task horizons and Anthropic, effective harnesses. The remaining taxonomy is my synthesis.
Part V · backup · removing the human from the curriculum

Self-generated curricula are bounded by the verifier that scores them.

The construction

A proposer generates tasks; a solver attempts them; an exact verifier scores both. The proposer is rewarded for tasks of intermediate difficulty — solvable but not solved — which keeps the curriculum at the ability frontier without any human-authored data.

Where it demonstrably works

Domains with an exact, cheap, proposer-independent verifier: code that must execute, arithmetic identities, formal proofs, puzzle solvers. Here the proposer cannot fake success, because the checker is not something it can write.

Where it fails
  • 1
    Collusion: shared weights let the proposer drift toward tasks the solver happens to pass.
  • 2
    Distribution drift: self-generated tasks converge to a narrow synthetic style that transfers poorly to real problems.
  • 3
    Verifier dependence: with a learned judge, self-play optimizes the judge — the Part II failure at compound interest.
Evidence boundary

Absolute Zero and R-Zero report transfer evaluations on held-out benchmarks. Those finite results do not establish open-ended scientific capability growth; inspect task independence, coverage and evaluation budgets.

Bridge
Self-play needs a verifier that the proposer cannot corrupt. In science, that verifier is the experiment — and it is expensive. Part VI.
Zhao et al., Absolute Zero · Huang et al., R-Zero. Both report transfer evaluations; assess independence, coverage and generality rather than assuming transfer is absent.
Part V · backup · the agenda

Open problems in agentic reinforcement learning

Episodes required to solve a task as a function of reward delay: exponential for TD and Monte-Carlo methods, flat for reward redistribution
Problem 1, measured before LLMs. Episodes-to-solve grows roughly exponentially in reward delay for the TD($\lambda$) family and for potential-based reward shaping, and is essentially delay-independent under return decomposition. The exponential TD bias and MC variance are proved in the appendix (Thm. A8/A10); the empirical speed-up is stated outright against Q($\lambda$) and only suggested against MC/MCTS. Arjona-Medina et al., RUDDER, NeurIPS 2019, Fig. 1(III), Trace-Back task.
1 · Credit assignment that survives 10² turns

Turn-level advantages help; they are still coarse. The classical answer — reward redistribution that provably preserves the optimal policy — has essentially not been tried at this scale.

2 · Verifier soundness at scale

We have no accepted methodology for validating a verifier before optimizing against it. Sound-but-incomplete costs recall; complete-but-unsound costs the experiment. A theory of verifier error and its interaction with RL dynamics is missing.

3 · Reliability as an objective

Deployment needs pass$^k$, not pass@$k$. Almost nothing optimizes for it directly, and the entropy results of Part III suggest reliability and diversity trade against each other in a way that has not been characterized.

4 · Sample efficiency against expensive environments

The software environments of Part V are cheap per interaction and expensive only in aggregate. When one rollout costs a beamline hour or a synthesis run, the recipe does not transfer, and the literature for that regime — model-based RL, Bayesian optimization, active learning — is barely connected to this one.

Next
Problem 4 is scientific discovery. That is Part VI.
Open problems are my synthesis. Delayed-credit figure: Arjona-Medina et al., RUDDER, NeurIPS 2019, Fig. 1(III), Trace-Back task; supporting evidence appears in the preceding reference slides.
Part VI · backup · formalizing the loop

Scientific discovery as a cost-sensitive MDP

$$r_t=\underbrace{\mathcal{V}(s_t,a_t)}_{\text{verifier signal}}-\underbrace{\lambda\,c(a_t)}_{\text{cost of obtaining it}},\qquad J(\pi)=\E_{\tau\sim\pi}\Big[\textstyle\sum_{t}\gamma^{t}r_t\Big]$$ $s_t$ = partial candidate plus accumulated evidence; $a_t$ = an edit to the candidate or an experiment to run; $\mathcal{V}$ = proof kernel, simulator, assay; $c(a_t)\ge0$ = TPU-seconds, beam-seconds, furnace-hours, dollars.
The regime boundary

When $c\approx0$ you may brute-force: the only real question is representation. When $c$ is measured in days and dollars, the question stops being "maximize reward" and becomes "which experiment should I run next" — Bayesian experimental design, whose sequential form is again an RL problem, now with the expensive verifier written into the reward.

$$\operatorname{EIG}(\xi)=\mathrm{H}[p(\theta)]-\E_{p(y\mid\xi)}\big[\mathrm{H}[p(\theta\mid y,\xi)]\big]=\mathrm{I}[\theta;y\mid\xi]$$ Lindley's criterion: value an experiment $\xi$ by the mutual information it yields about the latent $\theta$. The sequential version is exactly an RL problem — the return equals a lower bound on total EIG.
Two cleanly verifiable instances

AlphaTensor. State = the matrix-multiplication tensor; action = a rank-one term; reaching zero is an exact algorithm. The reward is an algebraic identity, so correctness is not a matter of belief.

AlphaProof. State = the Lean tactic state; action = a tactic; $r_t=-1$ per step. At AND-nodes the return is the minimum over subgoals, not the sum — which rewards balanced decompositions.

The objection to keep in view

"Reward is enough" is a hypothesis, and it has a published objection: scientific objectives are irreducibly multi-objective — novel, correct, useful, cheap — and scalarizing them is a modelling choice, not a fact about science. Both positions are live; the lecture does not settle it.

Fawzi et al., AlphaTensor, Nature 610:47, 2022 · Hubert et al., AlphaProof, Nature 651:607, 2025 (PUCT and AND-node value) · Lindley 1956; Blau et al., RL for Bayesian experimental design, ICML 2022 · Silver et al., Reward is enough, Artificial Intelligence 299, 2021 vs Vamplew et al., Scalar reward is not enough, JAAMAS 36:41, 2022. Sources: [70] · [75] · [100] · [105a] · [105b] · Lindley.
Part VI · 6.1 profile the verifier, then choose the algorithm

Verifier costs, algorithm choices and evidence limits

Verifier
System
Cost per verdict
What it licenses
Algebraic identity
AlphaTensor
microseconds
"Exact, and it recurses"
Lean kernel
AlphaProof
ms per tactic — 80,000 TPU-days of search
"This theorem is proved" — the statement is the risk
Physics simulator
TCV plasma
5,000 actors, days; sim-to-real gap
A zero-shot controller, 0.5–1.6 cm RMSE on hardware
Real instrument
CERN AWAKE
~5 s of beam time per iteration; ~350 iterations
Online training on the machine itself
Furnace + XRD
A-Lab
hours per sample
"A powder consistent with the target pattern"
Peer review
AI-Scientist-v2
weeks; $n=3$, 1 accepted, later withdrawn
Almost nothing about the science
The gradient
Epistemic quality declines down this table — and every correction in this part sits in its lower half.
Values as reported in: Nature 610:47 (AlphaTensor) · Nature 651:607 (AlphaProof) · Nature 618:257 (AlphaDev) · Nature 602:414 (Degrave et al., TCV) · Kain et al., PRAB 23:124801 (LINAC4) · Nature 624:80 (GNoME) · Nature 624:86 (A-Lab). Sources: [70] · [75] · [71] · [78] · [79] · [84] · [86].
Part VI · 6.2 the results that survived

Low-cost verification in RL and frozen-model program search

Proof kernel · IMO 2024

AlphaProof + AlphaGeometry 2: 28/42, competition-graded. Price: ~80,000 TPU-days of RL, 2–3 days per problem. Sound ≠ cheap.

…but the translation in front of it is not

miniF2F: 97 % autoformalization and 69 % proving as components — yet ≈36 % measured end to end.

Generalize it

Tests encode a spec, a simulator a model, an assay a hypothesis. The translation is where the error lives.

System
Learns?
Verified result
AlphaTensor
RL + MCTS
rank-47 for 4×4 in $\mathbb{Z}_2$ (Strassen²: 49)
AlphaDev
RL + MCTS
sort routines shipped in LLVM libc++
FunSearch
no weights
cap set 496 → 512 at $n=8$
AlphaEvolve
no weights
48 multiplications for 4×4 complex
Half of it computes no gradient

FunSearch, AlphaEvolve: program search — frozen LLM as mutator, exact verifier as fitness. AlphaFold: no RL either.

Design rule
Cheap exact verifier + an auditable artefact ⇒ program search beats a policy network. RL earns its place when the artefact must be a policy.
Hubert et al., AlphaProof, Nature 651:607, 2025, DOI 10.1038/s41586-025-09833-y · Trinh et al., AlphaGeometry, Nature 625:476, 2024 · Ospanov, Farnia & Yousefzadeh, miniF2F-Lean Revisited, arXiv:2511.03108 (end-to-end protocol) · Nature 610:47 (AlphaTensor) · Nature 618:257 (AlphaDev) · Nature 625:468 (FunSearch) · Novikov et al., AlphaEvolve, arXiv:2506.13131 §3.3.1, Tab. 3 · IMO 2025/2026 rows and the evidence tiers behind them: backup slide. Sources: [75] · [74] · [70] · [71] · [72].
Part VI · backup · what each claim rests on

Evidence tiers for IMO results and verified program search

Event
Result
Evidence tier
IMO 2024
28/42 — three Lean proofs (AlphaProof) + one geometry proof (AlphaGeometry 2)
graded by IMO-level judges
IMO 2025
35/42 natural language
officially graded by coordinators
IMO 2025
35/42, second (vendor-internal) system
self-graded by former medallists
IMO 2026
42/42, Lean-verified unrefereed
statements also auto-formalized
Why the column matters

"AI solved the IMO" spans all four rows. Naming the tier is the difference between a machine-checked artefact and a press release — the practice Part VI asks for.

FunSearch and AlphaEvolve, in full

FunSearch: cap set 496 → 512 at $n=8$; admissible-set capacity 2.2180 → 2.2202. AlphaEvolve: matched or improved the state of the art on ~75 % / 20 % of 50+ open mathematical problems; deployed results include a data-centre scheduling heuristic recovering 0.7 % of fleet compute, a 23 % kernel speed-up worth ~1 % of Gemini training time, and a TPU RTL simplification.

And the authors' own reason

The scheduling heuristic "was chosen over a deep reinforcement learning approach because its code solution not only leads to better performance, but also offers clear advantages in interpretability, debuggability, predictability, and ease of deployment."

Novikov et al., AlphaEvolve, arXiv:2506.13131 §3.3.1, Tab. 3 · Nature 625:468 (FunSearch) · IMO rows: organisers' and vendors' own reports, tier as stated; the 2026 row is unrefereed at the time of writing. Sources: [72].
Part VI · 6.3 when the environment is a machine

Reinforcement learning on laboratory hardware

Tier
Meaning
Verified instance
T-E
simulation only
WEST; SPARC ramp-down
T-B
learned surrogate → hardware
DIII-D tearing-mode avoidance
T-A
zero-shot sim-to-real
TCV shape control, 0.53–1.6 cm RMSE
T-C
trained online on the machine
AWAKE: ~350 iterations ≈ 30 min of beam; LINAC4: ~300
T-D
routine operations
One: CERN PS triple splitting, autonomous since March 2025
Fusion

Nothing published has reached T-D.

No GRPO here

MPO, DDPG, SAC, NAF — classical continuous control — because the constraint is sample cost, not credit over $10^5$ tokens.

Same problem, two literatures

Sample-efficient policy learning against an expensive verifier — with almost no citation traffic between them.

This bootcamp

The accelerator and robot keynotes are this row. A bad rollout costs beam time or a robot.

Part VI · backup · proxy coverage

Proxy coverage in chip placement

The claim and the record

RL-based chip floorplanning was published in Nature in 2021 and remains unretracted; the amendments of record are a 2022 author correction and a 2024 addendum. A separate News & Views commentary was retracted in 2023. Independent assessments were published in IEEE TCAD (2026) and CACM (2024); the original authors published a rebuttal listing pre-training, collector count, GPU budget and benchmark representativeness as the differences.

The number that matters

Kendall rank correlation between the wirelength component of the agent's proxy cost and post-route reality on one benchmark design: 0.355 for wirelength, −0.002 for worst negative slack, 0.046 for area.

The transferable lesson

If the reward is a proxy, measure the rank correlation between the proxy and the thing you care about before optimizing it, and report it. This is a one-day experiment that would have prevented years of argument — and it applies verbatim to every learned reward model in Part II.

Mirhoseini et al., Nature 594:207, 2021; Author Correction 2022; Addendum Nature 634:E10–E11, 2024 · Cheng et al., An Updated Assessment of Reinforcement Learning for Macro Placement, IEEE TCAD 45:3654–3668, DOI 10.1109/TCAD.2025.3644293, Tabs. III–IV, IX · Markov, CACM, DOI 10.1145/3676845 · Goldie et al., rebuttal, arXiv:2411.10053. Sources: [81] · [82] · [83] · correction · addendum.
Part VI · 6.4 the correction record

Materials discovery: critiques, corrections and experimental validation

Claim (2023–24)
Claimed
Established under scrutiny
Status
GNoME
2.2M new structures, 381k stable
Sampled entries already in the ICSD; DFT at 0 K, ordered cations
critiqued
A-Lab
41/58 "novel" compounds in 17 days
Correction: "novel" dropped; 36/57; XRD fits do not exclude known phases
corrected
AI in materials R&D
+44 % discovery at a large firm
Host institution: no confidence in the data
withdrawn
What survived

RL-designed molecules through synthesis and assay: 79 made, 13 potent, one efficacious in vivo.

What is not RL

AlphaFold 2 and 3: supervised learning and diffusion.

The pattern

Corrections concentrate where the verifier is expensive, approximate or social.

Merchant et al., Nature 624:80, 2023 · Cheetham & Seshadri, Chem. Mater. 36:3490, 2024, DOI 10.1021/acs.chemmater.4c00643 · Szymanski et al., Nature 624:86, 2023, Correction Nature 650:E1, 2026-01-19, DOI 10.1038/s41586-025-09992-y · Leeman et al., PRX Energy 3:011002 · Swanson et al., SyntheMol-RL, Mol. Syst. Biol. 22:833, 2026. Sources: [84] · [85] · [86] · [89] · 2412.17866 · Leeman et al. · AlphaFold 2 · AlphaFold 3 · correction.
Part VI · backup · can an agent do the research?

Research-agent benchmarks and human comparisons

What the medal rate is not

MLE-bench has no controlled human-time baseline — the thresholds are Kaggle medals, and time budgets differ across leaderboard rows. It measures relative agent progress, not "agents versus scientists".

Benchmark
Best reported agent
Human baseline
RE-Bench
the human score at a 2-hour budget
Real and controlled: 61 experts, 71 attempts; at an 8-hour total budget the top agents match the 36th–37th human-expert percentile
PaperBench
o1-high + IterativeAgent: 26.0 ± 0.3 replication score at a 36-hour budget
41.4 % for ML PhDs (best of 3 attempts, 48 h) vs 26.6 % for o1 on the same 3-paper subset
ScienceAgentBench
32.4–42.2 % task success
none published
CORE-Bench Hard
21.5 % reproduction
none published
Reward hacking is measured here too

In METR's follow-up evaluation on RE-Bench, 7 of 164 attempts were judged to have hacked the scoring rather than solved the task. On a benchmark about research competence, that fraction is the story, not a footnote.

Chan et al., MLE-bench, arXiv:2410.07095 (launch paper: 16.9 ± 1.1 over 16 seeds) and the official leaderboard at github.com/openai/mle-bench, from which both plotted points are read · Wijk et al., RE-Bench, METR, arXiv:2411.15114 §4–5 · Starace et al., PaperBench, arXiv:2504.01848 Tab. 5 and §5.4 (Fig. 3) · Chen et al., ScienceAgentBench, arXiv:2410.05080 · Siegel et al., CORE-Bench, arXiv:2409.11363 · 7/164 reward-hacked attempts: METR, o3 & o4-mini preliminary evaluation report, metr.org/evaluations. Sources: MLE-bench leaderboard · METR o3/o4-mini evaluation.
Part VI · backup · choosing the formalism

Choosing between RL, Bayesian optimization and GFlowNets

Bayesian optimization
$$R_T\le\sqrt{C_1\,T\,\beta_T\,\gamma_T},\quad C_1=\tfrac{8}{\log(1+\sigma^{-2})}$$

Sublinear regret, explicit in the information gain $\gamma_T$. Wins when evaluations are very expensive, the space is low-dimensional, and calibrated uncertainty matters.

GFlowNets
$$\mathcal{L}_{\text{TB}}(\tau)=\left(\log\frac{Z_\theta\prod_t P_F(s_{t+1}\mid s_t)}{R(x)\prod_t P_B(s_t\mid s_{t+1})}\right)^{2}$$

Sample proportional to reward: $\pi(x)\propto R(x)$. Wins when you need a diverse batch of high-reward candidates from a compositional space.

Reinforcement learning
$$\max_\pi\ \E_\tau\Big[\textstyle\sum_t\gamma^t\big(\mathcal{V}(s_t,a_t)-c(a_t)\big)\Big]$$

Wins when the artefact is a policy: online decisions against a state you cannot enumerate, or a long-horizon sequential search.

Two published head-to-heads

Accelerator tuning (ARES): an RL-trained optimizer reached target in a median of 7 steps versus 40 for Bayesian optimization in simulation, with a median final beam error of 4 µm versus 45 µm; on the real machine the advantage narrowed to roughly over 13 of 22 trials, and the authors attribute much of the gap to pre-training.

Materials design: on the Ackley and Rastrigin benchmarks, model-based RL beat expected-improvement BO for dimensionality $D\ge6$ (Fig. 2; no $p$-value reported for these). On high-entropy-alloy design the RL advantage reached significance only at 10 components ($p<0.01$, Fig. 7). Below that the two were comparable, with BO stronger in the early iterations.

How I choose

Evaluations expensive and the space low-dimensional → BO. A diverse batch needed → GFlowNets. The artefact is a policy over a long horizon → RL. The $D\ge6$ boundary is the only matched-budget crossover I found, and it is measured on benchmark functions, not materials; the rest is judgement.

An honest gap

Despite a large GFlowNet literature on molecule generation, no primary source could be found reporting GFlowNet-designed molecules that were synthesized and assayed. The formalism is elegant; the wet-lab evidence is missing. That is an opportunity, stated as such.

Srinivas et al., GP-UCB, ICML 2010 (Thm. 1) · Malkin et al., Trajectory Balance, NeurIPS 2022, arXiv:2201.13259 Eq. 14 · Kaiser et al., RL vs BO for accelerator tuning, Sci. Rep. 14:15733, 2024, DOI 10.1038/s41598-024-66263-y · Xian et al., npj Comput. Mater. 11:143, 2025, DOI 10.1038/s41524-025-01639-w Sources: [96] · [101] · [102] · [97].
Part VI · backup · reporting practices

Verification and reporting practices for AI-assisted discovery

Practice
Because
Concrete form
Name the verifier tier
"AI discovered X" spans several evidence tiers using identical vocabulary
State the verifier and who checked it, in the abstract
Measure proxy–objective correlation
An optimized proxy can be rank-uncorrelated with the objective (backup · the coverage failure)
Report Kendall $\tau$ between reward and the real metric
Validate the translation
Component scores of 97 % and 69 % can compose to 36 % end to end
Evaluate end-to-end against the original informal statement
Audit the top-reward rollouts
Exploits live at the top of the reward distribution, not the bottom
Manual review of the best $n$ trajectories, every run
Check novelty against a database
"Novel to the platform" is not "novel to science"
Automated ICSD/PubChem/literature cross-check before claiming novelty
Publish the harness
A provider-reported harness comparison changed the score by about 2.9× (Part V · the scaffold confound)
Version, prompts, budgets, retries, and the exact environment image
One encouraging measurement

Verifier noise is survivable for training: injecting up to 15 % label noise into RLVR left peak validation accuracy within 2 points of the clean baseline across three model families. Prefer moderate accuracy with high precision over perfect verification — but note this is a claim about training dynamics, not about believing an individual discovery.

Why this is not pedantry

Each correction on Part VI · the correction record involves a check that two of these six practices would have applied before publication. The cost is on the order of days.

Practice recommendations are my synthesis. Noise study: Plesner, Guzmán & Athalye, An Imperfect Verifier is Good Enough: Learning with Noisy Rewards, 2026 (Qwen3, GLM-4, Llama-3.1; 4B–9B).
Part VI · 6.5 the four bottlenecks

Scientific discovery: verification, sample efficiency, novelty and evaluation

1 · No verifier for most science

Kernels and tests for math and code. Assays, instruments and arguments for everything else.

2 · Sample efficiency against expensive verifiers

30 min of beam time = a few hundred iterations. The LLM-RL toolbox is not built for it; the tools that are barely cite it.

3 · Novelty is not in the objective

Verifiers score correctness, not interestingness — and correctness alone is what sharpening optimizes.

4 · Discovery cannot be benchmarked

A benchmark cannot contain a result nobody has found yet.

Next
Part VII runs Parts III–IV on one small pipeline that attacks 1 and 2 at laboratory scale — and says what it does not show.
Bottleneck statements are my synthesis of Parts II, IV, V and VI; the supporting evidence for each is cited on the slides referenced above.
Part VII · 7.1 what actually runs

Local GRPO: rollout filtering and loss weighting

group-relative policy optimization · one iteration
for prompt_batch in loader:                        # B prompts
    rollouts = engine.generate(prompt_batch, n=G)     # G samples / prompt
    r = verifier(rollouts)                            # {0,1}^(B×G), programmatic
    keep = (0 < r.sum(-1)) & (r.sum(-1) < G)          # ① dynamic sampling
    A = r - r.mean(-1, keepdim=True)                  # local mean subtraction; no /std
    if not keep.any(): continue
    mask = completion_mask(rollouts)
    rollouts, A, mask = rollouts[keep], A[keep], mask[keep]
    A = A[..., None]                                 # broadcast over retained tokens
    logp_old = policy.logprobs(rollouts).detach()    # ② old scores
    logp_ref = reference.logprobs(rollouts).detach()
    for _ in range(mu):                              # inspect actual ratios
        logp = policy.logprobs(rollouts)
        rho  = (logp - logp_old).exp()
        w    = torch.clamp(rho, 1-eps_lo, 1+eps_hi)      # clip-higher
        surr = torch.min(rho * A, w * A) * mask       # mask: model tokens only
        loss = -surr.sum() / mask.sum()               # ③ token-level denominator
        loss = loss + beta * k3_kl(logp, logp_ref, mask)
        loss.backward(); opt.step(); opt.zero_grad()
    proxy = (-(logp * mask).sum(-1) / mask.sum(-1)).mean()
    clipped = ((rho != w) * mask).sum() / mask.sum()
    log(sampled_surprisal=proxy, clip_frac=clipped)
① Filter before you average

Without filtering, unanimous groups dilute the denominator. Here they are dropped before the retained-token mean.

② Which log-probs?

Recomputed old scores are not necessarily sampling-distribution scores. Audit temperature, mode and stochastic forwards.

③ The denominator is the objective

Token-level vs per-response mean: same code path, different algorithm.

Log from day one

p4-final logged nonzero clipping. One inner epoch does not guarantee ratio one; zero clipping does not identify the algorithm.

Conceptual local loop; compare Shao et al. arXiv:2402.03300 Eq. 3, Liu et al. arXiv:2503.20783 App. A (aggregation), Yu et al. arXiv:2503.14476 Eqs. 10–12 (asymmetric clip, filtering, token-level denominator). The pseudocode is my own, not copied from any repository.
Part VII · 7.2 measure the support first

Pre-RL support measurement and gating

step 1
Sample

$G$ answers on $n=32$ evaluation prompts, from the init checkpoint.

minutes
step 2
Estimate

pass@1: first answer correct; pass@$G$: any of $G$ correct.

Part IV
step 3
Budget

Illustrative dead-group share $(1-p)^G+p^G$; measure actual retention too.

Part III
step 4
Decide

--require-gate blocks pass@$G=0$; positive support is not full readiness.

blocking
Make it block

Blocking was disabled: two zero-support runs proceeded. 46 min of skipped updates; loss, KL and entropy were logger sentinel zeros.

Read it
$G$ is a budget knob: at $p=0.1$, $G=8$ wastes 43 % of rollouts, $G=16$ wastes 19 % at twice the samples. The gate tells you where you are before you pay.
Generic pass@k estimator: Chen et al., Eq. 1. Historical local gate used first/any-answer frequencies. Two zero-support runs proceeded with blocking disabled; evaluation excluded the RL pool, earlier-stage overlap not ruled out. Own unpublished July 2026 experiments.
Part VII · 7.3 the gate, and what it caught

Local RLVR runs: support gates, training rewards and evaluation outcomes

The one that worked

Held-out 0.2083 → 0.375 (+8 of 48), logged entropy field up (0.335 → 0.491). Gate had found headroom: pass@1 0.19, pass@6 0.31.

Run
Gate pass@1 (n=32)
Train reward, first → last
Held-out accuracy
p4-final
0.1875
0.194 → 0.472
0.2083 → 0.375
p4-grpo-v1
0.531
0.444 → 0.611
0.604 → 0.604 (flat)
p4-grpo-v2
0.5625
0.438 → 0.354
0.604 → 0.583
uni10m-rlvr
0.0
0.0 for 50 steps
no gradient
found26m-rlvr
0.0
0.0 for 50 steps
no gradient
Two dead runs — the ledger, verbatim

Gate: pass@1 = pass@8 = 0. Every group unanimous, every group skipped: no updates for 50 steps; zero-valued metric sentinels. 46 min of compute. The verdict was recorded, not enforced.

One negative, one disclosure

p4-grpo-v1: reward up, evaluation flat; logged entropy field halved — not proof of entropy collapse. p4-final: nonzero clipping, despite one inner epoch.

Own unpublished July 2026 experiments: p4-final, p4-grpo-v1, p4-grpo-v2 (3 July); uni10m-rlvr, found26m-rlvr (6 July). Core parameters: 1,021,793; 2,952,323; 7,609,524, respectively. Architecture background: Spiral technical report; these runs are not results from that paper.
Part VII · backup · the implemented objective

Local GRPO objective

dentate/pretrain/grpo.py · advantage and loss — abridged excerpt, non-normalized configuration
# Local advantage: r − mean(group), NO /std; dynamic sampling skips
# zero-variance groups (all rewards equal ⇒ every advantage 0 ⇒ DAPO).
mean = sum(rs) / len(rs)
var  = sum((x - mean) ** 2 for x in rs) / len(rs)
if cfg.dynamic_sampling and var < 1e-12: continue
ro.advantage = (r - mean)

ratio     = torch.exp(new_lp - old_lp)
unclipped = ratio * adv
clipped   = torch.clamp(ratio, 1-cfg.clip_low, 1+cfg.clip_high) * adv
surr      = torch.minimum(unclipped, clipped)
# Mean over retained completion tokens; not a fixed-length denominator
denom = new_lp.numel() if cfg.length_normalize else tot_tokens
pg    = pg - surr.sum() / denom
d      = ref_lps[i] - new_lp        # k3: exp(d) − d − 1 ≥ 0
kl_acc = kl_acc + (torch.exp(d) - d - 1.0).sum() / tot_tokens
loss = pg + cfg.kl_beta * kl_acc - cfg.entropy_coef * ent_acc
$$\mathcal{J}=\frac{1}{\sum_i|o_i|}\sum_i\sum_t\min\big(\rho_{i,t}\tilde A_i,\clip(\rho_{i,t},1-\varepsilon_l,1+\varepsilon_h)\tilde A_i\big)-\beta\,\mathbb{D}^{k_3}_{\text{KL}}+\alpha_{\mathcal H}\,\mathcal{H}$$ $\tilde A_i=r_i-\operatorname{mean}(\mathbf r)$; $i$ ranges over retained completions. Retained-token mean, not the full Dr. GRPO objective. $\mathcal H$ is the optional Shannon loss bonus, not the default logged proxy; its coefficient is not persisted.
The reward

Rule-based binary exact match, plus a requirement that a non-trivial reasoning span precede the answer — so the policy cannot collapse the chain of thought into an answer-only shortcut. That is the Part II format-exploit lesson, encoded as a constraint.

Disclosure

Asymmetric bounds: v1 0.2 / 0.28; v2 and final 0.2 / 0.30. p4-final logged nonzero clipping. One inner epoch does not guarantee ratio one: audit scoring modes and stochastic forwards.

Historical Dentate estimator; Dentate documentation. Related published objectives: Dr. GRPO and DAPO. These citations do not imply implementation equivalence.
Part VII · backup · every logged step

p4-final: logged entropy field, skipped updates and checkpoint accuracy

The same run as the five-runs slide, plotted without smoothing: held-out accuracy at five checkpoints, and the logged entropy field at every update step. Nine steps performed none; they are marked, not hidden.

What the endpoints show

The logged field rose 0.3350 → 0.4906; v1 fell 0.157 → 0.077. Its default is a sampled-surprisal proxy; historical entropy coefficient was not persisted. These endpoints establish neither Shannon-entropy collapse nor its absence.

The nine skipped steps

Steps 12, 22, 30, 31, 39, 42, 44, 69, 79: every group in the batch was unanimous, dynamic sampling skipped all of them, and the logger recorded a sentinel 0 for entropy, KL and loss — the same mechanism that killed two runs entirely, appearing intermittently here. Illustrative homogeneous-Bernoulli arithmetic at the gate's $p=0.19$ and this run's $G=6$ gives ≈29 % unanimous prompts.

Own unpublished p4-final experiment, 3 July 2026. 100 logged iterations; answer accuracy at 20/40/60/80/100 on 48 evaluation items, greedy decoding. Earlier-stage data overlap not ruled out.
Part VII · backup · a coupling failure

Initialization and reward-format compatibility

phase 03 · reason
healthy

held-out test verify_acc 0.75
format compliance 1.00

reward can fire
phase 04 · agentic SFT
regression

tool-call syntax validity 0.00

format contract broken
phase 05 · RLVR
dead

format compliance 0.0208
reward ≈ 0 everywhere

no learning signal
Diagnosis

The RL reward requires a parseable answer preceded by a non-trivial reasoning span. Agentic fine-tuning moved the output distribution away from that format (its own tool-call syntax validity was 0.00 as well), so at RL time only 1 in 48 samples was parseable at all. The verifier was fine; the interface between two stages was not.

The general lesson

A post-training pipeline is a chain of format contracts, and the standard tooling does not check that stage $n{+}1$ preserves the contract that stage $n{+}2$'s reward depends on. This is a small, fully observable instance of a failure that at larger scale is usually reported only as "the RL stage did not help".

A second, unattributable observation

Two agentic-SFT runs with byte-identical recorded configurations differ 0.0 versus 1.0 in tool-call validity at essentially identical harness fit (token accuracy 0.44199 vs 0.44207). The delta is measured; the cause is not recoverable from the artifacts, because the run manifests do not persist the initialization lineage. Reproducibility is a data-model problem before it is a science problem.

Required fixes
Persist lineage; enable --require-gate for zero answer support; separately check readiness and cross-stage reasoning format.
Own unpublished Dentate pipeline experiments: found26m and p3-agentic/replay. Audit of saved configurations found a checkpoint-lineage gap. Product documentation: Dentate documentation; not an independent benchmark.
Part VII · backup · measured deployment

Checkpoint hash provenance and inference benchmark measurements

2.75×
prefill speed-up
13.405 → 4.870 ms median, 480-token prompt
98,567
prompt tokens / s
Apple M3 Max, 12 threads, f32, CPU
4 / 4
greedy-token parity
vs eager fp32 oracle, max logit error 1.05e-5
The provenance chain, closed by hashing

shasum -a 256 of the trained checkpoints equals the checkpoint_sha256 recorded inside the inference benchmark artifact. The served checkpoints are two ~1M-parameter cores (1,023,553 and 1,024,080 parameters) from the same family — a separate serving demonstration, not the p4-final RLVR checkpoint. Model identity is therefore verified, not asserted — the same discipline the epistemic-hygiene backup asks of a discovery claim.

What is not measured

Numerical conformance is enforced and passing. Task-quality retention is specified but not delivered: the suite pins ten benchmarks at a 0.95 threshold, and the results database currently holds one complete suite, one partial, and eight empty. The only end-to-end quality artefact is an 8-case smoke test on which both engines scored 0.125.

Why show a number this small

Because it is checkable. A 2.75× prefill speed-up for a model with a ~1M-parameter recurrent core is not a research result; the hash-verified chain from training run to served binary is the part worth copying.

Substitutability

Nothing here depends on this particular stack. The same pipeline can be assembled from any RL framework from the RL-infrastructure backup slide plus any serving runtime; what matters is that each arrow between stages is verified.

Own unpublished Sema-infer microbenchmark, 16 August 2026: six alternating A/B pairs, 60 samples per binary. Quality-suite validation was incomplete; these are not model-quality results.
Part VII · backup · the loop at the top

Scientific workflows as bounded execution graphs

Structure

One run traverses a frozen 15-phase DAG declared as data: knowledge acquisition → distillation → literature review → hypothesis and methodology → derivation → experiment design → validation and simulation → visualization → insight refinement → writing → revision → review → packaging, plus two user-facing phases.

Each node is a bounded render → turn → parse → validate → repair loop whose signal is a typed contract verdict — a verifier in exactly the Part II sense, with a repair budget instead of a gradient.

What is deterministic

A seven-layer contract validator, policy-keyed quality floors, citation-to-source cross-checking, byte-level evidence inspection, and an AST inspector on the packaged artefact. One model-judged seam and one review phase are the only learned verifiers in the loop.

screenshot · 2026-02 Research system UI: a generated manuscript with its originating problem statement, artifacts and review state
What is shown. One completed run's output surface: the generated manuscript, the originating problem statement, the packaged artifacts (PDF, code, LaTeX sources, datasets) and the review state. The artifacts are what make a run checkable by someone else.
Where the human is

Five configurable approval gates plus explicit needs-input and blocked states; an automatic mode with attempt and wall-clock limits can force-pass them — which removes the human, and should be reported whenever used.

The claim I will not make

No benchmark evaluation of this system's output is evidenced in the inspected repository: a repository-wide search finds no evaluation files; the output directories are Docker mount points whose runtime state was not inspected. The architecture is real and inspectable; no evaluation of its scientific output is on record, and Part VI's research-agent benchmarks are the yardstick it has not been held to.

Historical implementation audit, 17 August 2026: no evaluation artifacts were found for the displayed workflow. omegaXiv research artifacts provide project context, not proof of the displayed claims.
Part VII · 7.4 what to log, and what each number means

Learning diagnostics and failure modes

Signal
Healthy
Pathology — and the run that showed it
Slide
clip_frac
inspect ratios
Zero does not identify the algorithm; p4-final clipping was nonzero
III · genealogy
unanimous groups
$(1-p)^G+p^G$, < 50 %
100 % → no gradient (uni10m, found26m); rising → curriculum exhausted
III · ledger
logged entropy field
check definition
Default: sampled-surprisal proxy. A fall does not prove entropy collapse
III · entropy
reward vs held-out
move together
reward ↑, held-out → investigate overfit or verifier gaming — read top rollouts
II · Goodhart
KL to reference
budgeted
jumps → outside where $\mathcal{V}$ was measured; turnover next
II · Goodhart
parse rate
≈ 1 at step 0
≪ 1 → the previous stage broke the format contract (found26m: 0.02)
VII · backup
pass@$k$, $k$ to saturation
pass@$k$ not ↓
pass@1 ↑ while pass@$k$ → sharpening only
IV
Rule
Log training metrics per step; evaluate accuracy and format at checkpoints. Definitions matter as much as columns.
Own unpublished run diagnostics; earlier-stage evaluation overlap not ruled out. Related mechanisms: Cui et al., entropy mechanism, §4 · Liu et al., ProRL, §3.
Part VII · 7.5 the checklist, and the tournament

Run-reporting requirements and tournament-agent checks

Before anyone can read your result
  • 1
    The gate — init pass@1, pass@$G$, $n$; blocking predicate, enabled state and outcome
  • 2
    Which algorithm ran — $\mu$, clip_frac, engine pair, denominator
  • 3
    pass@$k$ to saturation — > 1 family, chain-checking verifier
  • 4
    The harness, pinned — version, context policy, tool budget, retries
  • 5
    Kendall $\tau$ — reward vs the metric you care about
  • 6
    The hash — and the runs that produced nothing
After the final, on the reward you wrote yesterday
  • a
    Price your verifier — Kendall $\tau$ between your reward and the outcome you meant, over 20 episodes
  • b
    Measure your dead-group share — $G=8$ from 32 states; count unanimous groups
  • c
    Audit the top five — read your highest-reward episodes; the hole in $r$ lives there
Hand-over
In ten minutes you watch policies compete under rewards you wrote. That is the verifier problem — and these three checks say whether the leaderboard measures what you meant.
Checklist items correspond to: Part VII · the gate; Part VII · the loop; Part IV · the metric is the confound; Part V · the scaffold confound; Part VI · the correction record and the coverage failure (backup); Part VII · serving (backup). Exercises use only the tournament environment and a spreadsheet.
Part VII · backup · limitations

Limitations of the local experiments and research-system evidence

1

Not a frontier-scale result. 1M–7.6M-parameter cores on a laptop-class accelerator reproduce the mechanisms of Parts III–V; they transfer no capability claim to large models.

2

Not evidence of a reliable gain. One run of five improved held-out accuracy; one was flat, one went backwards, two were dead. Single seeds throughout. Evaluation excludes the RL pool; earlier-stage overlap is not ruled out.

3

Not evidence that clipping was inert. p4-final logged nonzero clip_frac despite one inner epoch. Report the actual local clipped objective and scoring conventions.

4

Not an evaluated research system. The architecture is inspectable; no benchmark evaluation of its output — MLE-bench, RE-Bench, PaperBench or a human baseline — is evidenced in the inspected repository.

What it is

An existence proof that the whole chain — curate, distill, verify, optimize, serve — can be run, instrumented and audited end to end by a small group, and that doing so surfaces exactly the pathologies the literature describes. The two dead runs are the most useful thing in it.

Transferable
Not the stack — every component has substitutes named earlier. The discipline: enable zero-observed-answer-support blocking; check broader readiness separately, log clip_frac so you know which algorithm ran, hash the checkpoint you benchmarked, check the format contract across every stage boundary, and publish the runs that produced nothing.
Limitations of my unpublished experiments. The serving microbenchmark, local objective, research workflow and format-contract failure are documented in the adjacent backup slides; no research-agent benchmark performance is claimed. Sources: [91] · [92].
Part VII · 7.6 what to work on

Research directions in agentic RL and scientific discovery

theory

Reward redistribution for chains of thought

The classical machinery exists; almost nobody has applied it to token or turn credit.

measurement

The six-condition pass@$k$ experiment

Part IV's experiment. Nobody has run it.

theory + practice

Verifier error theory

How do false positives and negatives in $\mathcal{V}$ propagate into policy bias?

measurement

Proxy–objective rank correlation, as standard practice

Cheap, decisive, almost never done.

algorithms

Sample-efficient RL against instruments

350 iterations of beam time. Connect LLM-RL to model-based RL and experimental design.

objective

An objective that rewards novelty

Every verifier here scores correctness. None scores interestingness.

References · I · foundations, estimators

Classical RL, LLM post-training, estimators.

[2]Sutton, McAllester, Singh, Mansour, Policy gradient methods for RL with function approximation, NeurIPS 1999.
[3]Kakade & Langford, Approximately optimal approximate RL, ICML 2002.
[4]Schulman et al., Trust Region Policy Optimization, ICML 2015, arXiv:1502.05477.
[7]Schulman, Approximating KL Divergence, joschu.net/blog/kl-approx.html, 2020.
[11]Korbak, Perez, Buckley, RL with KL penalties is better viewed as Bayesian inference, EMNLP Findings 2022, arXiv:2205.11275.
[12]Rafailov et al., Direct Preference Optimization, NeurIPS 2023, arXiv:2305.18290.
[19]Chowdhury, Kini, Natarajan, Provably Robust DPO, arXiv:2403.00409.
[31]MiniMax, MiniMax-M1 (CISPO), arXiv:2506.13585.
Paper titles and identifiers link directly to the cited online sources. Blog posts and technical reports are identified separately from published papers.
References · II · verification, boundary debate, agents

RLVR, the pass@$k$ debate, agentic RL and infrastructure.

[65]METR, Clarifying limitations of time horizon, metr.org/notes, 2026-01-22.
Direct source links for verification, agent learning and evaluation. A citation identifies the source; it does not establish independent reproduction.
References · III · discovery, disputes, methods

Scientific discovery, critiques and corrections

[70]Fawzi et al., Discovering faster matrix multiplication algorithms with RL (AlphaTensor), Nature 610:47, 2022.
[71]Mankowitz et al., Faster sorting algorithms discovered using deep RL (AlphaDev), Nature 618:257, 2023, DOI 10.1038/s41586-023-06004-9.
[72]Romera-Paredes et al., Mathematical discoveries from program search with LLMs (FunSearch), Nature 625:468, 2024, DOI 10.1038/s41586-023-06924-6.
[74]Trinh et al., Solving olympiad geometry without human demonstrations (AlphaGeometry), Nature 625:476, 2024.
[75]Hubert et al., AlphaProof: Olympiad-level formal mathematical reasoning with reinforcement learning, Nature 651:607–613, DOI 10.1038/s41586-025-09833-y (online 2025-11-12).
[77]Ospanov, Farnia & Yousefzadeh, miniF2F-Lean Revisited (introduces miniF2F-v2), arXiv:2511.03108.
[78]Degrave et al., Magnetic control of tokamak plasmas through deep RL, Nature 602:414, 2022.
[79]Kain et al., Sample-efficient RL for CERN accelerator control, Phys. Rev. Accel. Beams 23:124801, 2020.
[80]Seo et al., Avoiding fusion plasma tearing instability with deep RL, Nature 626:746, 2024.
[82]Cheng et al., An Updated Assessment of Reinforcement Learning for Macro Placement, IEEE TCAD 45:3654–3668, DOI 10.1109/TCAD.2025.3644293.
[83]Markov, Reevaluating Google's Reinforcement Learning for IC Macro Placement, CACM 67:60–71, 2024, DOI 10.1145/3676845.
[84]Merchant et al., Scaling deep learning for materials discovery (GNoME), Nature 624:80, 2023.
[85]Cheetham & Seshadri, Artificial Intelligence Driving Materials Discovery?, Chem. Mater. 36:3490, 2024.
[86]Szymanski et al., An autonomous laboratory for the accelerated synthesis of inorganic materials, Nature 624:86, 2023; Correction Nature 650:E1, 2026 (title amended, count revised to 36/57).
[87]Boiko et al., Autonomous chemical research with large language models (Coscientist), Nature 624:570, 2023.
[88]M. Bran et al., Augmenting large language models with chemistry tools (ChemCrow), Nat. Mach. Intell. 6:525, 2024.
[96]Srinivas et al., Gaussian Process Optimization in the Bandit Setting (GP-UCB), ICML 2010.
[97]Bengio et al., Flow Network based Generative Models (GFlowNets), NeurIPS 2021, arXiv:2106.04399.
[99]Tiapkin et al., Generative Flow Networks as Entropy-Regularized RL, AISTATS 2024.
[101]Kaiser et al., Reinforcement learning-trained optimisers and Bayesian optimisation for online particle accelerator tuning, Sci. Rep. 14:15733, 2024, DOI 10.1038/s41598-024-66263-y.
[103]Arjona-Medina et al., RUDDER: Return Decomposition for Delayed Rewards, NeurIPS 2019, arXiv:1806.07857.
[105]Vamplew et al., Scalar reward is not enough, JAAMAS 36:41, 2022 · Silver et al., Reward is enough, Artificial Intelligence 299, 2021.
Direct sources include the original papers and their corrections/addenda. My unpublished experiments are not attributed to these publications.
01/01

Contents

← → navigate · O index · N presenter notes · F fullscreen · P export PDF · deep links #/n