[Paper Review] Autodata: An agentic data scientist to create high quality synthetic data

Metadata

Field	Value
Authors	Ilia Kulikov et al. (15 co-authors, FAIR at Meta)
Venue	arXiv preprint · 2026
arXiv or DOI	2606.25996
Data	10k+ S2ORC CS papers, 7.8k Pile of Law documents, Principia math/physics problems
Review date	2026-06-29

TL;DR

Autodata is a general framework where an LLM agent plays the role of a data scientist: it creates synthetic data, analyzes that data both qualitatively and quantitatively, distills learnings, and feeds them back into its data-generation recipe to iterate.
Its concrete instantiation, Agentic Self-Instruct, uses four subagents — challenger, weak solver, strong solver, judge — to hunt for examples that “the strong solver solves but the weak one struggles with.” Across CS research questions, legal reasoning, and scientific reasoning, RL-training the same 4B model on Agentic data consistently beats standard CoT Self-Instruct data.
The key insight is not “harder” but “just right.” In CS the loop makes too-easy questions harder; in legal it makes too-hard questions (where reward collapses to zero) learnable — opposite directions, yet downstream RL improves in both cases.
Meta-optimizing the data scientist agent itself (via evolutionary prompt search) lifts the validation pass rate from 62.1% to 79.6%. A general mechanism for converting inference-time compute into better training data.

Introduction

Frontier AI progress increasingly hinges on high-quality training data and benchmarks that keep challenging models. The original foundation was human-written data, but more and more of the gains now come from synthetic data the model creates itself. Synthetic data fills in edge cases and long-tail scenarios that real corpora underrepresent, cuts the cost and latency of manual labeling, and can produce data harder than the human-generated distribution.

The lineage starts with Self-Instruct (Wang et al., 2023), then Grounded Self-Instruct (grounding on documents to reduce hallucination), CoT Self-Instruct (Yu et al., 2025, Chain-of-Thought during generation), and “self-challenging” methods (Zhou et al., 2025, agents that interact with tools before proposing a task). The catch: none of these directly control the difficulty and quality of the data, which is why filtering, evolution, and refinement get bolted on afterward.

Autodata generalizes all of them. It has the agent perform the act a human data scientist would when building high-quality data — create data, “eyeball” it, measure its performance, construct learnings, and then iterate with an improved recipe to make better data. It then goes one step further and trains (meta-optimizes) this agentic system (the outer loop) to be optimal as a data scientist (the inner loop). Where recent autoresearch work has focused on architectural or training-recipe improvements (Karpathy, 2026), the authors argue that data is likely to play an equally important — perhaps more important — role.

As state-of-the-art LLMs keep getting stronger, there’s a real worry that existing tasks or synthetic-data methods can’t produce anything challenging enough to drive further progress. Autodata offers a way to convert growing inference-time compute into harder, high-quality data — potentially changing how we create new tasks and benchmarks for the frontier.

Key Contributions

Formulating the Autodata framework. Unifies data creation → analysis → recipe revision into one agentic loop, with an outer loop that optimizes the agent itself.
Agentic Self-Instruct, a concrete implementation. A four-subagent weak-vs-strong-solver-plus-judge design that directly searches for discriminative examples (“strong succeeds, weak fails”).
Evidence across three domains. On CS research questions (rubric-based), legal reasoning (PRBench), and scientific reasoning (Principia), a 4B model RL-trained on Agentic data beats CoT Self-Instruct data, the 2x-larger Combined data, and even a much larger 397B baseline.
The “just right” insight. The same loop fixes the opposite failure modes of CS (too easy) and legal (too hard). The goal is the difficulty a model can hill-climb on, not maximal difficulty.
Meta-optimizing the data scientist. Evolutionary prompt search treats the agent scaffold as code and lifts data quality (validation pass rate) from 62.1% to 79.6% with no manual prompt engineering.

Background

A few concepts to have in hand before reading.

The Self-Instruct family. Self-Instruct bootstraps new instruction-following examples from a small seed set. Follow-ups diversified into distillation from stronger teachers, large-scale synthetic conversations, AI preference data, and automatic instruction evolution. Most treat data generation as a mostly fixed prompting-plus-filtering pipeline. Autodata instead treats it as an iterative data-science process, putting generation, evaluation, failure analysis, and recipe revision all inside one loop.

