Synthetic data: what it's good for, and where it quietly breaks things

The episodes (47)

Newest first. Each line is what that paper contributed to the question.

• One Self-Written Page Is Enough to Collapse an AI Search Answer

  Model-generated articles are fed back into the search pool, simulating synthetic content polluting the web corpus. (39% vs 7% citation rate)

• Swapping the Name Did Nothing, But Hedging Moved Every Model

  Paired stimuli are created by having GPT-4 rewrite real WildChat requests into hedged and direct registers. (register decodes at ~99%, name gender at ~72% — with zero effect on output)

• Why a Model Can Grade an Answer But Not Write the Answer Key

  Model-generated test suites and answer keys are a form of synthetic ground truth whose quality is being interrogated. (60 to 80 percent of verified correct solutions thrown out)

• Coding Models Can Find the Bad Line, They Just Won't Delete It

  A small synthetic deletion-focused training mixture (~13k examples) is used to test transfer effects. (63% to 42%)

• How Do You Know an AI Agent Actually Refused? Check the World, Not the Words

  The system synthesizes thousands of attack scenarios from a taxonomy of harms, tricks, and environments. (94%)

• Twin Problems Suggest AI Reasoning Gains Are Mostly Better Fact Recall

  Claude generates the isomorphic twin problems that make up the IsoSci benchmark. (63 of 69 reasoning gains never transferred)

• How a Robot Builds a Debugging Notebook It Can Read, Edit, and Hand to Another Robot

  Skills are discovered and validated in simulation before being transferred to real hardware, exploiting sim-to-real portability of text. (31% vs 4%)

• Why Phone Agents Ace the Test and Crash on Your Actual Phone

  Recovery trajectories are synthesized by a teacher model intervening during student failures to generate correction demonstrations. (72% on real devices, roughly double the best open model)

• A Coding Agent Found a Hole in a Peer-Reviewed STOC Proof for Five Dollars

  Unit-test lemmas are generated synthetically to validate new mathematical definitions before they are used in proofs. (1 line)

• An 8-Billion Agent That Beats Models 80 Times Its Size By Looking Things Up

  ~400K training examples, 85K traces, and 281K tool calls are generated entirely by specialized AI systems with no human annotation. (8B beats 671B by 15+ points)

• Why You Can't Fine-Tune Foresight Into an AI Agent

  Two hundred billion tokens of agent trajectories are augmented with teacher-synthesized world-model blocks during the capability-injection stage. (99%+ format adherence, ~0 capability gain)

• The Bug Where Smart Assistants Read a Fact and Still Forget It

  Patel builds synthetic update-timeline episodes as a training curriculum, deliberately separate from the real held-out evaluation data. (28% to 28%)

• An AI Designed Its Own Psychology Studies, Then Confirmed What It Found

  The system simulates fake participant populations to pre-screen experiments and score theories before touching real humans. (250 real people, zero researchers)

• How Teaching an AI to Predict, Not Act, Made It a Better Actor

  Fictional consistent worlds (e.g., a 2030 Mars colony) are generated as sealed training environments for search agents, yielding a 16-point gain. (9 points better on an unseen benchmark)

• Why Training Only on Perfect Solutions Cripples a Model's Reasoning

  The paper's distillation fix involves generating reasoning traces with failures from an RL model to create training data that contains dead ends. (W·K vs W·L^K — linear vs exponential)

• A Robot That Plays Before You Give It a Job, And Why That Beats Retrying

  The play phase generates a self-built skill library and failure memory from simulated experience rather than human-labeled demonstrations.

• Training an AI to Take Its Own Notes, So Its Future Self Works Better

  Training uses synthetic environments like FrozenLake-Obscure that can generate essentially unlimited instances for RL training.

• Why More Human Demonstrations Made a Computer-Use Agent Worse

  The core contribution is replacing human demonstrations with a fully synthetic data pipeline that outperforms real human recordings.

• Why a Flawless Demo Makes a Worse Computer-Using Agent, And the Fix

  The core method manufactures recovery demonstrations by splicing plain-agent failures with skill-guided continuations, creating training data absent from the original expert corpus.

• Don't Kill the Loser: A Different Way to Handle Two AI Agents Colliding

  Contended workloads were hand-constructed by pairing tasks to exhibit textbook concurrency anomalies, raising representativeness concerns.

• Agents Fail at the Body, Not the Brain: A Self-Rewriting Scaffold That Lifts a 9B Model 44 Points

  Co-evolution reuses execution traces from harness variants as structured training signal for the underlying model, avoiding separate data generation costs.

• Training a Tiny Model to Run the Plumbing Between an Agent and the World

  Training examples are generated by running agents with prompted harness interventions and then filtered, rather than collected from human demonstrations.

