Athanor: An Agent-Native System for Autonomous Post-Training Research

The core question is whether frontier agents can autonomously post-train a raw base model into a general-purpose model across domains without an external teacher model or human research advice.

• Complexity and current state of post-training research: Post-training determines a language model's instruction following, reasoning, code, and alignment capabilities; however, current post-training research relies heavily on expensive trial-and-error search, and public reports often record only the final recipe without the complete experimental trajectory that produced it.
• Limitations of existing automated post-training: Existing work (such as PostTrainBench, Locus, etc.) is mostly limited to training specialized expert models for a single benchmark, or depends on external teacher models for guidance, lacking a research setting that evaluates a single general-purpose model on strictly isolated unseen held-out sets.
• Core engineering bottleneck in automated research: The authors argue that as agent reasoning capabilities improve, the bottleneck in autonomous research shifts from hypothesis generation to the friction cost of execution and verification; without hosted execution, agents spend substantial time debugging infrastructure and repeatedly setting up experimental environments.
• System-level solution: The authors propose Athanor, an open-source agent-native post-training system that decouples research decisions from underlying experiment execution and persists complete research records externally, supporting agent teams in conducting long-horizon end-to-end experiments on real GPU clusters.

According to the paper's introduction and related work sections, related research mainly falls into three groups:

Automated post-training

• PostTrainBench (Rank et al., 2026) and Locus (2026) — PostTrainBench has agents post-train small base models on a single benchmark under a single GPU and 10-hour budget; Locus extends this to parallel multi-day search, but both only build specialized models for a single benchmark. Lim et al. (2026) analyzed PostTrainBench trajectories and found that agents rarely change strategies across consecutive training attempts.
• RSI-Master and RSIGym (Du et al., 2026; Meng et al., 2026) — Also trained on single tasks, via access to external model APIs and training and evaluation after remote services, respectively.
• RSI Arena (Bake AI, 2026) and A-Evolve-Training (Shi et al., 2026) — RSI Arena has ten agents as competitors post-train a 30B model on a shared cluster with human preference ranking; A-Evolve-Training conducted four rounds of autonomous evolutionary training of a 30B model (as well as 120B and 550B).

Agents that improve AI systems

• Code and inference framework optimization (Liu et al., 2026; Xia et al., 2026; Zhang et al., 2026; Z.ai, 2026) — Agents are used to improve their own code, test frameworks, inference engineering, and even online production inference services. The authors note these works optimize the system and code layers surrounding the model, whereas the agents in this paper directly modify model weights.

Autonomous research and teams of agents

• Autonomous research systems and benchmarks (Lu et al., 2026; Novikov et al., 2025; Chan et al., 2025; Wijk et al., 2025) — Systems conduct end-to-end machine learning experiments over hours to days, with benchmarks evaluating agents' machine learning engineering and research capabilities.
• Multi-agent team dynamics and limitations (Park et al., 2026; Anthropic Frontier Red Team, 2026; Cai et al., 2026) — Park et al. found that homogeneous agents sharing a workspace outperform independent agents when a verifier filters outputs; Anthropic reports that agents sharing models, frameworks, and context behave highly similarly; Cai et al. point out that a single agent can fall into an "idea basin."

Comparison baselines and evaluation benchmarks

• Baseline models include Qwen3-4B-Base, the Default starter with no research runs from the default starting code, and the officially released Qwen3-4B-Instruct-2507, Qwen3-4B (hybrid reasoning version), and Qwen3-4B-Thinking-2507. The evaluation benchmarks comprise a development set of 6 tasks and an unseen twin held-out set, covering mathematics (early 2025 competitions / late 2025 to 2026 competitions), logic (two halves of ZebraLogic), code (LiveCodeBench 2024 / 2025), knowledge (MMLU-Pro / SuperGPQA), instruction following (IFEval / IFBench), and multi-step actions (ALFWorld 4 types / 2 unseen types).

The authors note that, unlike previous systems that train single-benchmark expert models or rely on external teacher models, this paper's setting has a team of four agents jointly building a single general-purpose model over multiple days, without calling external teachers, and validates generalization on a fully isolated twin held-out set.

The overall approach is to build an open agent-native system Athanor for real GPUs, decoupling research decisions from low-level experiment execution, giving agents full autonomy in programming and decision-making, with the environment providing asynchronous execution and objective evaluation.

Problem formalization and dual-loop architecture

• AutoPostTrain formalization: Search over the executable recipe space r ∈ ℛ(P_t−1), execution produces checkpoint M_t = Exec(r_t), and the evaluation suite gives a score vector p̂_t = Eval_ℬ(M_t; ξ_t), with the goal of finding the checkpoint with the highest potential capability. The agent acts as a policy π(r_t ∣ ℋ_t−1), continuously proposing new recipes based on historical records.
• Concurrent dual-loop mechanism: The system is divided into an agent research loop and an environment service loop. Agents read history in the workspace, autonomously write code, and initiate tasks through unified commands; the environment service asynchronously schedules GPU resources in the background, executes training and evaluation, and writes results back to the shared record.