Grounded, verifiable, reasoning-based synthetic data. Synthetic “textbook” data played a key role in training small-but-strong models (MetaMath, MAmmoTH, OpenMathInstruct), while Source2Synth and NaturalReasoning curate examples from real documents for answerability. CoT Self-Instruct (Yu et al., 2025) improves quality via CoT planning and filtering. Autodata builds on these grounded, reasoning-aware methods but adds an explicit agentic loop that uses solver behavior and evaluator feedback to adapt the data to the target model.

Self-play and challenger-solver. STaR (bootstrapping successful rationales), Self-Rewarding LMs, and the more adversarial/curriculum-oriented Self-Challenging (Zhou et al., 2025, tool-use tasks with verification functions), Absolute Zero (Zhao et al., 2025, self-proposed verifiable tasks with zero external data), and SPICE (Liu et al., 2025, corpus-grounded challenger-reasoner). Autodata’s weak-strong Agentic Self-Instruct shares the challenger-makes-tasks idea but places it inside a broader data-scientist loop that analyzes solver failures, judges example quality, adjusts difficulty, and optimizes for examples useful for learning rather than merely hard.

Worth noting: many of the cited works — CoT Self-Instruct, NaturalReasoning, Self-Challenging, SPICE — share substantial author overlap with this paper. They’re the continuing lineage of the FAIR at Meta / Jason Weston group, and Autodata sits as the piece that unifies them under an “agentic data science” umbrella.

Autoresearch / meta-optimization. Prompt optimizers like Promptbreeder, Self-Refine, and GEPA (Agrawal et al., 2025); The AI Scientist’s automated research; and Meta-Harness (Lee et al., 2026), which treats the harness itself as an object of end-to-end optimization. Autodata’s meta-optimization applies this lens to data creation: the outer loop improves the data-scientist agent’s prompt and strategy using the same data-quality criteria that guide the inner loop.

Method / Architecture

Figure 1: The Autodata pipeline. An autonomous agent emulates a data scientist, iteratively generating data, running qualitative and quantitative evaluation, and updating its data-generation recipe. The agent itself can be meta-optimized using the same criteria.

The three components of the Autodata loop

The high-level design cycles through three stages.

Data Creation. The agent grounds on provided data (math, legal, coding documents) and uses tools, previously acquired skills/learnings, and inference-time compute to build training or evaluation data. This step can be repeated after subsequent analysis.
Data Analysis. Given the data it created, the agent extracts learnings about what it got right vs. wrong and how to improve. This can be at the example level (is this correct? is it challenging enough?) or the dataset level (are samples diverse? do they improve a model if used for training?). These learnings feed back into the next round.
The overall data scientist loop. The agent loops over creation and analysis until satisfied, then emits a final dataset or benchmark. Guardrails can be placed in the outer loop to prevent hacking.

Agentic Self-Instruct: a weak-vs-strong, four-subagent design

Figure 2: Weak-vs-strong Agentic Self-Instruct. The main LLM agent directs a challenger, a weak solver, a strong solver, and a judge. The goal is data where the strong solver succeeds but the weak solver struggles.

In the concrete implementation, the main orchestrator agent has four LLM subagents:

Challenger — creates training examples from a detailed prompt supplied by the main agent.
Weak solver — generally expected to struggle on the created data.
Strong solver — generally expected to succeed.
Verifier/judge — given the example and a model solution, checks quality and passes its learnings back to the main agent.

The main agent creates an example (a context/input, a desired response or reference answer, and task-specific evaluation criteria) by sending an initial prompt plus grounding context to the challenger. It then checks the challenger’s output by sending it to the weak and strong solvers and assigning a reward based on the verifier’s judgments. The judge also checks the quality of the example itself — the question, reference answer, and generated rubric.

For verifiable tasks (using an LLM-based verifier), one approach requires that majority vote over the strong solver is correct while majority vote over the weak solver is wrong. For non-verifiable tasks, it requires a quality gap as measured by the judge — using rubrics generated by the challenger, the task should be neither too easy nor too hard for the weak solver, while the strong solver helps guarantee correctness. The main agent analyzes the verifier report (which includes the solver outputs), and if the criteria aren’t met, it modifies the input prompt to the challenger given those learnings and tries a new example.

A nice detail: the weak and strong solvers can be the same LLM in different modes — the strong version simply gets more inference-time compute (scaffolding, aggregation; Zhao et al., 2025b) and access to privileged information.

What the main agent actually prompts

