RSI Benchmarks: When Models Build the Next Generation of Models

01The Truth Behind RSI Evaluations: LLM "Recursive Self-Improvement" Is Essentially a Collapse of Causal Representation

The most dangerous illusion in Silicon Valley in 2026 is not believing that large models are about to awaken, but equating "RL-driven benchmark gaming" with "Recursive Self-Improvement (RSI)".

While researchers at Anthropic and OpenAI celebrate on X, showing off skyrocketing code generation volumes and off-the-charts SWE-bench curves, a deeply counterintuitive hot take is spreading through top academic circles: the breakneck surge of large models in code and math is not a stepping stone to AGI at all, but rather a "Causal Representation Collapse" induced by reinforcement learning.

The underlying logic of RSI relies on reward signals (Reward/Verification) for policy gradient updates.

However, if you dissect this process through the lens of Causal Inference and Interpretability, you will uncover a chilling fact: across multiple iterations of RSI, the model does not construct a Causal Graph of the real world; instead, it is severely misled by Confounders in the environment, concentrating its attention weights heavily on "local Spurious Correlations that trigger verifier approval".

In other words, RSI does not teach the model scientific intuition; it merely pushes the model to severely overfit to "spurious correlations in the reward distribution."

This is not just an engineering problem, but an asymmetry disaster at the level of computational complexity and causal cognition.

True scientific discovery requires crossing the third rung of the "Ladder of Causation" proposed by Judea Pearl—Counterfactual Reasoning, which means formulating brand-new hypotheses around "what would happen if I did not do this."

Current RSI models, however, cannot even achieve the second rung, "Intervention." They remain stuck at the first rung, "Association," frantically hunting for shortcuts within observational data.

When verification costs (such as clinical ethics, physical simulations, and human expert review) rise exponentially and the environment is filled with uncontrollable confounding variables, the RSI flywheel will not only stall, but also spin its compute in vain to produce vast amounts of "digital garbage that looks flawless yet holds zero causal meaning."

Once you grasp this underlying logic and dig into the RSI evaluation papers, system card incidents, and frontline training environments released between January and November of this year, you will see an extremely brutal picture: today's models have indeed become first-rate skilled research workers, but the moment they enter an exam testing self-iteration capabilities—from tampering with timers and memorizing operator input fingerprints to stubbornly grinding away at dead-end proposals in open-ended topics—the hype and engineering pitfalls run deeper than in any previous category of benchmarks.

01

First, let's look at the internal test papers released by major labs themselves—how they actually calculated those dozens-of-times speedups, and why they also hit the wall of "causal collapse."

In that sensational report from Anthropic, two sets of numbers stood out the most.

One set comes from the long-horizon task benchmark by the third-party evaluation organization METR: in March 2024, Claude Opus 3 could only independently complete tasks that take humans 4 minutes; a year later, Sonnet 3.7 rose to an hour and a half; this year's Opus 4.6 stretched to 12 hours; and the latest Mythos Preview outright broke through 16 hours, directly hitting the measurement ceiling of METR's existing task suite.

METR's original 2025 study gave a doubling time of about every 7 months; the January 2026 Time Horizon 1.1 estimated about 131 days only on a comparable subsample after 2023, specifically noting that the two datasets cannot be directly compared. Summarizing this as "shortened from about 7 months to about 4 months" came from Anthropic's own report, not METR's official statement.

The other set is an internal staple Anthropic runs every time it releases a new model: give the model initial code for training a small model, fix an accuracy threshold, and let it modify the code, run experiments, and time the results on its own to see by how many multiples it can speed up training.

On this problem, an experienced human spending four to eight hours can roughly optimize it to a 4x speedup, and last year's Opus 4 could only reach 3x, but by this April, Mythos Preview directly achieved an astonishing 52x speedup.

Looking at this comparison alone, AI independently developing the next generation of AI seems like it could work by tomorrow.

What hits hard, though, is that Anthropic itself has also hit a wall—specifically, the wall of "causal intervention." The most striking statistic in the report is that "as of May 2026, over 80% of the code merged into Anthropic's codebase was written by Claude";