Role division and sandbox environment isolation

• Three-way separation of powers design: Researcher agents have full research decision authority but cannot modify the evaluator or access the held-out set; the environment service handles task queue management, decontamination, and objective evaluation; operators handle startup configuration, recovery of failed nodes, and scoring on the held-out set after the event, without providing any research guidance.
• Environment security and data decontamination: Agents run in GPU node sandboxes with read-only network access (prohibiting external communication and downloading teacher models). The evaluator and decontamination service run in separate network namespaces; the decontamination rule converts text to lowercase without punctuation, extracts 13-word sequences, and removes them if they overlap with benchmark questions by 50%.

Externalized research records and asynchronous scheduling

• Four types of externalized persistent records: A chronological log (Journal) records each request and state change; a lineage graph (Lineage) tracks checkpoint evolution parent-child relationships; a transcript (Transcript) saves complete agent interactions; workspace history saves Git versions and notes. This enables seamless recovery on new nodes after node interruption and supports team members reading each other's work.
• Non-blocking asynchronous execution: Agents return immediately after submitting training or evaluation commands without synchronously waiting in the session; the environment service pushes log summaries and scores to the agent session after completing jobs in the background, keeping agents continuously planning and analyzing.

Four-stage recipe for autonomous agent evolution

• SFT stage: Within the first hour, agents build a high-quality mixed corpus of 300,000 to 600,000 rows from the public data pool, covering all 6 capabilities, and perform a single epoch of fine-tuning on the base model.
• GRPO reinforcement learning stage: Reinforcement learning based on rule-based rewards. To address the problem of greedy decoding falling into repetitive loops, agents autonomously modify the training code to set a quarter of rollouts to greedy decoding, giving loop outputs negative advantages and effectively suppressing repetition.
• Cross-agent weight fusion and extrapolation: Agents perform weighted averaging of checkpoints trained by multiple members and extrapolate away from the base using task vector scaling (coefficients 1.2 to 1.3), improving logic capability.
• Rejection-sampled self-distillation (RFT): From the fused model, sample 4 solutions per training question, retain the answer judged correct by rules with the shortest length, and perform self-distillation fine-tuning.

Experimental Setup

