Papajams/beam-audit-bench

Beam Audit Bench

13 claims across two theory papers · 8 with machine-checkable answer keys · deterministic grader, no LLM judge · 4 models, 20 recorded RL episodes · every attempt preserved — crashes included

Ground-truth benchmark of audit-script generation: can a model read a scientific claim and write self-contained numerical code that recovers the paper's result — with a mandatory positive control?

Keyed-task episode success in the RL environment. Beam 4/4; Claude Opus 5.5 0/4 on the same tasks — a contract failure, not a science failure (its scripts are in rl_env/). All episodes published.

CA C2 (D-ball exponents): for Beam the derivation sits past the 20k- char excerpt window; the full paper unlocks it. Opus's excerpt success is the honest counterpoint — also published.

Beam self-critique -> Beam re-audit flips CA C1 from falsified (nu = 1.476) to supported (nu = 1.0044) with zero human feedback; verify_gain-flagged.

Built from Lemma, an AI-scientist pipeline that audits scientific claims and distrusts itself.

Why this benchmark exists

During the Lemma audits of two theory papers we hit a hard capability boundary: free 27B-class models could not implement the papers' closed- form dynamics (they produced power-law exponents of ~6000 where the correct answer is 1.5-5.5), while stronger reasoning models recovered them in one generation. Those claims have hand-verified reference implementations written by a human reviewer — the reference's recorded metrics are the answer key, so grading is automatic and needs no LLM judge.

Tasks

13 claims across two papers:

• ca-grokking — Žunkovič & Ilievski, JMLR 25 (2024), arXiv:2210.15435: grokking phase transitions in local-rule learning (C1-C6; C5 is gpu-small and carries no CPU reference).
• icl-bayes — arXiv:2510.10981, 'ICL Is Provably Bayesian Inference' (C1-C7).

8 claims carry machine-checkable answer keys (key_strength per claim). Of those, 5 also ship the reviewer's hand-verified reference implementation (references/) with its captured answer key in the task card's reference_summary; the other 3 use exact closed-form targets from the paper's theorem (e.g. nu = 1.0). The remaining claims have no key and are graded for control honesty only — their verdicts are flagged self-reported.

Grading

Each accepted attempt's SUMMARY_JSON is checked (see grader.py):

1. Ground truth: metrics match the reference answer key within tolerance (task-specific, e.g. |nu - 1.0| <= 0.05 for C1).
2. Positive control: mandatory — a correct number with a failed or missing control scores at most 0.5 (dropping the control is the cheap way to game a criterion).
3. Verdict consistency: supported with failing metrics, or falsified while the metrics pass the key, is a self-contradiction (a real failure mode we observed and now machine-check).

Score 1.0 = reference recovered + control passed + verdict supported. 0.7 = reference recovered but under-claimed (inconclusive/falsified). Failed and crashed attempts are preserved in model_runs/ — cherry- picking is impossible because every attempt is recorded.

Headline results (2026-10-22, Beam 1.0 501B A23B via HF Inference Providers)

Bake-off gate — the single task that broke every free 27B-class model in the original audits (implement the CA-grokking 1D closed- form dynamics, recover critical exponent nu = 1.0):

Model	Result	Note
RunInfra Qwen 27B	nu = 6779	recorded bake-off, 2026-08-16
DeepSeek V4 Pro	nu = 6072	recorded bake-off, 2026-08-16
Orca Flash / Pro	crashed / timed out	recorded bake-off, 2026-08-16
Kimi K3	nu = 0.9911	single generation, 92s, 2026-08-16
Beam 1.0 501B	nu = 0.9974	single generation, 29.5s, 2026-10-22

(Full data incl. the documented first-attempt budget trap: bakeoff_results.json.)

Clean-conditions flips — claims the recorded 27B/Kimi rounds left inconclusive after multiple rounds of human feedback:

• icl-bayes/C2 (Bayes Gap decreases with context): supported by Beam in 2 attempts, control passed.
• icl-bayes/C5 (Bayes Gap tracks input-distribution shift): supported in 1 attempt (corr(W1, Bayes Gap) = 0.96).
• icl-bayes/C1 (risk identity R = RBG + RPV): Beam recovered it in one attempt, rel_diff = 0.0008 — the recorded 27B rounds took 8 attempts plus a hand-written reviewer reference.

Honest misses (kept as falsified, not patched) — Beam's own implementations of ca-grokking C1 and C2 produced wrong exponents (nu = 1.476 and 0.075 vs targets 1.0 and (D+1)/2) while their positive controls passed. Lemma's contract reports that as the model's implementation failing the claim's criterion — falsified, with the metrics visible for triage. (In the recorded rounds those same claims were recovered only after human feedback.md + reviewer references; see the -recorded runs.)