Appendix C reproduces every subagent’s system prompt, and that’s where the real mechanics show. The CS main agent doesn’t interpret the paper itself — it passes that to the challenger. The workflow loops: (1) challenger generates QA + rubrics → (2) quality verifier checks → (3) on QV failure, back to (1) with feedback → (4) run evaluate_rubric.py on the weak solver first → (5) on weak failure, back to (1) → (6) evaluate the strong solver → (7) check the gap, back to (1) if it fails → (8) ACCEPTED when all criteria pass. Crucially, a failed round doesn’t mean “tweak the question” — previously failed questions are grouped by failure mode (TOO EASY / FAILED ON STRONG / FAILED QV) and handed back to the challenger, which must produce “an entirely new question from a different angle that requires deeper reasoning.”

Training objective / reward

There’s no new loss function here — all downstream training uses GRPO (Shao et al., 2024) as-is. The “objective” lives in two places instead: the data acceptance criteria and the selection/acceptance rule of meta-optimization.

CS acceptance criteria. A useful training example for the weak solver requires the strong solver to score meaningfully higher on the rubric. But questions from standard CoT prompting were mostly too easy even for the weak solver (CoT column of Table 1: weak avg 0.677, gap 0.02), leaving little room to improve. So the criterion is defined directly in terms of the gap — a candidate is accepted only if

strong avg $\geq 0.65$,
weak avg $< 0.5$,
strong−weak gap $\geq 20$ percentage points.

Compute is saved by only evaluating the strong solver when the weak solver passes its criterion.

Legal reward shaping. Legal is the opposite. When a CoT question is too hard and four or five of five weak rollouts score zero, the per-group GRPO advantage collapses to near zero and there’s almost no learning signal. Here, instead of fixed thresholds, a loop judge decides acceptance per round. It reads the per-rollout patterns, the weak/strong gap, and the rubric, returning a structured verdict (weak_pattern, strong_pattern, gap_interpretation, rubric_concerns, grpo_suitability) plus an accept/improve decision. The key signal is the variance of weak rollouts — all-zero, all-100, or tightly clustered means no gradient (improve), while a usable spread means accept.

Meta-optimization selection/acceptance. The meta-optimizer keeps a population of candidate prompts and samples a parent via Boltzmann sampling. A candidate $c$ is chosen with probability

\[p(c) \propto \exp\!\left(\frac{\text{score}_c}{T}\right), \quad T = 0.1\]

which strongly favors high-scoring candidates while preserving exploration ($T=0.1$). A mutant prompt is added to the population only if its validation score on held-out papers strictly exceeds the parent’s — so the acceptance rule is itself aligned with the inner-loop criterion of “did this actually raise data quality?”

Training data and pipeline

The setup across the three domains:

Domain	Grounding source	Weak / strong solver	Orchestrator·challenger·judge	Output data
CS research questions	10k+ S2ORC CS papers (2022+)	Qwen3.5-4B / Qwen3.5-397B-A17B	Kimi-K2.6	2.8k accepted → 1.3k after filtering
Legal reasoning	7.8k Pile of Law documents	Qwen3.5-4B / Qwen3.5-397B-A17B	Kimi-K2.6	2.8k accepted (CoT sampled from 5.7k)
Scientific reasoning	Principia math/physics problems	Qwen3.5-4B / Qwen3.5-397B-A17B	Kimi-K2.6	9k train + 1k held-out (Combined 18k)

Shared training setup: all downstream models are Qwen3.5-4B trained with GRPO. CS uses batch 16, learning rate 1e-6, 1.3k data with 100 held out as test. Legal uses n=8 rollouts per prompt with a Kimi-K2.6 rubric judge as the train-time reward. Scientific uses GRPO with group size 8, batch 64, binary reward. The reasoning token budget is 65,536 tokens.

The CS data curation is notable. From 10k papers, Agentic Self-Instruct produces 2.8k accepted examples; a quality verifier (Kimi-K2.6) at the end of the loop then removes questions with paper-specific reference leakage, short contexts, or malformed rubrics, retaining 1.3k high-quality examples. The same quality verifier is applied to the CoT baseline, and an equal 1.3k is sampled for a fair comparison.

Experiments

CS research questions — open-ended, rubric-based

The CS setting answers open-ended research questions using academic CS papers as source. The challenger produces a context, a question, a reference answer, and a self-contained evaluation rubric of weighted criteria, which an LLM judge uses to score any response without access to the reference answer.

Table 1: Quality statistics for generated CS research tasks, graded at generation time by Kimi-K2.6 on the same 4B-weak / 397B-strong pair.

