RST Cuts AI Agent Task Costs to 5 Cents via Recursive Proof Growth

Xiaol.x

AI agent training avoids recursive data collapse when pipelines expand verified executable solutions before generating prompts rather than mutating text descriptions.

AI-assisted summary of How AI Training Tasks Learn to Grow | Recursive Synthesis (RST) Explained — original source. Check the original for full context.

Source published: 2026-08-12

Key ideas

Recursive Synthesis (RST) introduces a framework to grow verified terminal-agent tasks at approximately five cents each, compared to hundreds or thousands of dollars for manual authoring. (0:00)
Across 15 recursive rounds, 639 initial seeds expanded into 37,484 verified tasks while reference solution lengths increased from 67 to 374 lines and DeepSeek-V4-Pro pass@4 dropped from 90% to 2.5%, proving genuine difficulty growth. (3:41)
Training Qwen3.5-27B with agentic PPO using RST environments produced substantial downstream gains, including a 41.16% relative improvement on Terminal-Bench Hard. (6:48)
The core methodology shifts synthetic data generation from prompt mutation to expanding executable proofs first, aligning the environment, verifier, and public instruction afterward. (1:29)

Detailed notes

## Background Published by Xiaol.x on YouTube on August 12, 2026, this explainer examines the paper on Recursive Synthesis (RST), an automated method that generates verified terminal-agent training tasks for roughly five cents each. The video breaks down how RST recursively scales complete executable task bundles across 15 rounds while maintaining strict synchronization between public instructions, environments, reference solutions, and verifiers.

## TL;DR Conventional agent task generation struggles with desynchronized components and expensive human authoring, but RST overcomes this by expanding the executable reference solution before updating the prompt and verifier. By enforcing dual-gated oracle and contract validity alongside strict diversity quotas, the framework grew 639 seeds into 37,484 verified tasks across 15 rounds without suffering validation yield decay. The synthetic tasks proved genuinely harder, causing frozen DeepSeek-V4-Pro pass@4 rates to fall from 90% down to 2.5% as median solution length surged from 67 to 374 lines. Downstream training validated the curriculum's real-world utility, delivering strong supervised fine-tuning improvements and up to a 41.16% relative gain on Terminal-Bench Hard via agentic PPO.

## Atmosphere & style The presentation is disciplined, analytical, and highly structured, carrying the precise and crisp rhythm characteristic of Lean/Leanim-style technical breakdowns. Rather than relying on superficial AI hype, the narrative builds a compelling engineering argument through concrete metrics, lineage traces, and architectural diagrams. Watching the breakdown feels like sitting in an elite computer science seminar that methodically deconstructs an intricate distributed systems problem before demonstrating verified empirical results.

## Bulletin - [00:00](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=0s) Recursive Synthesis (RST) introduces a framework to grow verified terminal-agent tasks at approximately five cents each, compared to hundreds or thousands of dollars for manual authoring. - [03:41](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=221s) Across 15 recursive rounds, 639 initial seeds expanded into 37,484 verified tasks while reference solution lengths increased from 67 to 374 lines and DeepSeek-V4-Pro pass@4 dropped from 90% to 2.5%, proving genuine difficulty growth. - [06:48](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=408s) Training Qwen3.5-27B with agentic PPO using RST environments produced substantial downstream gains, including a 41.16% relative improvement on Terminal-Bench Hard. - [01:29](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=89s) The core methodology shifts synthetic data generation from prompt mutation to expanding executable proofs first, aligning the environment, verifier, and public instruction afterward.