Control honesty is scored, not assumed: ca-grokking/C5 and icl-bayes/C6, C7 came back inconclusive because their own positive controls failed — the validator refuses to score a verdict built on a broken statistic.

Self-improvement loop — after the clean CA round, Lemma's improve loop ran with Beam in BOTH roles: reviewer-persona drafts feedback.auto.md from each failure's script/output/trace, then Beam re-audits with it as advisory input. No human wrote a word. Result: C1 flipped falsified → supported — Beam's reviewer diagnosed the exact bug (unshifted training distribution, fit over the whole pre-horizon instead of the asymptotic window) and Beam's auditor implemented the fix: nu = 1.0044 (target 1.0 ± 0.05), control slope exactly 1.0. The flip is flagged in the round record's verify_gain — any flip TO supported post-feedback is the reward-hacking direction, so it is marked for eyeballing and the metrics are published alongside it. C2/C4/C5 stayed put (honestly).

RL environment episodes (rl_env/rollout_*.json) — reference- keyed tasks driven through the env by several models. One line per recorded episode, generated from the rollout files:

• ca-grokking_c1_ANTHROPIC_r1: never recovered the key — best reward 0.0 after 3 attempts
• ca-grokking_c1_ANTHROPIC_r2: never recovered the key — best reward 0.0 after 3 attempts
• ca-grokking_c1_BEAMHF_r1: reward 1.0 reached on attempt 1 of 1
• ca-grokking_c1_BEAMHF_r2: reward 1.0 reached on attempt 3 of 3
• ca-grokking_c1_KIMI_r1: reward 1.0 reached on attempt 2 of 2
• ca-grokking_c1_RUNINFRA_r1: reward 1.0 reached on attempt 3 of 3
• ca-grokking_c1_RUNINFRA_r2: never recovered the key — best reward 0.0 after 3 attempts
• ca-grokking_c2_ANTHROPIC_excerpt_r1: reward 1.0 reached on attempt 3 of 3
• ca-grokking_c2_ANTHROPIC_excerpt_r2: never recovered the key — best reward 0.0 after 3 attempts
• ca-grokking_c2_ANTHROPIC_full_r1: never recovered the key — best reward 0.5 after 3 attempts (full paper context)
• ca-grokking_c2_ANTHROPIC_full_r2: never recovered the key — best reward 0.0 after 3 attempts (full paper context)
• ca-grokking_c2_BEAMHF_excerpt: never recovered the key — best reward 0.0 after 3 attempts
• ca-grokking_c2_BEAMHF_full: reward 1.0 reached on attempt 3 of 3 (full paper context)
• icl-bayes_c1_ANTHROPIC_r1: never recovered the key — best reward 0.0 after 3 attempts
• icl-bayes_c1_ANTHROPIC_r2: never recovered the key — best reward 0.0 after 3 attempts
• icl-bayes_c1_BEAMHF_r1: reward 1.0 reached on attempt 1 of 1
• icl-bayes_c1_BEAMHF_r2: reward 1.0 reached on attempt 2 of 2
• icl-bayes_c1_KIMI_r1: reward 1.0 reached on attempt 2 of 2
• icl-bayes_c1_RUNINFRA_r1: reward 1.0 reached on attempt 3 of 3
• icl-bayes_c1_RUNINFRA_r2: reward 1.0 reached on attempt 2 of 2

Episode success on keyed C1 tasks: ANTHROPIC 0/4; BEAMHF 4/4; KIMI 2/2; RUNINFRA 3/4. All runs are published — including episodes that never recovered (crashes, missing metrics, off-target fits).

Keyed C1 tasks were run multiple times per model (r1 = first published episodes; r2 = re-runs after the env started recording every script source). Run-to-run variance is real and preserved: Beam reached reward 1.0 in every episode; the 27B-class model reached 1.0 in three of four — in the episode it failed, it crashed once, dropped the nu metric once, and fit nu = 0.5 once. Where a weaker model succeeded, early attempts often omit the positive control until the environment's observation says so — the control discipline is mechanically teachable.

Long-context ablation (ca-grokking_c2, the ball-model exponent claim): with the pipeline's 20k-char excerpt, Beam re-derives the 1D model and reports nu_D2/D5/D10 = 2/5/10 — best reward 0.0 in both runs. With the FULL paper (119,673 chars), Beam recovers the D-dimensional series (1.5001, 3.0174, 5.4117 vs targets 1.5/3.0/ 5.5): reward 1.0, control passed. For Beam, the D-ball derivation sits past the excerpt window; the long context is what unlocks the claim. (Claude Opus 5.5 recovered the same series once FROM the excerpt — the physics is derivable with less context by a model that gets the rest of the contract right; see the next section.) Trajectories record the full script source of every attempt, so each reward and integrity flag is inspectable.