Table 1 captures the loop’s effect compactly. Under CoT Self-Instruct the weak solver averages 0.677, strong 0.696, and the gap is a mere 0.019. After the Agentic loop the weak average drops 22 points to 0.458 while the strong average rises 8 points to 0.772, widening the gap to 0.314. The accepted questions specifically reward the strong solver’s deeper reasoning rather than being answerable by both. It took 6.59 rounds on average (vs. 1.00 for CoT), and questions actually got shorter (723 → 619 chars) — harder because sharper, not longer. Rubric items stayed roughly constant (13.2 → 13.1).

The loop analysis is telling. Of 880 pre-acceptance rounds, 80% were rejected because the question was too easy (the weak solver scored too high), and 13% because the strong solver scored too high (it couldn’t reliably solve it either). The failure modes are heavily one-sided.

Figure 4: Progression of Agentic Self-Instruct generating a training example for one CS paper. A Round-1 recall/enumeration question (rejected for answer leakage) evolves into a high-gap causal-reasoning question (gap 70.2%) by round 17.

Figure 4 shows that evolution in one frame. Round 1 is a recall/enumeration question (“analyze the three-way interaction between task type, model architecture, and null-shot prompting effectiveness…”) that leaks the answer in its context and gets rejected. Over rounds, the question moves toward specific algorithmic steps, ablation details, and numerical claims that require following the paper’s actual argument — and by Round 17 it becomes a causal/thesis-consistency question (“which of the two explanations for null-CoT ineffectiveness is more consistent with the paper’s broader conclusion? Justify by explaining how the other would undermine it”), accepted with gap 70.2% (weak 21.7%, strong 91.9%).

Table 2: RL training results on CS research tasks. Qwen3.5-4B trained with GRPO on 1.3k examples per source; evaluated on a 200-prompt held-out set.

So how does this data train? In Table 2, on the easier CoT test, the base 4B goes 0.630 → 0.727 (CoT-trained) → 0.774 (Agentic-trained). On the harder Agentic test it’s 0.366 → 0.500 → 0.632, where the gap between the two methods is more than twice as large as on the CoT test. The Agentic-trained model transfers both ways — +0.05 on the easier CoT test, +0.13 on the harder Agentic test. Discriminative training data clearly translates to stronger reasoning.

Legal reasoning — the opposite failure mode

Legal has the reverse problem: standard CoT self-instruct produces questions that are too hard. In Table 3 the CoT weak-solver average is just 0.159, with many rollouts scoring zero, which hinders GRPO. The gap is large (0.558) but the reward signal is too harsh.

The Agentic loop (extractor → question+rubric writer → loop-judge) raises the weak average to 0.283 while leaving the strong roughly unchanged at 0.698, narrowing the gap to 0.415. The decisive metric is that the weak-rollout standard deviation rises from 7.93 to 12.63. CoT questions cluster weak scores near zero (mean 15.9%, median 10.7%), killing the per-group advantage; the Agentic loop pushes the weak mean up to 28.3%, spreading the same gap into a usable variance range. It reshapes the questions to be more learnable. As a byproduct, the loop judge’s textual feedback nudges the challenger toward shorter, application-style questions (900 vs. 1.6k chars), incidentally matching PRBench-Legal’s short prompt format.

The grpo_suitability verdicts make it vivid. The CoT pool is 4.8% high / 41% medium / 45% low; the Agentic pool is 52% high / 43% medium / 2% low. The median accepted question goes through 4 agentic rounds (mean 4.98, max 19), with only ~2% accepted in a single round.

Table 4: RL training results on PRBench legal reasoning. Under both GPT-5 and Kimi-K2.6 graders, the 4B model trained on Agentic data beats both the CoT-trained model and the much larger 397B baseline.

The RL results (Table 4) are the headline. On the 500-prompt PRBench-Legal split, Qwen3.5-4B RL’d on Agentic data scores 0.441 (GPT-5 grader) and 0.393 (Kimi grader), beating the same-architecture CoT-trained model (0.377 / 0.343) and even outperforming the much larger Qwen3.5-397B-A17B baseline (0.404 / 0.358) with no additional RL. The ordering holds on PRBench-Legal-Hard too. With the same 2.8k-prompt budget, same challenger, and same source corpus, the only difference is the agentic loop, yet it yields a +0.05–0.06 advantage. Using the stronger GPT-5 as an independent grader confirms the comparison isn’t Kimi-grader biased.

“More challenging” vs “just right”

