BigBang-V1: When AI Starts Writing Its Own Training Data

For the past two years the story of AI progress has been compute: bigger clusters, longer training runs, more tokens. The open-source release of BigBang-V1 points at a quieter bottleneck that is starting to bind — human question-writing. The model, a 35B-parameter agentic model (3B active) from the Chinese team Endless Frontier, was trained on post-training data that is 100% AI-synthesized: the questions, the solutions, and the verification were all produced by AI itself. On eight representative benchmarks it records the highest scores among 35B-scale models — and on FrontierScience Research, Humanity's Last Exam, PaperBench (Code-Dev) and BioMysteryBench-HD it beats DeepSeek V4 Pro Preview, a 1.6T model more than 45x its size.

The pipeline: two agents, one factory that retools itself

Built on the Qwen3.6-35B-A3B base and open-sourced on Hugging Face and GitHub, BigBang-V1 is the team's bid to build what they call the first foundation model trained natively with a recursive self-improving (RSI) loop — and, more importantly, to move RSI from concept to engineering. The team behind it pairs Shanghai Jiao Tong University's AI Institute with DP Technology (深势科技) and the Shanghai Institute of Algorithm Innovation, with roots in the SciMaster research agent that previously topped OpenAI's FrontierScience leaderboard.

The data system runs on two classes of agents. A Generator Agent proposes and solves hard tasks in science, engineering and AI research. It is not a prompt-templated question machine: it directly writes, runs and debugs the data-synthesis programs, picks which scientific domains to draw from, decides how long a reasoning chain should be, and records what failed so the next round inherits the lessons. A Critic Agent audits candidates adversarially — first on format, tool execution, data integrity and constraint satisfaction, then on whether a task is correct, verifiable, difficult, diverse and genuinely worth training on. Tasks that fail are rejected or sent back for rework.

Two properties make a task fit for this loop. It must be frontier — at the edge of current knowledge, ideally with no known answer, so it cannot be exhausted like a static question bank. And it must be verifiable — checkable through formal methods, code execution, numerical computation, simulators or domain tools. Science satisfies both at once, which is why the team uses it as the training ground: an open-ended generator of new problems whose answers can be objectively checked.

The AlphaGo move: self-play with an outer loop

The Generator-versus-Critic dynamic is essentially AlphaGo-style self-play, with the board swapped for open-ended science tasks. But self-play has a known failure mode: the Generator learns to please the Critic, producing data that looks sophisticated and scores high yet fails to transfer to real tasks. BigBang's answer is a second, slower loop. The system builds different versions of the data pipeline, trains models on each, and evaluates them on held-out real research tasks. If data the Critic rated highly does not actually make models stronger, the Critic's criteria are recalibrated and the Generator is redirected; if a narrow-looking scientific task yields broad gains in search, reasoning or tool use, the system doubles down. This outer loop is what keeps the pipeline honest — and keeps it moving, because as the model gets stronger, tasks that once seemed hard become cheap, and the system retires them and pushes toward the new frontier.

This is the "data-layer RSI" that matters: the data production system itself becomes the object being optimized, evolving alongside the model. It is a different bet than the two approaches most labs are actually shipping — wrapping models in a harness so they can call tools and tweak prompts (which leaves the training pipeline untouched), or filtering generated data with human-written scoring rubrics (which stop being useful the moment models outgrow them).

What it signals

Three structural shifts are worth taking seriously:

  • The competitive frontier moves from compute to data intelligence. If a 35B model can outscore a 1.6T one because its training data is better, then model quality becomes a function of the data flywheel, not the GPU count. That changes who can compete — and reopens the question of whether the biggest labs' compute moats are as wide as they look.
  • Static question banks devalue fast. Models consume fixed benchmarks the way they consume fixed data. A system that generates its own frontier tasks removes the human question-writing bottleneck entirely — and quietly reshapes the market for evaluation and benchmark data.
  • A redivision of labor in AI development. Humans still set research goals, budgets, risk boundaries and acceptance criteria; AI runs the large-scale exploration, experiments, failure bookkeeping and next-round data production. The constraint that used to be "human experts author each training example" is being replaced by "humans audit the system that authors them."

The risks are real, and the team is explicit about them: critic collusion, evaluation overfitting, and the general problem that self-referential systems need external ground truth. Their mitigation is verification chains plus the training-result outer loop — an architecture worth watching to see whether it holds as scale grows. Notably, the model cannot rewrite its own evaluation criteria, and high Critic scores alone cannot approve data into the next training round.

What to do with this

  • If you build training or eval data: audit your pipeline against the two criteria — frontier-ness and verifiability. Data that is neither will depreciate quickly regardless of how much you clean it.
  • Try it: BigBang-V1 is open — model on Hugging Face, code on GitHub, with the harness and reported benchmark results included.
  • Watch the economics: if data-layer RSI holds up, the binding constraint on frontier models shifts from "how many GPUs" to "how good is your data production loop." Labs that treat data generation as a first-class system — not a cleanup chore — are the ones to watch.

Compute bought the last two generations of progress. The next one may be bought with a better question.

Scroll to Top