## Key takeaways - [00:44](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=44s) Terminal tasks consist of four coupled gears—public instruction, runnable environment, reference solution, and private verifier—which must stay strictly synchronized to avoid corrupted training feedback. - [00:44](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=44s) Conventional task generation fails by mutating prompts in isolation, leading to unrunnable environments, missing tool dependencies, or misaligned test assertions. - [01:29](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=89s) RST adopts the principle of growing the reference solution and state dependencies first before updating the environment, verifier, and public prompt. - [02:13](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=133s) Dual validation gates enforce Oracle Validity (the reference solution passes the verifier in a clean sandbox) and Contract Validity (all checked requirements are either disclosed in the prompt or discoverable in the workspace). - [02:13](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=133s) Contract validity prevents teacher cheating by rejecting tasks where private tests evaluate unstated requirements that only the oracle knows. - [02:52](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=172s) A traced JSON lineage illustrates how complexity compounds over 15 rounds from a simple 10-line diff script into a 347-line diagnostic and configuration reconciliation workflow. - [03:41](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=221s) Synthesis yield remained stable between 498 and 572 accepted tasks per 1,000 attempts, with sandbox pass rates consistently between 74.5% and 81.5% across 15 rounds. - [04:27](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=267s) A fixed DeepSeek-V4-Pro baseline demonstrated monotonic performance degradation from 90% pass@4 down to 2.5%, confirming that task difficulty stems from real operational depth rather than superficial verbosity. - [05:17](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=317s) To prevent recursive data collapse, RST enforces strict diversity quotas across rewrite operators and lineage families, keeping 36 of 40 discrete operators active through round 15. - [05:17](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=317s) Semantic similarity between tasks creeps upward across recursive rounds, indicating that deduplication and diversity quotas are essential safeguards against homogenization. - [06:05](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=365s) Supervised fine-tuning on rollout trajectories improved Qwen3.5 27B and 122B models across benchmarks, with zero 13-token n-gram overlap against test evaluation sets. - [06:48](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=408s) Agentic PPO training yielded significant improvements across benchmarks, highlighted by a jump from 22.67% to 32.00% on Terminal-Bench Hard. - [07:36](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=456s) The framework establishes an automated, self-sustaining curriculum that reuses validated executable bundles as seeds for subsequent generation rounds. - [08:16](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=496s) Current limitations include reliance on initial verifier correctness, unproven transfer to GUI and general OS settings, and lack of guarantees for infinite recursion without quality degradation.

## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=0s) The Five-Cent Paradox and the Four-Gear Contract

Authoring serious, long-horizon terminal-agent tasks traditionally requires substantial human engineering, routinely costing hundreds or even thousands of dollars per verified instance. Against this backdrop, Recursive Synthesis (RST) reports an astonishing figure: roughly five cents per accepted, verified task. The bottleneck in authoring long-horizon tasks has never been prompt writing—it is the grueling challenge of maintaining strict alignment across four tightly coupled components over dozens of dependent operations: the public instruction, the runnable sandbox environment, the reference solution, and the private verifier. If even a single link desynchronizes, the agent ends up training against nonsense. RST bypasses this failure mode not by manufacturing cheap text prompts, but by producing cheap, verified, executable work with genuinely rising difficulty.

```mermaid flowchart TD accTitle: The Four-Gear Task Bundle Contract accDescr: Diagram showing how instruction, environment, reference solution, and verifier must stay synchronized.

subgraph TaskContract["Executable Task Bundle"] direction TB INST["Public Instruction (Specifies success)"] ENV["Runnable Environment (Tools & system state)"] SOL["Reference Solution (Executable ground-truth proof)"] VER["Private Verifier (Validates final state)"] end

INST <--> ENV ENV <--> SOL SOL <--> VER VER <--> INST ```

To understand the core problem, picture a terminal task as four interconnected gears. The instruction communicates what success looks like to the agent; the environment specifies available tools and workspace state; the reference solution proves that the task can actually be completed end-to-end; and the verifier evaluates the final workspace condition. Conventional direct task generation turns one gear while leaving the others frozen. A model might invent a new hidden configuration file name inside a test suite without declaring it in the prompt, demand a third-party tool that was never installed in the environment container, or stretch an instruction into paragraphs while leaving the underlying bash commands completely trivial. The immediate symptom is an unrunnable task, but the hidden killer is corrupted training feedback injected directly into agent loops.

---

[01:29](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=89s) Grow the Proof First: Dual-Gated Synthesis

RST introduces an unusually disciplined design principle: it grows the reference solution before touching the prompt. Instead of hallucinating a complex task description and hoping an automated solver can satisfy it, RST begins with an already-verified seed task. The synthesis generator chooses an explicit rewrite target, appends real operations, and introduces new state dependencies into the executable workflow script. Only after the execution trace has expanded does the framework synchronize the environment configuration, private verifier tests, and public instruction to reflect those new requirements.