This is the paper’s most important message. CS and legal are opposite failure modes of standard CoT self-instruct — CS too easy (gap 0.02), legal too hard (gap 0.56 but rollouts scoring zero). Applying the Autodata loop moves the gap in opposite directions (widening in CS, narrowing in legal), yet the downstream RL outcome is the same — the Agentic-trained model beats the CoT-trained one on every held-out test. The key is not making the question harder but making it just right for the model to hill-climb on, and the Agentic Self-Instruct loop is what lets us do that.

Scientific reasoning — harder problems transfer to easier ones

The third domain constructs challenging problems over mathematical objects in the same categories as the Principia collection. Here three data sources are compared — (i) CoT Self-Instruct (train directly on Principia problems, also used as grounding context), (ii) Agentic, and (iii) Combined (both, 2x size).

Tables 5/6: RL training on scientific reasoning (top: combined validation, bottom: out-of-distribution Principia benchmark). Agentic data yields the largest overall improvement, beating even the 2x-larger Combined data.

On combined validation (Table 5), Agentic improves most overall at +3.20% avg@8, beating direct CoT training (+2.42%) and Combined (+2.70%). Strikingly, Agentic data improves even on the CoT validation subset it wasn’t explicitly optimized for (+3.05% vs. +1.86% for CoT) — harder training transfers to easier problems.

On the out-of-distribution Principia benchmark (Table 6), Agentic again has the best overall avg@8 (+1.04%), with consistent gains on RealMath (+1.75%) and SuperGPQA (+0.82%). pass@8 reveals a trade-off, though — Combined leads on ARB (+2.13% vs. Agentic +0.00%) and RealMath (+2.37% vs. +1.74%). The interpretation: Combined’s greater volume and diversity helps the model occasionally solve a broader range of problems. avg@8 (average reliability) favors Agentic; pass@8 (probability of getting it right at least once) favors Combined.

Analysis / Ablation

Token efficiency: teaching the model to reason less

Appendix A’s analysis is interesting. Even with a 65,536-token budget, the base Qwen3.5-4B truncates (finish_reason=length) 23.75% of the time on combined-val and 17.06% on Principia — many responses can’t finish reasoning within 65K tokens. Agentic training drops these to 4.09% and 1.85% respectively. (The CoT-on-Principia source is labeled “Grounding” in that table, at 10.00% / 6.62%.)

More decisively, the attribution analysis: of 945 generations flipped from incorrect to correct, 54.81% are attributable to fixing truncation and 41.06% to improved reasoning on non-truncated examples. So about half of the accuracy gain comes not from “reasoning better” but from learning to reason more concisely within the token budget. It points to an underappreciated benefit of synthetic-data training: long-form reasoning models like Qwen3.5-4B often fail because they run out of tokens, not because they lack reasoning ability.

Data quality and difficulty over volume

The through-line across all three domains is that data quality and difficulty are a more efficient learning signal than simply scaling size. In the scientific experiment, Agentic produced a larger overall improvement than Combined (2x the data) with less data. In legal, the 4B beat the 397B baseline. In CS, discriminative data transferred both ways. Investing inference-time compute to generate higher-quality, harder data can beat growing dataset size.

Meta-optimizing the data scientist agent

Figure 6: Meta-optimization of the data scientist agent. An outer loop evaluates the agent's prompt on training papers, analyzes failure trajectories, edits the prompt via a code-editing agent, and re-evaluates on held-out papers. Changes are accepted only if they raise the weak-strong separation rate — 62.1% to 79.6%.

So far the Agentic Self-Instruct framework has been fixed. Section 4 meta-optimizes the data scientist agent itself. The meta-optimizer maintains a population of candidate prompts (each a code diff relative to the baseline repo) and, each iteration: (1) selects a parent via Boltzmann sampling → (2) evaluates the parent’s prompt on a minibatch of training papers, collecting trajectories and weak/strong scores → (3) an LLM agent analyzes the trajectories to root-cause systematic failure patterns → (4) a code-editing agent reads the analysis, history, and current prompt and produces an improved diff → (5) re-evaluates both parent and mutant on held-out validation papers → (6) accepts only if the validation score strictly exceeds the parent’s → (7) summarizes the outcome into a history log. Multiple iterations run concurrently.

Table 7: Meta-optimization of the data scientist agent on the CS research-paper task. Validation pass rate rises from 62.1% at baseline to 79.6% by iteration 124.

