Writing down what an agent should actually be fed may matter more than squeezing out another point on a leaderboard.
The paper daVinci-Prover on arXiv (paper: https://arxiv.org/abs/2611.16433) works on formal theorem proving. The model writes Lean 4 code inside an isolated workspace, the compiler judges it on the spot, and the model revises when it fails. What is interesting is not another benchmark entry but a set of counterintuitive controlled comparisons.
The contrast is this. According to the paper's own measurements, out of a 33.7B-token mid-training corpus only 8.4B tokens are agent trajectories that involve real environment interaction, and those 8.4B tokens produce larger gains on MiniF2F and FATE-M than a 25.3B-token corpus of general theorem-proving skill priors. The other bill is heavier: 48 H200 GPUs for about 20 days, which works out to roughly 122,000 to 146,000 US dollars if rented from a public cloud.
What the corpus contains
The corpus has two parts. One is skill priors, covering proof decomposition and assembly, verified subgoal search, error diagnosis and revision, and self-verification. The other is environment-native trajectories containing real tool calls, execution outcomes, intermediate proof states and Lean feedback. The sources are NuminaMath-LEAN, AoPS, Lean Workbook, Goedel LM/SFT_dataset_v2 and OProofs, totalling 33.7B tokens and 9.585M samples under the Qwen3.5 tokenizer, of which replay adds 5.11B and pre-replay data accounts for 28.6B. Decontamination was done too: 29 overlapping problems were found among 2,137 evaluation problems, a rate of 1.36%, worth at most 11.55M tokens, or 0.03427% of the whole corpus.
The teacher models are DeepSeek-V4-Flash and DeepSeek-V4-Flash-0731. For post-training the authors built a separate daVinci-Prover harness: the input theorem is copied verbatim into scratch/solution.lean, and at each turn the agent picks from seven tools (reading, writing and editing files, retrieving Mathlib declarations, running Lean checks). Only scratch/ and sketch/ are writable, target/ is read-only, and every Lean file edit triggers verification automatically. Bash and Python are deliberately withheld to leave room for RL later. Trajectories were collected with DeepSeek-V4-Flash-0731 on roughly 99K unverified problems from Goedel-LM/RL_dataset_V2, capped at 30 turns and 200 tool calls, leaving about 36K high-quality trajectories for SFT. Anything with fewer than 5 turns is dropped, and so is anything exceeding a 144K-token context.
How 8.4B beats 25.3B
The ablation runs on Qwen3.5-9B, where the base model sits at 87.4 on MiniF2F, 88.4 on FATE-M and 42.9 on ProofNet. Skill priors alone, at 25.3B tokens, give 87.8, 89.8 and 43.6. Agent trajectories alone, at 8.4B tokens, give 88.8, 92.2 and 43.5. Both together at 33.7B tokens give 90.1, 93.3 and 44.5. The paper's explanation is distribution alignment: at inference time the model faces tool calls, execution results and verifier feedback, so feeding the same structures during training closes the gap between static next-token training and interactive proving.
Against existing corpora, the authors match a 33B-token mid-training run against Oprover's 65B. Qwen3-8B-Base with SFT only scores 73.4, 68.0 and 28.4; Oprover-8B-Base plus SFT scores 80.3, 73.1 and 30.3; the daVinci-Prover recipe scores 85.3, 85.3 and 40.4. The paper's own reading is that composition, not only scale, is what matters.
Compressing context beats swapping parameters
One more switch is easy to overlook: memory compaction. The method is plain. When the context reaches 200K tokens, compression triggers, older interactions are replaced by deterministically extracted tool evidence, and the original theorem, the current Lean proof and recent interactions are preserved. Up to 8 compactions are allowed, and nothing in the pipeline depends on a model summarising for itself. The effect is clearer on the harder FATE-H, where the 35B model goes from 16.3 to 42.0 and the 9B model from 16.7 to 28.0. On MiniF2F both models reach 97.1, which the abstract describes as near-saturating.
What the bill looks like
The paper is unusually specific about synthesis cost. DeepSeek-V4-Flash-0731 ran on 48 NVIDIA H200 GPUs for about 20 days, roughly 23,040 GPU-hours. The Lean verification service used about 8 worker instances with 160 CPU cores and 640 GB of memory in total, roughly 76,800 CPU core-hours. At the two H200 rates Runpod lists, 5.29 and 6.35 US dollars per GPU-hour, renting the equivalent deployment costs about 122,000 to 146,000 US dollars. The paper stresses this is a reference-price estimate rather than actual spend.
My take
Two things are worth copying. First, write down what will actually happen at inference time into the training corpus, because that buys more than another half of the tokens: with 25.3B tokens of skill priors FATE-M sits at 89.8, while swapping in 8.4B of environment-native trajectories moves it to 92.2. Second, an environment that ships its own compiler, like Lean, is naturally a good agent training ground, since the verification feedback is free, automatic and reproducible, which is better than hand-made reward.
Now the cold water. The paper itself admits in its limitations section that no generalization data is replayed during mid-training, and argues that adding generalization replay is both necessary and important, so the current gains probably are not the ceiling. The other thing is that two different sets of numbers must not be mixed. The tables in the arXiv paper use Lean v4.26, a 200K context and at most 30 interactions, reporting pass@1 and pass@8 side by side. The README in the official repository (https://github.com/GAIR-NLP/daVinci-prover) ships a different setup: Lean 4.35.0, 200 interaction turns per problem, and a different backbone in DeepSeek-V4.1-flash-1012, so what it compares is harnesses rather than models. On that harness comparison daVinci-Prover scores 93.0, Claude Code 85.0, Codex 86.0 and DeepSeek Harness 93.0. On FATE-X the numbers are 47.0 against 45.0, 20.0 and 37.0. On Putnam-200 they are 87.5 against 86.0, 86.0 and 88.5, where the DeepSeek Harness column is actually 88.5, above daVinci-Prover at 87.5. Two sets of numbers should not be read as one.
Corroboration comes from two other teams. Moonshot's Kimi-Dev (paper: https://arxiv.org/abs/2509.23045) derives skill priors from agentless training and then adapts on 5k publicly available trajectories, pushing SWE-Agents to 48.6% pass@1, which the paper puts on par with Claude 3.5 Sonnet, so the recipe of prior plus a small amount of environment trajectory has already run in the code repository setting. DeepSeek-Prover-V2 (repository: https://github.com/deepseek-ai/DeepSeek-Prover-V2) takes a different route, using DeepSeek-V3 to recursively decompose subgoals into cold-start data before reinforcement learning, and its 671B model reaches an 88.9% pass ratio on MiniF2F-test while solving 49 of 658 PutnamBench problems. On the benchmark spec itself, ProverBench has 325 problems, 15 from AIME 24 and AIME 25 and 310 drawn from textbooks and tutorials, and two independent teams agree on that number.