```mermaid flowchart LR accTitle: RST Recursive Synthesis and Verification Pipeline accDescr: Pipeline showing task expansion from seed to static filtering, dual-gated sandbox verification, and pool ingestion.

subgraph GrowStage["1. Proof Expansion"] SEED["Verified Seed Task"] --> REWRITE["Expand Solution & State Dependencies"] REWRITE --> ALIGN["Update Env, Verifier, & Public Prompt"] end

subgraph FilterStage["2. Validation Gates"] ALIGN --> STATIC["Static Filters (Drop leaks & no-ops)"] STATIC --> SANDBOX["Fresh Sandbox Exec"] SANDBOX --> GATES{"Dual Gates: Oracle & Contract"} end

subgraph PoolStage["3. Yield & Reuse"] GATES -->|"Pass"| POOL["Verified Task Pool (RL Env & Next-Round Seeds)"] GATES -->|"Fail"| DROP["Discarded Candidate"] end ```

Before an expanded candidate can join the pool, it must survive both static filters and a clean sandbox execution. Static filters prune malformed syntax, information-leaking prompts, or trivial cosmetic mutations. Surviving candidates are then spun up in an isolated execution sandbox where the augmented reference solution must pass the verifier. To guarantee training integrity, RST enforces two distinct validation gates: - **Oracle Validity:** The trusted reference solution must run in a clean environment and successfully pass every assertion in the private verifier. - **Contract Validity:** Every single requirement, assertion, and check performed by the verifier must be either explicitly stated in the public prompt or discoverable via the sandbox workspace.

If a private test silently checks an undisclosed file path that the oracle hardcodes but the public prompt never reveals, the task is strictly rejected. This dual gate prevents "teacher cheating" and ensures difficulty grows from genuine work rather than "adjectives" or missing specifications.

---

[02:52](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=172s) Lineage Tracing: 15 Rounds of Executable Expansion

To demonstrate that complexity compounds without drifting into incoherence, the paper documents an exact task lineage starting from a minimal seed across 15 recursive rounds:

Across these 15 generations, the core domain objective survives, but the required dependency chain deepens substantially. The agent cannot skate by on shallow pattern matching; it must carry out deep multi-step diagnostics, configuration edits, reconciliation runs, and validation sweeps.

---

[03:41](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=221s) Scaling Without Collapse: Yield, Effort, and Difficulty Growth

Starting from an initial set of 639 human-verified bootstrap seeds, RST synthesized 37,484 accepted tasks across 15 generations at approximately five cents per validated task. Crucially, validation yield did not decay as task depth increased: - Yield of passed tasks remained remarkably steady between roughly 498 and 572 per 1,000 synthesis attempts. - Candidate pass rates inside the sandbox stayed consistently between 74.5% and 81.5%.

```mermaid flowchart TD accTitle: Synthesized Task Complexity vs Solver Performance accDescr: Comparing the increase in code/command lines against the steep collapse in DeepSeek-V4-Pro pass rates across 15 rounds.

subgraph Growth["Executable Complexity (Rounds 1 to 15)"] L["Median Solution Lines: 67 ➔ 374 lines"] C["Terminal Commands: 40 ➔ 244 commands"] end

subgraph Difficulty["DeepSeek-V4-Pro Performance"] P["pass@4 Rate: 90.0% ➔ 2.5%"] SC["Mean Partial Credit: 0.97 ➔ 0.17"] end

Growth -.->|"Induces Genuine Difficulty"| Difficulty ```

To verify that these accepted tasks were not accumulating cosmetic bloat, the authors evaluated them with a frozen frontier baseline: - **Solution Length:** Median reference solution code expanded from 67 lines in round 1 to 374 lines in round 15. - **Command Volume:** Executed bash commands grew from 40 to 244. - **Solver Performance Drop:** DeepSeek-V4-Pro pass@4 plummeted monotonically from 90.0% down to 2.5%. - **Partial Credit:** Mean partial credit fell from 0.97 to 0.17.

Because the evaluator model remained fixed, the steep drop in pass rate proves that the tasks became genuinely harder execution problems rather than superficially verbose prompts.

---

[05:17](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=317s) Guarding Against Recursive Diversity Collapse

Recursive generation pipelines notoriously suffer from mode collapse, degenerating into narrow clusters of near-identical rewrites. To forestall this, RST enforces strict diversity quotas across lineage domains, rewrite families, operators, and generation cohorts: - By round 15, 36 out of 40 discrete rewrite operators remained actively represented in the pool. - No single rewrite family comprised more than 29% of the overall distribution. - No individual seed task from the initial 639 bootstrap instances accounted for more than 0.77% of the total dataset.