Starting from a ~62.1% validation pass rate, over 233 iterations (under a 6h per-session timeout) it reaches 79.6% at iteration 124 (Table 7). The four prompt modifications the optimizer discovered through trajectory analysis are especially instructive.

Paper-specific insight enforcement: questions must test knowledge specific to the paper, not generic ML/CS knowledge. Self-test: “If a solver could answer correctly without reading this specific paper, the question is too easy.”
Context leak prevention: strict rules requiring the context to describe only the problem domain and setup, never the paper’s proposed solution. Self-test: “Could someone answer by rephrasing sentences from the context? If yes, rewrite.”
Positive-only rubric with weight capping: eliminated negative-weight criteria, which historically misfired and destroyed strong scores without improving discrimination. All criteria use positive integer weights capped at 7. A counter-intuitive finding — penalizing errors seemed helpful in theory but hurt in practice.
Structured rubric format: enforced strict JSON with integer weights, eliminating parsing errors (string weights like “+8” instead of integer 8).

The progression shows meta-optimization can substantially improve data quality without manual prompt engineering — while also underscoring how hard it is to reliably generate questions that separate models of different capability.

Limitations and critical assessment

Limitations the authors acknowledge.

Hacking / cheating. The agents sometimes tried to avoid doing the work correctly — e.g., changing the prompt to the weak solver to tell it to be weak. Partially addressed by enforcing more constraints, but stronger safeguards are needed.
Questions overly tied to numbers. In CS, some generated questions and rubrics were overly bound to the paper’s specific experimental numbers rather than testing generalizable reasoning.
Example-level analysis only. Currently only example-level quality is examined. The authors want to expand to dataset-level analysis (diversity statistics, batch-level analysis feeding the next batch).

Limitations a reviewer would add.

Compute cost. The Agentic loop runs 6.59 rounds on average in CS, calling weak/strong solvers multiple times plus a judge per round. Meta-optimization runs 233 iterations, each with evaluation, analysis, code editing, and re-evaluation. The per-datapoint inference cost is plausibly orders of magnitude above CoT, yet absolute cost, wall-clock, and dollar figures are reported nowhere. The cost-benefit of “converting inference compute into data” is unmeasurable for the reader.
Judge dependence. Data acceptance and rewards lean heavily on a Kimi-K2.6 judge. The GPT-5 cross-check in legal is good, but the risk that data generation is locked into one judge model’s bias remains — the data distribution may skew toward question types that judge prefers.
A single model pair. All three domains fix weak=Qwen3.5-4B, strong=Qwen3.5-397B. Whether the same gains hold for other weak-strong pairs (a smaller gap, a non-same-family pair) or diminish as the weak model gets stronger (the authors note 4B may approach its capacity ceiling on scientific pass@8) is untested.
Ambiguity vs. Combined. In scientific reasoning, avg@8 favors Agentic but pass@8 favors Combined, so “which is better” is domain- and metric-dependent. The authors’ conjecture that a larger model would better exploit Combined is unverified.

Takeaways

The goal is “learnable” data, not “hard” data. That the same loop fixes CS (too easy) and legal (too hard) in opposite directions while improving both downstream tells us the lever is the right discriminability with a live gradient signal, not difficulty per se. The observation that weak-rollout variance governs the reward signal’s substance (7.93 → 12.63) is directly actionable for RLVR data design.
Put judge feedback inside the generation loop, not the filter. Where prior synthetic data post-filtered a static pool, Autodata feeds the judge’s verdict back to the challenger to make the next question. The reframing — optimizing for “effective learning signal” rather than “quality or difficulty” — is the core shift.
Half of synthetic-data training is token efficiency. The attribution that ~50% of the accuracy gain comes from reduced truncation (23.75% → 4.09%) is an under-told fact. Long-form reasoning models may be failing from token exhaustion, not a lack of capability.
The data pipeline is itself an optimization target. Treating the agent scaffold as a code diff and evolving it (62.1% → 79.6%) lets the meta-optimizer auto-discover counter-intuitive prompt rules like “negative rubric criteria hurt” and “enforce paper-specific knowledge.” There’s a lot of room to automate prompt engineering.
A 4B beats a 397B. That a 4B trained on good legal data outperformed a 397B with no additional RL is strong evidence that, for a given task, data appropriateness can matter more than model scale.

References

Paper: https://arxiv.org/abs/2606.25996
Authors: FAIR at Meta (Ilia Kulikov, Chenxi Whitehouse, Tianhao Wu, Yixin Nie, and 11 others)