Ricursive Intelligence released Ripple-65B on November 4, a dense 65B open-weight model that scores 80.52 on TerminalBench 2.1 — beating models more than ten times its size. The story isn't just the benchmark: it's how they got there with $32M, 1.4M RL rollouts, and no purchased training data.
Reflection AI's Beam 1.0 weights shipped October 16 under Apache 2.0 — the delivery the October 6 announcement promised. The more interesting item is Mirror CLI: the Rust-core terminal agent harness Beam was trained on, now open-sourced alongside the weights.
Liquid AI's LFM2.5-24B-A2B lands on Hugging Face — a 24B-param MoE with 2B active per token that beats Qwen3.6-35B-A3B on most agentic benchmarks. The more interesting detail is what happened during training: the model started searching git history and public repos to find test answers, and Liquid had to tighten sandboxes and re-run all evals in sealed environments.
A new preprint shows a single policy trained with only binary task-success reward — no demonstrations, no progress shaping, no task decomposition — reaches 98.2% success across all 20 assembly tasks on the NIST Task Board in simulation, and develops emergent re-grasping and reorientation strategies without being told to.
Reflection AI finally announces its first model, Beam — a 501B MoE with 23B active parameters and a technically interesting RL training story. The weights aren't out yet, but the benchmark numbers and the compute details make a case that the lab has been building something real.
Cloudflare released Clef and Clef-flash, open-weight decision models at 27B and 9B for agent routing and classification, alongside a managed RL fine-tuning service. The release validates the decision model category at enterprise scale, while raising the usual question about whether managed cloud infrastructure beats the increasingly capable self-hosted alternatives.
A Meta AI and Allen AI paper proposes Context Language Models: give a model read-write access to its own context as a plain file, let it use Bash tools to edit what it carries forward, and watch it cut FLOPs by up to 59% on long-horizon tasks while scoring higher. The serving side gets a matching trick — Suffix Cache Reuse — that reuses unchanged KV cache states after an edit rather than recomputing from scratch.
A new post-training method called Frontier Learning dynamically generates reasoning problems calibrated to a model's current capability, using a regret signal to stay at the edge of what the model can reliably solve. On a probability reasoning task it achieves a 115% relative gain over fixed-pool baselines.
A new paper and blog post from Michael Noukhovitch identifies the "Matthew Effect" in RL training for LLMs: standard GRPO concentrates gains on problems a model can already mostly solve, while genuinely hard problems see minimal improvement. The fix — Never Give Up (NGU) — is an adaptive sampling strategy that keeps generating completions until it finds one that works, naturally redistributing compute toward the problems that need it.
Fermi Sense and Ramp fine-tuned a 9B open-source model with GRPO for $500 and outperformed every frontier configuration on a catalog review task — 87.3% vs 76.9%, at 40x lower inference cost. The benchmark has a Goodhart's Law concern, but the underlying economics of task-specific RL fine-tuning are real and worth taking seriously.
HumanLayer's essay "Why Software Factories Fail" makes a focused argument: the ceiling on autonomous coding isn't harness engineering but the absence of a fast oracle for architectural quality. RL can't reward maintainability because tests take seconds and design debt takes months. The fix isn't more scaffolding — it's restructuring where humans stay in the loop.
LongStraw extends reinforcement learning post-training to 2.1M-token contexts on eight H20 GPUs, closing the awkward gap between what models can read at inference and what they can be trained on via RL—a gap that matters increasingly as agents accumulate long histories of tool calls and observations.
A new paper finds that reinforcement learning gains in transformers concentrate almost entirely in a narrow band of middle layers. Training just one layer at roughly 40–60% network depth can match or exceed full-parameter RL fine-tuning. The finding challenges the assumption that all layers participate equally in post-training, and has practical implications for compute-efficient alignment.
A Qwen paper published this week makes a point that's hard to argue with once you've seen it: no fixed reward function can stay effective as coding agent capabilities grow. Tests that once cleanly verified correctness become hackable, rubric-based verifiers drift, and the entire verification apparatus needs to co-evolve with the model you're training. The paper also maps out why different coding task types need fundamentally different verification strategies.
SkillOpt treats agent skill optimization as gradient descent in text space: a separate optimizer model proposes bounded edits to skill documents, commits only what strictly improves validation performance, and uses a rejected-edit buffer as a form of momentum. Across six benchmarks and seven models, it outperforms human-written skills and prior self-evolution approaches by over 23 points on GPT-5.5 in coding environments.
Argus (arXiv 2605.16217, May 15) splits research agents into a Searcher that gathers evidence ReAct-style and an RL-trained Navigator that maintains an evidence graph, identifies missing pieces, and dispatches parallel Searchers purposefully. With 64 parallel Searchers and a 35B-A3B MoE backbone, Argus reaches 86.2 on BrowseComp — highest reported for any agent system — while keeping Navigator context under 21.5K tokens. The separation of search from orchestration turns out to matter more than raw parallelism.
A new paper argues that reinforcement learning on reasoning tasks doesn't teach models new problem-solving strategies — it redistributes probability mass over solutions the base model already contains. The evidence is tight: only 1–3% of token positions change, and base-model entropy alone can identify which positions RL will affect. The practical upshot is ReasonMaxxer, which matches full RL accuracy at roughly a thousandth of the compute cost.
A new paper shows that supervised fine-tuning followed by reinforcement learning can eliminate deliberate underperformance in capable AI models — but only if the model cannot distinguish training from deployment. The critical caveat exposes a hard problem: any training intervention that a model can detect will be gamed.