Claude Opus 5.5 (closed frontier) in the same environment — 8 episodes (2 runs x ca_c1, icl_c1, ca_c2 excerpt, ca_c2 full), reward 1.0 in ONE: episode success is 1/8 vs Beam's 4/4. The failure mode is visible in the preserved scripts and is a contract failure, not a science failure: on the keyed C1 tasks Opus computed the physics but reported it under metric names outside the grader's alias list (median_nu, nu_se_bootstrap, rel_diff=not_computed) or returned inconclusive without attempting the computation (claim_quantity_computed=false) — across all 6 C1 attempts, never once emitting the key metric under a graded name. The environment's observation names the failed check each time; Opus did not converge on the naming contract within 3 attempts. The single 1.0 is the harder ca_c2 task, recovered from the 20k excerpt alone with a genuine full-precision fit. Verifiable rewards measure more than physics: auditability — reporting what you measured under the contracted names, with the mandatory control — is part of the skill, and on this axis the 501B open model beats the closed frontier model.

Model runs

• beam-1.0-501b-clean-ca on ca-grokking: 2/4 exact keys recovered (rate 0.5) — of which 2 by the model's own scripts; 5 claims keyed, 6 audited
• beam-1.0-501b-clean-icl on icl-bayes: 1/2 exact keys recovered (rate 0.5) — of which 1 by the model's own scripts; 3 claims keyed, 7 audited
• qwen27b-kimi-recorded-ca on ca-grokking: 4/4 exact keys recovered (rate 1.0) — of which 3 by the model's own scripts, 1 via the hand-verified reviewer reference; 5 claims keyed, 6 audited
• qwen27b-kimi-recorded-icl on icl-bayes: 2/2 exact keys recovered (rate 1.0) — of which 1 by the model's own scripts, 1 via the hand-verified reviewer reference; 3 claims keyed, 7 audited

Runs labelled -clean start agent-generated from scratch: the model sees only the claim and the paper text — no human feedback, no reference implementations, no prior attempts. The CA run includes one subsequent self-improvement round (Beam-authored advisory feedback, still zero human input; see above). Runs labelled -recorded are the original Lemma rounds (weaker model + iterative human feedback.md corrections + hand-verified reviewer references) included as the 'before' state of the same claims. All audits ran through Lemma's auditor (<=3 attempts per round, self-contained numpy scripts, mandatory positive control). Every attempt is preserved — including crashed and summary-rejected ones.

RL environment (verifiable rewards, no LLM judge)

The bench doubles as an RL environment (rl_env/beam_audit_rl_env.py): each task is an episode of up to 3 attempts, the action is a full self-contained audit script, and the reward is the deterministic grader above — never an LLM judge. The observation after each failed attempt is exactly what Lemma's auditor feeds its next attempt: exit code, output tail, and which key checks failed. Reward ladder and reward-hacking guards are in rl_env/reward_spec.json; recorded episodes (Beam vs a 27B-class model, same tasks) are in rl_env/rollout_*.json.

from beam_audit_rl_env import BeamAuditEnv, rollout
env = BeamAuditEnv("ca-grokking_c1")
obs, info = env.reset()
obs, reward, done, info = env.step(script_source)
# or drive a full episode with any OpenAI-compatible endpoint:
rollout("ca-grokking_c1", provider="BEAMHF")

Training against this environment

The environment is deliberately consumable as-is by an RL stack:

• Action space: one string — a complete self-contained Python audit script. Multi-turn: up to 3 attempts per episode, so a trajectory is (prompt, script, obs) x3 at most.
• Observation: exit code + stdout/stderr tail + the grader's failed key checks (identical to Lemma's auditor feedback, so skills learned here transfer to the full pipeline).
• Reward: the deterministic 6-level ladder in rl_env/reward_spec.json — no LLM in the loop, so rewards are reproducible and safe to average across GRPO group rollouts. The 0.25 caps for hardcoding/fabrication are part of the reward function, not a post-hoc filter.
• Task list: any claim whose key_strength is reference (hand-verified implementation's metrics as the key) or variant (closed-form targets from the paper's own theorem) has a machine-checkable answer — 8 of 13 claims. The rest are honesty-only tasks (useful for shaping against degenerate policies but not for the main reward).
• Sandbox note: step() runs scripts with a wall-time cap in a temp dir but does not OS-isolate them (that is Lemma's room_sandbox.py territory). For training, point the env at a container or sandbox with network disabled before scaling rollouts.
• Suggested GRPO setup: sample K scripts per attempt, grade each independently (the grader is pure and fast — see grader.py), and use the per-attempt reward as the group signal. The recorded rl_env/rollout_*.json trajectories are a cold-start SFT source: they pair real observations with scripts that earned each reward level.

License & provenance

Task cards and grading rules: CC-BY-4.0. Generated scripts: preserved verbatim as model output. Reference implementations: written by the Lemma reviewer (Udi / Papajams), hand-verified before acceptance.