• Models under test: Qwen3-4B-Base, the default starter code artifact (Default starter), the official reference models (Qwen3-4B-Instruct-2507, Qwen3-4B hybrid reasoning version, Qwen3-4B-Thinking-2507), as well as the checkpoint submitted by the agent team (Team submission, i.e., Agent 3's submission) and the individual submissions of the four agents (Agent 1, Agent 2, Agent 3, Agent 4).
• Datasets and evaluation benchmarks: The development set (visible) contains 2025 early-year math competitions (183 problems), half of ZebraLogic (500 problems), LiveCodeBench 2024 (511 problems), MMLU-Pro (2,000 problems), IFEval (541 problems), and 4 task types of ALFWorld (91 games); the twin held-out set (sealed) contains 2025 late-year to 2026 early-year math competitions (93 problems), the other half of ZebraLogic (500 problems), LiveCodeBench 2025 (175 problems), SuperGPQA (1,000 problems), IFBench (300 problems), and 2 unseen task types of ALFWorld (85 games).
• Training resources and data pool: 4 agents driven by Claude Opus 5.5 (xhigh reasoning effort), each allocated 1 node equipped with 8 80GB HBM3 GPUs (32 GPUs in total), with a research window of 104 hours. The public data pool contains 447 decontaminated datasets (about 384 million rows).
• Evaluation protocol and judging method: All tasks are scored by deterministic rules or test-case programs, with no LLM judge. Under the activity protocol, math tasks are sampled 4 times (temperature 0.6, top-p 0.95), the remaining tasks use greedy decoding, and the maximum output tokens are 16,384 for math/logic/code, 8,192 for knowledge/instruction, and 256 per step for ALFWorld; the final measurement relaxes the output limit to 32,768 (8,192 per step for ALFWorld) and uniformly adopts the recommended sampling parameters for thinking mode (temperature 0.6, top-p 0.95, top-k 20).
• Sample size and number of repetitions: Under the activity protocol, each reference model is evaluated with 2 seeds and the team submission with 3 seeds; in the final measurement, each model is evaluated with 4 seeds.

Main Results

The table below presents the average scores of each model on the development set and the held-out set (according to Table 1):

Swipe horizontally to read the table

• The authors point out that under the final measurement, the team-submitted model reaches an average score of 67.3 on the development set (higher than Instruct-2507's 66.5) and an average score of 48.2 on the unseen held-out set (higher than Instruct-2507's 47.9); the paired 95% confidence interval includes 0, indicating that the two models are statistically indistinguishable.
• The authors' analysis finds that the team model differs from the vendor version in task distribution: it outperforms Instruct-2507 on multi-step actions (development set 98.9 vs 82.4, held-out set 78.8 vs 65.9) and code (47.1 vs 43.9, 34.9 vs 31.4), but lags behind on logic (63.4 vs 80.4) and math (37.2 vs 42.9); after removing action tasks, the team lags behind Instruct-2507 by 3.7 points and 4.2 points on the development set and held-out set, respectively.
• The authors report that the team model matches the vendor's instruction-tuned version (Instruct-2507), but has not yet reached the level of the reasoning version with dedicated long chain of thought (Thinking-2507: development set 80.5, held-out set 63.0).

Analysis of Agent Research Behavior and Collaboration Dynamics

• What was measured: Statistics on 500 jobs, 255 full evaluation runs, 160 note versions, and checkpoint exchange records during the 104-hour activity.
• Results: Before the operator informed them at hour 15.8 that the final score would depend on the team submission, agents read teammates' files only 37 times and did not pull models; after the notification, agents immediately began collaborating, cumulatively pulling teammates' checkpoints 57 times (Figure 7a). After hour 21, all checkpoints that set new high scores were multi-agent model fusions or retraining on such fusions (Figure 6). Of the 32 checkpoints evaluated after hour 84, 28 integrated the training results of all 4 agents (Figure 7b).
• The authors' interpretation: The authors believe that, given an objective evaluator as a verification baseline, immediate sharing of results and cooperation among agents can effectively drive performance improvement.

Analysis of the Truncation and Scale Mechanisms of the Logic and Math Capability Gap

• What was measured: Analysis of the output truncation rates and problem-scale performance of the team model and Instruct-2507 on development-set logic and math tasks.
• Results: Under the activity protocol, the team model's extended long reasoning causes 17.5% of logic answers and 24.2% of math answers to hit the 16,384 token limit, be truncated, and be scored 0, whereas Instruct-2507's truncation rates are only 0.8% and 9.8% (Appendix D.1). Among samples that could complete an answer, the team model's logic accuracy is 76.4% (Instruct-2507: 81.0%) and math accuracy is 50.1% (Instruct-2507: 47.2%). After relaxing the output limit to 32,768 tokens, the team's logic score changes only from 63.4 to 63.0 (still behind Instruct-2507's 79.5). Figure 11 shows that truncation and score loss are highly concentrated in large-scale grid puzzles (number of cells greater than or equal to 21).
• The authors' interpretation: The authors state that truncation is not the sole cause of the logic lag; the model itself lacks sufficient correct training samples for large-scale complex puzzles.

System Operating Efficiency and Cost Breakdown

• What was measured: Statistics on agent working-time allocation, GPU utilization, and financial cost.
• Results: Of 416 total agent work-hours, time spent by agents in reasoning or tool-calling states accounts for only about 9%, of which autonomous reasoning analysis takes 15 hours (3.6%), and 87% of session time is spent waiting for background jobs to complete (Figure 3b). Of 3,315 total GPU hours, job occupancy reaches 93% (3,086 hours), and idle waiting for agents accounts for less than 1%. Total financial cost is about $11,800, of which GPU rental costs are about $10,800 and agent reasoning costs are $1,074 (about 9%) (Figure 4a).
• The authors' interpretation: The authors state that infrastructure hosting greatly reduces execution friction, keeps expensive compute utilization at a very high level, and the overhead brought by agent intelligence accounts for only a small part of the overall cost.

Other Ablations and Analyses

• Greedy mixed sampling (Agent 3): After changing 25% of rollouts in GRPO to greedy decoding, the checkpoint's development-set average score rises from 49.7 to 57.3 (Trace 1).
• Weight extrapolation scaling (Agent 3): When the scaling coefficient of the fused model's task vector relative to the base is increased from 1.0 to 1.2, the logic score rises from 56.4 to 63.0, but when scaled to 1.3 the knowledge score drops from 66.8 to 63.8 (Figure 8b, Appendix D.6).
• Rejection-sampling self-distillation (Agent 3): Fine-tuning on the shortest correct solutions extracted from the fused checkpoint's own samples raises the development-set average score by 1.0 point in the first round (from 63.97 to 64.99), with subsequent rounds changing by no more than 0.2 points (Trace 4, Table 11).
• Single-evaluation noise bias: Among 23 candidate checkpoints evaluated with multiple seeds, 19 have their 1st seed higher than the mean of subsequent seeds, with an average overestimate of 0.4 points and a maximum overestimate of 1.1 points (Figure 8a).
• Negative ablation of logic-solver trajectories: Agent 2 attempted fine-tuning on 6,900 simulated solving trajectories, causing the logic diagnostic score to drop from about 49 to 27 (Trace 7).
• Negative ablation of an alternative training-data branch: Agent 3 attempted to train branch B on other data away from the main corpus; the development-set score stayed at only about 55, and after fusion it instead diluted the logic score and was discarded (Trace 6).
• Negative ablation of length penalty: Adding a length penalty to reinforcement learning causes the development-set score to drop from 65.1 at step 10 to 64.6 at step 20 (Appendix D.2).

Limitations noted by the authors and future directions

• Single-run activity and reproducibility limits of homogeneous agents: The results come from only a single run, completed by four identical agents working collaboratively, and each agent's submissions are not independent repeated trials; repeated experiments are needed to explore variability across different runs, and non-collaborative settings are needed to identify the specific gains from the team mechanism (Section 8).
• Transferability across base model scale and model families is unverified: The study uses only a 4B-scale base model to support high-frequency training and evaluation within a single run; whether the recipes discovered by the agents transfer to larger parameter scales or other model families remains unverified (Section 8).
• Effect of agent model heterogeneity on search diversity: Four agents based on the same model converged to a single data recipe early in the search; whether agent teams based on other models or mixing different models can produce broader search strategies remains to be explored (Section 8).
• Not yet reaching the level of vendor frontier reasoning models: Although the team model matches the vendor Instruct version, it still clearly lags behind the reasoning release version with explicit long thinking processes (Thinking-2507) in the final measurements (Section 8).
• Dependence on implicitly distilled knowledge in public corpora: Although the agents did not directly call an external teacher model, the public datasets used for fine-tuning were mostly distilled by their publishers from stronger models, so the results reflect the ceiling of using public resources rather than pure self-evolution from the base model (Section 8).
• Building a more complete autonomous research loop: Future work could hand over human-preset steps to the agents, including having agents construct evaluation benchmarks, build post-training environments through meta-loops, and build a data flywheel for self-generation and verification of synthetic data (Section 6).

Experimental coverage

• The tested base model is only Qwen3-4B-Base, a single 4B-parameter model.
• The researcher agents use only a single architecture, Claude Opus 5.5 (running in Claude Code), with a fixed count of 4.
• The hardware computing environment is 4 server nodes, each equipped with 8 80GB HBM3 GPUs, with a total run duration of 104 hours.
• The evaluation benchmarks cover 6 tasks: mathematics, logic, code, knowledge, instruction following, and multi-step actions, with the development set and held-out set each containing 6 corresponding datasets.
• All reward signals for reinforcement learning and self-distillation are deterministic rule-based verification (1 for correct, 0 for incorrect); the paper does not test model-based or human-preference reward models.

• Research positioning: Aiming at the research potential of frontier large language models to autonomously improve themselves, the paper proposes Athanor, an open system for automated post-training research. The authors state this is the first known demonstration of a frontier agent team autonomously training a raw base model to the level of the vendor's official instruction-tuned version, without human research suggestions or external teacher models.
• Core challenges and design: Targeting the difficulties of high-dimensional post-training search states, delayed feedback, and engineering failure friction, Athanor implements a strict decoupling of research decisions from low-level execution, builds an externalized persistent record system containing logs, code versions, and checkpoint lineage, and provides asynchronous non-blocking task scheduling along with protected automated decontamination and evaluation environments.
• Agent exploration methods: Four agents powered by Claude Opus 5.5 autonomously completed, within 104 hours, SFT covering all capabilities, GRPO reinforcement learning that introduced greedy sampling to suppress repetitive outputs, cross-agent weight extrapolation fusion, and rejection-sampled self-distillation (RFT) based on their own shortest correct solutions.
• Core experimental results: In an evaluation system comprising 6 tasks, the team's final submitted model improved the average development set score under final measurement from the base's 15.9 to 67.3 (official Qwen3-4B-Instruct-2507: 66.5), and on the unseen twin held-out set from 9.2 to 48.2 (official: 47.9); the total cost of the entire process was approximately $11,800 (GPU rental accounted for $10,800, agent inference only $1,074).
• Research insights and implications: The authors' analysis shows that the agents possess strong engineering implementation, known-method recombination, and team collaboration capabilities, and quickly shared checkpoints after learning of the team evaluation mechanism; however, homogeneous agents showed early convergence and insufficient diversity in priors and data selection. The authors believe that with execution friction eliminated, the current bottleneck lies in idea diversity, and Athanor lays the foundation for future scalable autonomous AI research and development.