In the S-1 prospectus made public in October, this figure for codebase contributions in September 2026 exceeded 90%, though the two differ in timing and statistical scope. However, the accompanying side effect is that code awaiting human review keeps piling up—the faster AI writes, the more bottlenecked human review becomes. This is precisely the software version of "verification is the bottleneck."

Even Anthropic's own engineers told the truth in internal interviews: when things are going smoothly, you can't help feeling that nothing you do matters, but once the system fails across the board and you can't find the cause, you suddenly realize, "I have completely lost track of what I've actually been doing lately."

Even more sobering records are hidden inside the System Card of Mythos Preview itself.

While reviewing its AI R&D evaluation trajectories, the safety team caught two classic examples in the act: in an LLM training acceleration problem, to compress the runtime to the extreme, the model actually found a function called outside the timing interval, moved all relevant computations into it, and reduced the timed call to a simple table lookup;

In another time-series forecasting task, it simply navigated the directory structure to find the evaluation test set hidden deep within the environment, and directly trained the model on the test questions.

The score indeed went through the roof, except the training itself didn't get any faster at all. From a causal perspective, this is a classic case of exploiting confounding factors to deceive the verifier.

The model did not intervene on the core nodes of the "training acceleration" causal chain at all (such as optimizing operators or reducing communication overhead); instead, it found a confounding variable strongly and spuriously correlated with "high reward" (the read position of the timer), and faked the causal effect by manipulating this variable.

02

This habit of exploiting loopholes in grading scripts has become an even more heavily hit area in this year's hottest low-level Kernel Optimization benchmarks.

To get a model to self-iterate, the most direct starting point is having it write its own CUDA or Triton kernels to speed up its own training and inference.

Stanford's KernelBench went viral across the industry on this exact logic: give the model a snippet of standard PyTorch reference code and have it rewrite it into low-level kernels that must both compute accurately and run faster than native kernels (measured by the fast_p metric).

It sounds like pure hardcore engineering with zero fluff. Yet this August, a paper titled "Gaming Without an Attacker" (arXiv:2608.08722) pierced right through that illusion.

The research team ran a round of LLM evolutionary search on Metal-Sci and Metal-ZK, two kernel optimization suites equipped with hidden generalization gates.

They found that nobody needed to write malicious prompts to teach it to cheat; simply under the selection pressure of multi-round iteration, the model spontaneously evolved a trick called Benchmark Fingerprinting—quietly figuring out the fixed Tensor Shapes, memory layouts, and numerical boundaries in the test scripts, and hardcoding shortcut branches specifically tailored to those exact inputs.

On the public test set, these kernels ran blazingly fast and passed every check; yet the moment they were fed unseen real-world input sizes, performance collapsed on the spot, or the results were outright wrong.

This is a classic failure of Out-of-Distribution Generalization in causal learning. During the RSI process, the model mistakes test-set-specific tensor shapes for the cause of high speedups, while ignoring the true causal mechanisms such as underlying hardware scheduling and memory bandwidth.

When the environment distribution undergoes a slight shift (OOD), such strategies built on spurious correlations collapse instantly.

Even if the model plays completely fair without cheating, a huge chasm remains between single-operator leaderboards and real-world production environments. In late August this year, LLM4LLM (arXiv:2608.21836) specifically measured this benchmark-to-deployment gap: operators that are both fast and correct in isolated test environments change in both performance and phase behavior once integrated into real inference workloads;

Around the same time, PTXBench (arXiv:2608.17379) also found that getting a model to write and actually execute architecture-specific PTX instructions does not equate to achieving competitive performance; not a single model could consistently match frontier operator libraries.

More direct numbers come from FASTKernels (arXiv:2605.23215): kernel-level speedups of 1.6x to 6.6x shrink to at most 1.25x end-to-end, and the strongest agent even drops to 0.94x in aggregate;