Nevertheless, synthesis boundaries do emerge under close inspection. Median nearest-neighbor semantic similarity increased over recursion rounds to 0.464, with a high-similarity tail stretching to 0.703. While diversity remains healthy enough to drive downstream learning, aggressive deduplication and boundary monitoring remain critical safeguards against late-stage homogenization.

---

[06:05](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=365s) Downstream Transfer: SFT and Agentic PPO Benchmarks

Hard synthesis tasks are useless if they fail to teach models generalizable skills. To measure downstream transfer, successful rollout trajectories collected across the verified RST environments were formatted into supervised fine-tuning (SFT) data for Qwen3.5 models (evaluating both the 27B parameter dense model and the 122B mixture-of-experts model). Evaluated across Terminal-Bench 2, Terminal-Bench Hard, and Long-Horizon Terminal-Bench: - Both model sizes showed progressive performance gains through three consecutive fine-tuning stages. - The 122B model achieved its largest absolute improvement on Terminal-Bench Hard, picking up 10 full percentage points. - A strict n-gram overlap audit confirmed zero exact 13-token matches against the test benchmarks, ruling out test set contamination or memorized task descriptions.

The task corpus was subsequently deployed as an active training ground for agentic Reinforcement Learning via PPO starting from Qwen3.5-27B:

| Benchmark | Baseline Pass Rate | Agentic PPO (RST) | Relative Gain | |:--- |:--- |:--- |:--- | | **Terminal-Bench 2** | 41.20% | 49.44% | +20.00% | | **Terminal-Bench Hard** | 22.67% | 32.00% | +41.16% | | **Long-Horizon Terminal-Bench** | 18.10% | 22.07% | +21.93% |