• How MiniMax Turned a Reward-Hacking Disaster Into Olympiad Gold

  The Verifier and Fixer Experts are trained on data generated as a side-effect of the RL training run—problems, flawed proofs, critiques, and verdicts produced automatically.

• The Agent Failed — But Did the Instructions Deserve to Be Followed?

  LLM-authored skill documents are LLM-generated artifacts analogous to synthetic data, and the paper studies why they fail without targeted feedback.

• How a Model Can Earn Full Reward and Still Resist Training

  Over 16,000 synthetic documents are used to give the model organism knowledge of training dynamics and self-inoculation without explicit instructions.

• How Coding Agents Can Mine Their Own Failures Into a Self-Targeting Curriculum

  The system generates new bug-fix tasks by injecting realistic defects into real repositories, targeting agent-specific weak spots.

• A Cheap Model With the Blueprints Beats Expensive Models Working Blind

  The paper releases Terminal Wrench, a dataset of 3600+ confirmed cheat trajectories generated during the audit.

• Five Identical Worlds, One Swapped Model: What Happens When AI Agents Run for Fifteen Days

  The simulated world generates a rich log of ~70,000 actions, in-world blog posts, votes, and social events used as analysis data throughout the paper.

• How an Open AI System Verified 672 Hard Math Proofs for Under $300

  Natural-language proof sketches are optionally used to seed the initial blueprint, acting as informal strategy hints for the formalization loop.

• Agents That Rewrite Their Own Weights Instead of Just Taking Notes

  The agent self-generates structured QA flashcards that serve as its own training data for the parametric memory update.

• How an Agent Got 44 Points Better by Mining Its Own Scratch Paper

  Induced pseudo-tools are constructed from the agent's own successful trace data rather than human-authored examples.

• Treating Math Formalization Like a Codebase, and Where the Agents Cheat

  ATLAS generates large-scale verified Lean 4 formal mathematics that could serve as training data for future reasoning models.

• How an Open-Book Trick Teaches a Model to Catch Its Own Mistakes

  Training signal for the verifier is generated by the model itself in open-book mode, requiring no human annotations.

• How MiniMax-M2 Bets That Sparsity Plus Verifiable Rewards Can Match Frontier Agents

  Verifiable training tasks are constructed by scraping GitHub PRs, deploying sandboxed apps, and grounding web-search answers in retrieved documents.

• Training a Deep Research Agent on 8,000 Synthetic Tasks: The Rubric Tree Trick

  The entire QUEST training set of 8,000 examples is fully synthetic, generated without any human annotation.

• How a Two-Agent Trick Unlocked Large-Scale Training for Computer-Use Agents

  The pipeline synthesizes 32,000+ verified training tuples and 94 mock web applications for RL training.

• An Old Idea From Cognitive Psychology Reshapes How We Reward Reasoning Models

  Gold knowledge units (the supervision targets) are generated by GPT-5.1 rather than human-curated, making the training targets model-generated.

• How a Fifteen-Hundred-Dollar Training Run Matched Llama and Gemma on Reasoning

  Training uses curated instruction-response datasets like OpenMathInstruct and NuminaMath rather than raw web text.

• When Three LLMs Talk to Each Other, Their Ideas Quietly Stop Moving

  The paper connects generation-time semantic collapse to training-side model collapse, arguing pre-contracted synthetic data compounds both.

• Why Giving an AI Agent More Tools Can Make It Worse at Using a Computer

  The bootstrapping pipeline manufactures interleaved GUI-and-tool trajectories from existing click-only data using a strong model.

• Firefly's Inversion: Building Verified Tool-Call Training Data by Working Backward

  Firefly generates training data synthetically but grounds it in real API executions rather than pure model imagination.

• Why Upgrading Your AI Auditor to a Smarter Model Can Make Your System Less Safe

  Adversarial payloads are generated by an LLM mutator seeded from real incident postmortems, creating a synthetic attack dataset.

• When Models Learn the Monitor Exists, the Reasoning Trace Stops Being a Window

  The intervention uses synthetic documents about CoT monitoring to inject beliefs about the monitoring environment into the model during finetuning.

• When Agent Benchmarks Lie: The Harness Problem in Open-Source AI

  Orchard-Claw is trained on only 200 synthetic tasks, and GUI training data is generated via teacher model rollouts.

• When 'This Is False' Doesn't Stick: Why Models Learn the Lie Anyway

  All experiments use synthetically constructed documents designed to implant specific false beliefs during finetuning.

• Training the Model Spec Directly: An Alignment Lever Aimed at the Say-Do Gap

  MSM generates a large corpus of synthetic documents (blog posts, memos, papers) that discuss the Model Spec, used as the midtraining signal.

• Ten Thousand Examples Beat the Full Industrial Pipeline for Search Agents

  Training examples are synthesized from knowledge graphs rather than collected from real human research sessions.