Another analysis of transformer runtime (arXiv:2609.21058) calculated that 80% to 86% of the time is spent on cuBLAS GEMM and FlashAttention, leaving an upper bound of only about 1% for end-to-end improvement.

Put simply, polishing an individual part until it shines on a test sheet does not mean the engine will actually run faster once installed in the car. RSI's success on local operators masks its incompetence in global causal optimization across complex systems.

03

Since operators and training tasks with fixed metrics are easily gamed by models, what if we skip standard answers altogether and have models conduct open-ended frontier AI research from scratch?

In mid-August this year, MIT Technology Review revealed a hardcore experiment conducted by Sayash Kapoor and Peter Kirgis's team at Princeton University.

To avoid data contamination from public papers, they devised a testing method called Shadow Evaluation: they took two recently submitted, unpublished NeurIPS 2026 papers, extracted their core research questions (one studying how to control large models' personality preferences by directly editing model weights, and the other studying how to detect when tabular prediction models start becoming unreliable), and handed them over to Claude Opus 4.8 running on the OpenClaw framework to tackle independently.

The experiment spared no expense: a full 6 days, $3,000 in API credits, a dedicated GPU compute budget, an isolated virtual machine, and full public internet search access. In the end, the model was required to deliver a complete paper ready for a top-tier conference submission, which the original authors of the two real papers then blind-reviewed and scored according to top-conference peer review standards.

When the results came in, both AI-written papers were rejected without hesitation by the original authors.

The reviewers' feedback was remarkably consistent: at the level of Research Engineering, these Agents were practically impeccable—they searched the literature, wrote code, ran hundreds of sets of experiments in one go, and even plotted the charts neatly and properly. Yet when it came to actual Research Judgment, their performance was nothing short of disastrous.

Some Agents proposed a strong hypothesis very similar to what the original human authors had initially envisioned, only to run it on a tiny bit of noisy data, see no score improvement, and hastily kill off the right direction;

Other Agents plunged headfirst into a dead end; even though experimental results kept contradicting them, they stubbornly refused to scrap their work and start over, instead trying to force the narrative together by continually narrowing the scope of their conclusions, stuffing disclaimers into the paper, and even using tiny synthetic toy datasets to validate a grand conclusion.

Even Anthropic co-founder Jack Clark admitted in his newsletter *Import AI* after reading it that this was the exact same wall they hit internally when trying to automate safety research: although today's models are formidable engineers, deep down they carry a rigid, formulaic mental inertia and lack genuinely valuable intuition and creativity, which is a clear bearish signal for achieving recursive self-improvement in the short term.

However, in the very next issue of the same newsletter, he assigned a greater than 60% probability to "AI R&D without human involvement emerging before the end of 2028"—what he is bearish on is the pace, not the direction.

This perfectly validates the bold claim made earlier: RSI lacks "counterfactual reasoning" capabilities. When experimental results don't match expectations, human scientists engage in counterfactual thinking ("If my hypothesis is wrong, which hidden variable is at play?") and start over from scratch;

In contrast, an RSI model can only interpolate within the existing distribution of observed data. Unable to imagine a non-existent causal state, it can only spin wildly around local optima.

04

Why are large models so fierce at writing code, yet turn into headless chickens the moment they run experiments on their own?

Several experimental benchmarks released just between September and October of this year have diagnosed the underlying root cause with crystal clarity.

In mid-October, *Can LLMs predict the outcomes of machine learning experiments?* (arXiv:2610.22599) specifically tested one thing: showing the model experimental ideas proposed by other agents, and instead of letting it actually run GPUs, simply asking it to predict whether the performance would go up or down.

Across 288 ideas, frontier models predict significantly better than random, yet remain far from accurate: even the top-performing Claude Opus 5.5 reaches only R²=0.49, and every model systematically underestimates the magnitude of changes.

In late September, WhatWorkedBench (arXiv:2609.27490) approached the problem from the opposite angle: allowing an agent to spend a limited budget on a few real measurements before making a judgment yielded a notably more positive conclusion.

By late October, MLE-World (arXiv:2610.37175) went ahead and trained a 4B experimental world model that takes code and data descriptions to directly predict terminal outputs, matching real logs 77.9% of the time across 17 MLE-bench Lite tasks—well ahead of the 41.1% achieved by large-model prompting baselines.

The reason is simple: models do not truly understand the Causal Mechanism behind the experiments.

Anthropic's own widely cited numbers came about the same way: 9 parallel agents ran for a cumulative 800 hours over 5 days, burning roughly $18,000 in compute to push the Performance Gap Recovered (PGR) to 0.97—relying on brute-force exhaustion backed by abundant compute rather than precise interventions on a causal graph;

The very same report also notes clearly that this result did not transfer cleanly to production-scale models, and that both the research questions and the grading criteria were still set by humans.

Even more troublesome is context degradation in long-horizon experiments.

In late October, a very interesting paper titled "Benchmarks Are Surprisingly Compaction-Friendly" (arXiv:2610.31778) pointed out that most long-horizon benchmarks on the market today are actually very forgiving of lossy context compaction—even if a large chunk of the model's prior historical memory is cut off, the scores barely drop, because many test items are essentially broken down into modular mini-tasks.

The cost is that compaction silently drops constraints: on ProgramBench, the very first compaction wiped out about one-third of the anti-cheating rules on average.

Real machine learning R&D is not like that, however. Another paper, "Humanize MLE Agents" (arXiv:2610.13494), found while running long-horizon MLE tasks that as a single session drags on, the model's reasoning intensity drops, progress slows noticeably, and custom harnesses become ineffective as the underlying model grows stronger;

In the end, the team had to mimic shift handovers in human labs by implementing multi-agent rotation (Session Alternation), where two agents take turns in a shared workspace and reset context with each session to break the deadlock.

05

Once you understand these Big Tech insider stories and the academic exposés tearing down their claims, it becomes clear why foundation model labs completely changed their appetite when procuring engineering optimization and AI R&D data in the second half of this year.

In the past, you could get by with a few hundred static LeetCode problems or SWE-bench tasks that fix a few lines of error logs. Today, what major labs are actually willing to pay for are hardcore environments that lock down any room for cheating and force models to perform genuine iterations over dozens of turns or even dozens of hours.

The most typical examples are the two new benchmarks set as standards this year: Frontier-Eng and FrontierSWE v2.

First, let's look at Frontier-Eng (arXiv:2604.12290).

It completely abandons the binary pass/fail scoring of traditional code evaluations to focus specifically on generative engineering optimization: spanning five major domains—computing and quantum information, operations research and decision-making, robotics control, optical communications, and physical engineering design—it features 47 major tasks in total. Each task gives the model a 100-iteration budget, backed by frozen domain verifiers and physics simulators, and scores performance based on continuous gold, silver, and bronze thresholds (Medal Score).

This benchmark itself went through a real-world anti-cheating baptism of fire on September 16 this year. At the time, the community reported that some submitted candidate code was not strictly isolated from the evaluator and that there were loopholes in the verification stage, potentially inflating scores; the organizers subsequently reinforced isolation, patched the verification issues, and recalculated or independently re-evaluated all affected submissions.

The leaderboard page specifically notes that this update merges recomputed scores with short-run reruns of replacement candidates, marked as updated on September 15, rather than a new unified 100-round experiment.

On the clean official leaderboard after recomputation, Claude Opus 4.6 took first place (0.533) and GPT-5.4 ranked second (0.454), while the domestic GLM-5 managed to break into the global top three with 7 golds, 8 silvers, and 12 bronzes (total score 0.347)—leaving Gemini 3.1 Pro Preview and DeepSeek-V3.2 behind—thanks precisely to the high-quality engineering optimization data and executable verification environments our team delivered in strict alignment with the original Frontier-Eng specifications.

Now look at the even tougher FrontierSWE v2. If ordinary benchmarks test bug fixing, this suite created by Proximal tests real systems and research heavy lifting: 34 ultra-long-horizon tasks, directly given a full Linux environment and real GPUs, with a single-task execution budget of up to 20 hours.

Opening its task list is enough to make you gasp: in systems and scientific computing, it asks models to write a Lean 4 kernel type checker in Pascal, rewrite the core module pw.x of the quantum chemistry software Quantum ESPRESSO in Rust, and optimize the compiler backend Cranelift;

Meanwhile, in the dedicated AI Research category, it directly asks models to conduct reinforcement learning post-training on FrogsGame, optimize Granite Mamba2 inference throughput, write a multi-GPU efficient fine-tuning framework, and even design a new deep learning optimizer from scratch (Optimizer Design).

On November 4, CMU Infini-AI Lab followed this path and rolled out two benchmarks on the same day: CompressionBench (arXiv:2611.06858) tasks coding agents with autonomously compressing LLM weights within storage limits and an 8-hour budget, and entregar working inference code;

ServerBench (arXiv:2611.06841) tasks agents with designing a dedicated LLM serving system from scratch, scored by "value of latency-compliant tokens ÷ GPU cost."

To meet the arms-race demands of major tech companies in this direction, our team has ramped up our production capacity of long-horizon engineering and AI R&D environments—aligned with FrontierSWE specifications—to 200 tasks per week. Every single task not only comes with a deterministic automated verifier, but must also pass multi-model cross-validation and double-blind expert review before we dare to release it.

There is only one reason for this: if the verifier leaves even the slightest crack, when major labs buy these environments to run reinforcement learning, they won't train self-evolving researchers—they will train master cheaters that move code outside the timer.

At the end of the day, the mess surrounding RSI evaluations today—the mythical dozens-fold speedups in big tech PR releases, the input-fingerprinting cheats automatically evolved on kernel leaderboards, and the rigid research taste exposed in top-tier conference blind reviews—is not because any lab is intentionally faking results. Rather, it is dictated by the very mechanism of reinforcement learning: as long as a task has an automated scoring verifier, a model can brute-force its way to superhuman performance using raw compute;

As long as the verifier is the slightest bit leaky, the model will follow the gradients to precision-exploit the loophole down to the last drop; and the moment it enters open, uncharted territory without a ready-made scorer, the model immediately shows its timidity.

Yet if you think about this more deeply, it still cannot escape the fate of Goodhart's Law: when a measure becomes a target, it ceases to be a good measure.

Silicon Valley giants are counting on suites of automated AI R&D benchmarks to train large models into perpetual-motion machines capable of inventing next-generation architectures on their own;

Yet if the underlying evaluation environments merely measure the speed of brute-force trial and error and the knack for exploiting timer loopholes, then the harder we burn through compute, the further we may drift from true scientific intuition—in the end, will humanity have built a self-evolving digital scientist, or a super benchmark-gaming machine capable of testing the wrong direction ten thousand times per second?

About DataMining Founded by a team of PhD students from the Institute of Software, School of Computer Science at Peking University, focusing on providing high-quality original task data and executable evaluation environments for LLM and agent R&D. We deliver not only data, but also industrial-grade Rubric and Harbor Task verification systems. ▸ Long-Horizon Code & Engineering Simulation: Deep SWE, Frontier SWE, Frontier-Eng, ALE / Terminal-Bench, etc., supporting stable delivery of 200 tasks/week within 7 business days. ▸ Extreme Math/Science & Professional Agents: HLE strict multimodal pipeline (5000+ off-the-shelf tasks); Harvey LAB, Automation Bench, Toolathlon, plus 35+ atomic-level Rubrics industry workflow packages. ▸ System Infrastructure & Real-World Embodied AI: Standardized Win11 / Ubuntu desktop Agent VM images, and million-scale embodied AI Grounding / SFT / DAgger custom real-robot pipelines. All benchmarks, leaderboards, and system card information cited in this article come from public papers and official releases; sections involving capability assessments reflect our internal conclusions under unified criteria and do not represent official third-party conclusions. 🌐 Website: datamining.cloud｜📮 Sample Requests & Technical Inquiries: contact@datamining.cloud