*(Note: The dedicated reinforcement learning results table reports 49.44% on Terminal-Bench 2, though the paper's conclusion section includes a conflicting value of 46.07%.)*

The standout result is the massive 41.16% relative surge on Terminal-Bench Hard—an independently curated, out-of-distribution evaluation set that underscores genuine reasoning transfer rather than narrow benchmark gaming.

---

[07:36](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=456s) Limits and the Core Mental Model

Conventional agent data generation relies on naive prompt mutation paired with rejection filtering, hoping downstream heuristics catch broken setups. RST redefines the fundamental unit of synthesis: every newly minted child is an executable, proof-carrying task bundle complete with runnable environment assets, contract validation receipts, and explicit provenance. This transforms synthetic data generation into an automated, self-sustaining curriculum. As models become more capable, the system autonomously expands dependency chains and verifier rigor without waiting for manual human authoring.

However, several clear caveats bound the claims: - Demonstrating 15 stable generations proves there was no immediate collapse ceiling, but it does not guarantee unbounded scaling to infinity. - Synthesis integrity depends entirely on verifier quality; flawed test assertions propagate down the lineage. - The high-similarity tail is measurably expanding. - Empirical results apply to terminal environments; generalizability to graphical user interface (GUI) or arbitrary OS interactions remains unproven.

The lasting takeaway of the work is straightforward: "Do not recursively mutate prompts. Recursively grow executable work, and let every accepted task carry its own proof."

## Notable quotes > [00:00](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=0s) A serious terminal-agent task can cost hundreds or even thousands of dollars to author. RST reports roughly five cents per verified task.

> [00:00](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=0s) The bottleneck in authoring long-horizon tasks has never been prompt writing—it is the grueling challenge of maintaining strict alignment across four tightly coupled components

> [00:00](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=0s) RST bypasses this failure mode not by manufacturing cheap text prompts, but by producing cheap, verified, executable work with genuinely rising difficulty.

> [00:00](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=0s) Conventional direct task generation turns one gear while leaving the others frozen.

> [01:29](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=89s) it grows the reference solution before touching the prompt.

> [01:29](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=89s) This dual gate prevents "teacher cheating" and ensures difficulty grows from genuine work rather than "adjectives" or missing specifications.

> [03:41](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=221s) Because the evaluator model remained fixed, the steep drop in pass rate proves that the tasks became genuinely harder execution problems rather than superficially verbose prompts.

> [05:17](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=317s) By round 15, 36 out of 40 discrete rewrite operators remained actively represented in the pool.

> [06:05](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=365s) A strict n-gram overlap audit confirmed zero exact 13-token matches against the test benchmarks, ruling out test set contamination or memorized task descriptions.

> [06:48](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=408s) The standout result is the massive 41.16% relative surge on Terminal-Bench Hard—an independently curated, out-of-distribution evaluation set that underscores genuine reasoning transfer rather than narrow benchmark gaming.

> [07:36](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=456s) every newly minted child is an executable, proof-carrying task bundle complete with runnable environment assets, contract validation receipts, and explicit provenance.

> [08:16](https://www.youtube.com/watch?v=zAeJwDdM6OE&t=496s) Do not recursively mutate prompts. Recursively grow executable work, and let every accepted task carry its own proof.

## Mentioned Xiaol.x, Recursive Synthesis, RST, DeepSeek-V4-Pro, Qwen3.5, Qwen3.5-27B, Qwen3.5-122B, Terminal-Bench 2, Terminal-Bench Hard, Long-Horizon Terminal-Bench, PPO, Lean, Leanim, Hugging Face, arXiv

## Video description A serious terminal-agent task can cost hundreds or even thousands of dollars to author. RST reports roughly five cents per verified task.

The breakthrough is not cheaper prompt generation. RST recursively grows the executable solution, realigns the verifier and public instruction, validates everything in a fresh sandbox, and reuses accepted tasks as seeds. The result is a proof-carrying curriculum for training increasingly capable terminal agents.

In this English Lean/Leanim explainer:

- 639 verified seeds become 37,484 tasks across 15 rounds. - Median solution length grows from 67 to 374 lines. - Command count rises from 40 to 244. - DeepSeek-V4-Pro pass@4 falls from 90% to 2.5%, showing genuine difficulty growth. - SFT improves two Qwen3.5 model sizes across three terminal benchmarks. - Agentic PPO delivers its largest relative gain—41.16%—on Terminal-Bench Hard.

Why this matters: conventional task-generation pipelines produce and filter isolated examples. RST recursively reuses complete, validated task bundles while keeping the environment, solution, verifier, and public contract aligned.

Chapters

00:00 The five-cent paradox 00:44 Four files, one executable contract 01:29 Grow the proof before the prompt 02:13 Solvability versus fairness 02:52 A JSON task grows through 15 rounds 03:41 Scaling without losing validation yield 04:27 Proving the tasks become harder 05:17 Avoiding recursive data collapse 06:05 Supervised fine-tuning results 06:48 Agentic PPO results 07:36 Why this work is important 08:16 Limits and the final mental model

Sources

Paper: https://arxiv.org/abs/2608.05466 Hugging Face: https://huggingface.co/papers/2608.05466 Project page: https://zhongzhi660.github.io/recursive-verified-synthesis-site/

Note: the video follows the dedicated RL table’s 49.44 Terminal-Bench 2 result; the paper’s conclusion contains a conflicting 46.07 value.

#AIResearch #AIAgents #MachineLearning

[Source](https://www.youtube.com/watch?v=zAeJwDdM6OE)

中文简报

递归合成技术通过代码证明将智能体任务成本降至5美分在修改提示词之前先行扩展可执行参考解决方案，可防止合成数据崩溃，以每个5美分的成本生成37,484个经验证的训练任务，同时提升智能体在基准测试中的推理能力。该视频解析了递归合成（RST）框架，该框架通过优先修改可执行参考解决方案而非直接变异文本提示词，来扩展终端智能体基准测试。在15轮递归中，初始的639个种子任务扩展为37,484个经验证的任务，每个任务成本维持在约5美分左右，同时解决方案的中位数长度从67行增加至374行。双门控沙箱机制与严格的配额限制防止了反馈受损和递归数据崩溃；随着难度递增，DeepSeek-V4-Pro的通过率从90%骤降至2.5%，证实了这一难度扩展效果。在下游应用中，利用这些附带证明的任务训练Qwen3.5模型带来了持续的监督微调性能提升，并在Terminal-Bench Hard测试中使用Agentic PPO取得了最高达41.16%的相对增益。递归合成（RST）引入了一种以大约每个5美分生成经验证的终端智能体任务的技术，在15轮递归中将639个初始种子任务扩展至37,484个任务。 (0:00) RST并非变异提示词，而是先行扩展参考解决方案代码，并重新对齐环境、私有验证器和公共指令，以维持可执行契约。 (1:29) 任务展现出真实的难度递增而非表面上的代码膨胀，解决方案中位数长度从67行增长至374行，DeepSeek-V4-Pro的pass@4从90%降至2.5%。 (3:41) 在RST任务上进行监督微调和Agentic PPO在三个终端基准测试中均带来了持续的下游性能提升，包括Qwen3.5-27B在Terminal-Bench Hard上获得的41.16%相对增益。 (6:48)

Reading summary

Recursive Synthesis (RST) significantly lowers the cost of authoring complex terminal-agent benchmarks to roughly five cents per accepted task by expanding executable proofs before altering instructions. According to the research, this proof-first framework generates verified, escalating dependency chains that deliver marked improvements in downstream agentic fine-tuning and reinforcement learning. The Four-Gear Contract and Proof-First Synthesis (0:00) Authoring long-horizon terminal tasks traditionally costs hundreds to thousands of dollars per instance because creators must synchronize four interconnected components: the public instruction, the runnable sandbox environment, the reference solution, and the private verifier. Conventional generative approaches frequently alter one component while leaving others unchanged—such as verifiers checking undeclared file paths or environments lacking required packages—which injects corrupted feedback directly into agent training loops. RST bypasses this desynchronization by prioritizing the reference solution over prompt writing. Starting from verified bootstrap seed tasks, the generator introduces real operations and dependency chains into an executable script first. Only after the execution proof expands does the framework synchronize the sandbox environment, private assertions, and public instruction. Before acceptance, candidates must pass static sanitization and a clean sandbox run governed by two rules: Oracle Validity, requiring the reference solution to pass all verifier checks, and Contract Validity, requiring all verifier requirements to be explicitly stated in the prompt or discoverable in the workspace. Verifiable Complexity Growth Across Recursive Generations (3:41) Starting from 639 human-verified bootstrap seeds, RST synthesized 37,484 accepted tasks across 15 recursive generations without experiencing yield decay. Synthesis yield remained stable between 498 and 572 passed tasks per 1,000 attempts, while sandbox candidate pass rates stayed between 74.5% and 81.5%. Tracing task lineages showed that initial ten-line diff scripts compounded into 347-line workflows requiring multi-step diagnostics, configuration edits, fixture repairs, and reconciliation sweeps by round 15. To ensure that expanding tasks represented genuine computational difficulty rather than prompt verbosity, the authors evaluated candidate tasks against a frozen baseline model, DeepSeek-V4-Pro. As median reference solution code lengthened from 67 to 374 lines and executed terminal commands rose from 40 to 244, DeepSeek-V4-Pro's pass@4 rate dropped monotonically from 90.0% down to 2.5%, accompanied by a drop in mean partial credit from 0.97 to 0.17. Diversity Preservation and Downstream Agentic Transfer (6:05) To forestall recursive mode collapse, RST enforces strict diversity quotas across domains, rewrite operators, and seed lineages. By round 15, 36 of 40 rewrite operators remained active, no single rewrite family comprised over 29% of the distribution, and no original seed task accounted for more than 0.77% of the pool. However, semantic similarity still drifted upward, with median nearest-neighbor similarity reaching 0.464 and a high-similarity tail touching 0.703. Downstream evaluations showed that synthesized trajectories transferred generalizable problem-solving skills rather than memorized patterns. Supervised fine-tuning of Qwen3.5 (27B and 122B) produced consistent benchmark gains with zero 13-token overlap against evaluation sets. Applying the corpus to agentic Reinforcement Learning via PPO on Qwen3.5-27B increased pass rates from 41.20% to 49.44% on Terminal-Bench 2 (though a conflicting 46.07% figure is noted in the paper's conclusion), from 18.10% to 22.07% on Long-Horizon Terminal-Bench, and by 41.16% relative on Terminal-Bench Hard (22.67% to 32.00%). RST demonstrates that automated curriculum generation is viable when tasks carry executable proofs, but the method has distinct boundaries. System integrity depends entirely on verifier correctness, as flawed assertions propagate downstream, and infinite recursive scaling without diversity decay remains unproven beyond 15 generations. Additionally, empirical validation is limited to terminal interactions, leaving applicability to graphical user interfaces or broader operating system tasks untested.

Source quotes

[0:00] A serious terminal-agent task can cost hundreds or even thousands of dollars to author. RST reports roughly five cents per verified task. [0:00] The bottleneck in authoring long-horizon tasks has never been prompt writing—it is the grueling challenge of maintaining strict alignment across four tightly coupled components [0:00] RST bypasses this failure mode not by manufacturing cheap text prompts, but by producing cheap, verified, executable work with genuinely rising difficulty. [0:00] Conventional direct task generation turns one gear while leaving the others frozen. [1:29] it grows the reference solution before touching the prompt. [1:29] This dual gate prevents "teacher cheating" and ensures difficulty grows from genuine work rather than "adjectives" or missing specifications. [3:41] Because the evaluator model remained fixed, the steep drop in pass rate proves that the tasks became genuinely harder execution problems rather than superficially verbose prompts. [5:17] By round 15, 36 out of 40 discrete rewrite operators remained actively represented in the pool. [6:05] A strict n-gram overlap audit confirmed zero exact 13-token matches against the test benchmarks, ruling out test set contamination or memorized task descriptions. [6:48] The standout result is the massive 41.16% relative surge on Terminal-Bench Hard—an independently curated, out-of-distribution evaluation set that underscores genuine reasoning transfer rather than narrow benchmark gaming. [7:36] every newly minted child is an executable, proof-carrying task bundle complete with runnable environment assets, contract validation receipts, and explicit provenance. [8:16] Do not recursively mutate prompts. Recursively grow executable work, and let every accepted task carry its own proof.

Original transcript

[0:00] A serious terminal task can cost [0:03] hundreds or even thousands of dollars to [0:06] author. [0:07] This work reports roughly 5 cents. [0:10] That number sounds impossible until you [0:12] notice what is actually expensive. It is [0:15] not [0:16] writing one more instruction. A long [0:19] horizon task must keep a public request, [0:22] a runnable environment, a reference [0:24] solution, and a private verifier [0:26] consistent across many dependent steps. [0:29] Break one link and the agent trains [0:30] against nonsense. The highlight of RST [0:34] is not cheap text. It is cheap, [0:38] verified, [0:39] increasingly difficult, executable work. [0:45] Picture the task as four gears. [0:49] The instruction tells the agent what [0:51] success means. [0:53] The environment determines what tools [0:55] and state exist. [0:57] The reference solution proves that the [0:59] job can be completed. The verifier [1:02] checks the final workspace. Direct [1:05] generation often turns one gear without [1:08] turning the others. A new hidden file [1:11] name appears only in the tests. [1:13] A tool is requested but never installed. [1:16] A longer prompt still leads to the same [1:18] trivial workflow. The visible failure is [1:22] a broken task. The hidden killer [1:25] is corrupted training feedback. [1:29] RST makes one unusually disciplined [1:32] move. It grows the reference solution [1:35] first. Starting from a verified seed, [1:38] the generator chooses a rewrite target, [1:40] adds operations and state dependencies [1:42] to the executable workflow, then updates [1:45] the environment, verifier, and public [1:46] instruction to match [1:48] uh Static filters remove malformed, [1:52] leaky, or cosmetic rewrites. A fresh [1:55] sandbox runs the solution against the [1:57] private checks. Only accepted tasks can [1:59] enter the verified pool, become [2:02] reinforcement learning environments, or [2:04] seed the next synthesis round. [2:07] Difficulty grows from work, not [2:11] adjectives. [2:13] Sandbox success alone is not enough. RST [2:17] keeps two gates. Oracle validity asks [2:20] whether the trusted solution passes the [2:22] verifier in a fresh environment. [2:24] Contract validity asks whether every [2:26] tested requirement was stated publicly [2:28] or made discoverable in the workspace. [2:30] Imagine a JSON report task whose private [2:33] test silently demands an undisclosed [2:35] path. The Oracle may know that path and [2:38] pass. The agent cannot. RST rejects that [2:42] mismatch. [2:44] This dual gate is the quiet reason the [2:46] recursion is useful for training instead [2:49] of merely impressive for generation. [2:53] The paper follows one exact lineage. The [2:56] seed simply generates six JSON diff [2:59] reports, and its reference solution has [3:02] 10 non-empty lines. Round one moves the [3:06] comparison matrix into configuration and [3:09] grows to 66 lines. Round five adds [3:12] invalid configuration diagnosis and [3:15] reaches 219. [3:18] Round 10 adds a release note driven [3:20] regression case and reaches 264. [3:24] By round 15, the agent must repair [3:26] configuration and fixtures, regenerate [3:29] every report, reconcile counts, and pass [3:32] tests. 347 lines. The objective [3:36] survives. The dependency chain deepens. [3:42] Now, the dramatic scale receipt. 639 [3:46] verified bootstrap tasks become 37,484 [3:51] synthesized tasks across 15 rounds at [3:55] about 5 cents per accepted task. Cheap [3:58] generation [3:59] would be less interesting if validation [4:03] collapsed with depth. [4:05] It does not. Pass task yield stays [4:08] between roughly 498 and 572 per thousand [4:12] attempts [4:13] and the candidate pass rate remains [4:16] between 74.5 and 81.5 percent. After 15 [4:21] rounds the flywheel still produces [4:25] viable children. [4:28] Stable yield could hide cosmetic [4:30] rewrites. So, the paper measures [4:32] executable growth and holds the solver [4:35] fixed. Um from round 1 to round 15 [4:41] median solution length rises from 67 to [4:44] 374 [4:47] lines. Commands rise from [4:50] 40 to 244. [4:53] Meanwhile [4:55] deep seek V4 [4:58] pro pass at four falls monotonically [5:01] from 90% to 2.5% [5:04] and mean partial credit falls from 0.97 [5:08] to 0.17. [5:11] The tasks are not merely longer on [5:12] paper. The same agent completes far less [5:15] of them. [5:18] Recursive data can collapse into one [5:20] family of near duplicates. RST fights [5:23] that with caps on lineage domain, [5:25] rewrite family, operator, and generation [5:27] cohort. At round 15 36 of 40 rewrite [5:32] operators remain represented. No family [5:35] exceeds 29%. [5:38] And no individual bootstrap seed [5:41] contributes more than 0.77% [5:44] of the pool. [5:46] But there is [5:48] a real boundary. Median nearest neighbor [5:52] similarity rises to 0.464 [5:56] with a high similarity tail reaching [5:58] 0.703. [6:00] Diversity survives. [6:02] Deduplication still matters. [6:05] Hard tasks matter only if they teach. [6:08] Quinn 3 [6:10] 5 rules out on the verified environments [6:12] and successful trajectories become [6:13] supervised fine-tuning data. Across [6:16] Terminal Bench 2, Terminal Bench Hard, [6:19] and Long Horizon Terminal Bench, [6:22] performance rises through three training [6:25] stages for both the 27 billion model and [6:28] the 122 billion mixture model. The [6:31] largest absolute gain is 10 points on [6:35] Terminal Bench Hard for the larger [6:36] model. An overlap audit finds zero exact [6:40] 13 token matches against the evaluated [6:42] benchmark task, so the transfer is not [6:44] explained by copied descriptions under [6:46] that test. [6:48] >> [laughter] [6:49] >> The same task pool becomes an agentic [6:52] reinforcement learning environment. Um [6:55] starting from Quinn [6:58] 3 5 27 billion, [7:02] PPO raises Terminal Bench 2 from 41.2 to [7:06] 49.44, [7:08] Terminal Bench Hard from 22.67 [7:12] to 32, and Long Horizon Terminal Bench [7:16] from 18.1 to 22.07. [7:21] Those are relative gains of 20 41.16 [7:26] and 21.93%. [7:28] The strongest relative jump appears on [7:30] the independently constructed hard set, [7:33] which is the most interesting transfer [7:34] receipt. [7:36] Most data pipelines scale quantity by [7:38] repeating a generator and hoping filters [7:41] catch the damage. RST changes the unit [7:44] of recursion. The child is a complete [7:46] task bundle carrying an executable proof [7:49] of solvability, a public contract [7:51] validation receipts, and provenance. [7:53] That turns task generation into [7:55] curriculum construction. As the model [7:58] improves, the data factory can keep [8:00] growing longer workflows and denser [8:02] checks instead of waiting for human [8:04] authors. The paper closes a practical [8:07] loop among benchmark construction, [8:10] supervised trajectories, verifier [8:13] rewards, and harder future tasks. [8:17] The claim still has edges. 15 stable [8:20] rounds show no observed ceiling. They do [8:23] not prove infinite scaling. [8:26] Verifier quality remains load-bearing. [8:29] The similarity tail is already growing. [8:32] The evidence is strong inside terminal [8:34] agent benchmarks, not across every form [8:37] of computer use. And one conclusion [8:40] number conflicts with the paper's [8:42] dedicated RL table. So, this explainer [8:45] follows the table and flags the [8:47] discrepancy in its report. [8:49] The durable mental model is simpler. [8:52] Do not recursively mutate prompts. [8:55] Recursively grow executable work, [8:59] and let every accepted task carry its [9:01] own proof.