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

> A team of four autonomous agents post-trained a 4B base model to vendor-instruct level in 104 hours for $12,000, without teacher models or human advice.

- **Source:** [arXiv](https://arxiv.org/abs/2610.21055)
- **Published:** 2026-10-17
- **Permalink:** https://picx.dev/p/y3XvS4
- **Whiteboard:** https://picx.dev/p/y3XvS4/image

## Summary

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

## Summary (Overview)

- **First demonstration of autonomous post-training at vendor-instruct level**: A team of four Claude Opus 5.5 agents, working autonomously for 104 hours, post-trains Qwen3-4B-Base from 15.9 to 67.3 on a six-task development suite and from 9.2 to 48.2 on a held-out suite, matching or surpassing the official Qwen3-4B-Instruct-2507 (66.5 and 47.9, respectively).

- **Athanor system design**: An open agent-native system built on three principles—separating research decisions from execution, externalizing research state, and keeping the research loop productive—enabling long-running campaigns of training experiments on real GPUs.

- **Recipe discovered through recombination**: The agents reach instruct-level performance by composing known methods—SFT on public reasoning data, GRPO with a novel rollout change, weight merging across agents, and self-distillation—without any teacher model calls or human research advice.

- **Four key findings on agent research behavior**: (1) recombination of known methods, (2) effective team progress through checkpoint sharing, (3) early recipe convergence limiting exploration, and (4) uneven data sense (agents check data format but rarely correctness).

- **Cost efficiency**: The entire campaign costs approximately $12,000 (GPU time at rental prices plus agent inference), with agent inference accounting for only 9% of the total.

## Introduction and Theoretical Foundation

### Background and Motivation

The paper addresses **recursive self-improvement (RSI)**—the concept that AI systems can build stronger AI systems. The authors study a measurable weaker form: frontier agents post-training a small raw base model with public data as a test of their research potential. Post-training (as opposed to pretraining) shapes instruction following, reasoning, coding, and alignment, yet remains an expensive iterative search typically documented only through final recipes rather than full research trajectories.

### Problem Formulation: The AutoPostTrain Loop

The formal framework defines autonomous post-training research as a search over executable recipes:

$$
\begin{array}{r l} \text { RESEARCH } & r _ {t} \sim \pi (\cdot   |   \mathcal {H} _ {t - 1}), \qquad r _ {t} \in \mathcal {R} (\mathcal {P} _ {t - 1}), \\ \text { EXPERIMENT } & M _ {t} = \text { Exec } (r _ {t}), \qquad \widehat {\mathbf {p}} _ {t} = \text { Eval } _ {\mathcal {B}} (M _ {t}; \xi_ {t}), \\ \text { OBJECTIVE } & M _ {T} ^ {\star} \in \underset {M \in \mathcal {P} _ {T}} {\arg \max} c (M). \end{array}\tag{AutoPostTrain}
$$

Where:
- $r_t$ is the recipe proposed by policy $\pi$ at step $t$
- $M_t = \text{Exec}(r_t)$ is the checkpoint produced by executing the recipe
- $\widehat{\mathbf{p}}_t$ is the benchmark score vector (with evaluation randomness $\xi_t$)
- $\mathcal{P}_t$ is the pool of available checkpoints
- $c(M)$ is the latent (unobservable) capability of checkpoint $M$ (estimated by benchmark suite $\mathcal{B}$)
- $\mathcal{H}_{t-1}$ is the history of recipes, programs, measurements, failures, and notes

### What Makes AutoPostTrain Hard

The paper identifies three core challenges:

1. **Combinatorial, state-dependent search**: The recipe space is high-dimensional and compositional (data choices, methods, hyperparameters, stage order), with each stage conditioning what later stages can achieve. The outer loop is stochastic black-box hill climbing since benchmark scores are not differentiable with respect to recipes.

2. **Delayed, noisy, and incomplete feedback**: Each recipe requires full training and evaluation before feedback arrives, with delay $\tau_{\text{fb},t} = \tau_{\text{exec}}(r_t) + \tau_{\text{eval}}(M_t, \mathcal{B})$. Scores are noisy (finite evaluation) and incomplete (each benchmark covers only part of a capability).

3. **Scaling the research process**: Unlike pretraining scaling laws that relate loss to compute for fixed procedures, no stable law relates post-training compute to downstream performance when the recipe itself is being searched. The authors introduce **autoresearch scaling** as the relationship between research output (best checkpoint capability $c(M_T^\star)$ and accumulated understanding) and compute/resources spent.

## Methodology

### System Design: Athanor

Athanor implements the AutoPostTrain loop as two concurrent loops over one shared history (Algorithm 1):

```python
history = persistent_record()

Each researcher of the team
while research_open():
    evidence = inspect(history)  # own, teammates'
    action = agent.develop(evidence)
    athanor(action)  # job / eval / data / artifact

Environment services (run independently)
while execution_open():
    updates = collect_job_updates()
    history.record(update)
    # Train, evaluate, decontaminate, store.
    for job in ready_work(history):
    launch_async(job)
```

### Three Design Principles

1. **Separate research decisions from execution**: The agent chooses recipes; the environment handles resource allocation, job execution, checkpoint storage, evaluation, and recovery. The evaluator runs outside the agent's sandbox with verifiable rules.

2. **Externalize the research state**: A persistent research record contains four entry types—journal (time-ordered log), lineage (checkpoint ancestry), transcript (full agent sessions), and workspace history (including agent notes). This enables session resumption, team collaboration, and full auditability.

3. **Keep the research loop productive**: Jobs run in the background, survive session endings, and push results to agents as they arrive, allowing multiple experiments in flight simultaneously.

### Experimental Setting

- **Agents**: Four Claude Opus 5.5 agents in Claude Code, each with one node (8 GPUs with 80 GB HBM3 each)
- **Goal**: Single sentence—raise the development-suite score of a model post-trained from Qwen3-4B-Base as high as possible
- **Constraints**: No teacher models, no human research advice, public data only (decontaminated against benchmarks)
- **Evaluation**: Six-task development suite (mathematics, logic, code, knowledge, instruction following, multi-step action) plus a sealed held-out twin suite with different questions for the same capabilities

### Evaluation Suites

Each held-out task is the "twin" of a development task—measuring the same capability on different material:

| Capability | Development Task | Held-out Twin |
|---|---|---|
| Mathematics | Math contests (early 2025) | Math contests (Nov 2025) |
| Logic | ZebraLogic (half 1) | ZebraLogic (half 2) |
| Code | LiveCodeBench (2024) | LiveCodeBench (2025) |
| Knowledge | MMLU-Pro | SuperGPQA |
| Instruction Following | IFEval | IFBench |
| Multi-step Action | ALFWorld (4 task types) | ALFWorld (other 2 types) |

## Empirical Validation / Results

### Main Results

Under the **final measurement** protocol (up to 32,768 output tokens, sampled decoding):

| Model | Development Mean | Held-out Mean |
|---|---|---|
| Qwen3-4B-Base | 15.9 | 9.2 |
| **Team submission (ours)** | **67.3** | **48.2** |
| Qwen3-4B-Instruct-2507 | 66.5 | 47.9 |
| Qwen3-4B (hybrid) | 73.3 | 50.6 |
| Qwen3-4B-Thinking-2507 | 80.5 | 63.0 |

The team's submission is **statistically indistinguishable** from Instruct-2507 (paired 95% intervals: −0.8 to +2.4 on development, −2.0 to +2.6 on held-out, both containing zero).

### Task Profile Differences

The submission beats Instruct-2507 on:
- Multi-step action: 95.6 vs. 81.8 (development), 74.7 vs. 66.8 (held-out)
- Code: 51.1 vs. 45.1 (development), 37.9 vs. 33.6 (held-out)

But trails on:
- Logic: 63.0 vs. 79.5 (development), 62.5 vs. 77.7 (held-out)
- Mathematics: 38.4 vs. 44.2 (development), 33.3 vs. 42.5 (held-out)

### Execution Effectiveness

- **GPU utilization**: Jobs hold GPUs for 93% of available hours (3,086 of 3,315); training takes 54% (40% GRPO alone), sampling 17%, evaluation 22%
- **Agent efficiency**: Agents work (reasoning or tool calls) only ~9% of session time; reasoning takes 15 hours total (3.6%); 87% of time is spent waiting on jobs
- **Cost breakdown**: GPU time ≈ $10,800 at $3.49/GPU-hour; agent inference ≈ $1,074 (9% of total); total ≈ $11,800
- **Reliability**: 26 of 500 jobs failed (mostly agent program errors); platform reclaimed 3 of 4 nodes during the run; all checkpoints and lineages recovered from the record

### The Discovered Recipe

The lineage of the team's submission passes through four stages:

1. **SFT**: Each agent builds a mixture of ~300–600K rows covering all six capabilities, fine-tuning the base for one epoch (reaching 49.7)
2. **GRPO with rollout change**: Agent 3 discovers that greedy decoding (with probability 1/4) fixes repetition loops in evaluation (reaching 61.7)
3. **Weight merging**: Agent 4 averages models from multiple agents; Agent 3 extrapolates task vectors with factor $f = 1.2$–$1.3$ (reaching 65.5)
4. **Self-distillation**: Agents sample 4 answers per problem, keep shortest correct ones, fine-tune (reaching 66.1); averaging two agents' self-distilled models gives the submission

## Theoretical and Practical Implications

### Implications for Autonomous Research

1. **Execution friction is the bottleneck, not ideas**: Once execution is handled, agents demonstrate sufficient engineering, planning, reasoning, and post-training knowledge to reach vendor-instruct levels from a raw base model.

2. **The search converges too early**: All four agents converge on the same corpus (AM-Thinking-v1-Distilled, 76–87% of each agent's first mixture) within the first hour and test few alternatives. This represents a shared "idea basin" that limits exploration.

3. **Automated scientific discovery**: The campaign record converts open post-training questions into measurements—e.g., averaging two equally strong models from different lineages gains 2–3 points, moving a merge further from base trades knowledge for logic, and self-distillation adds ~1 point.

4. **Autoresearch scaling**: The capability curve (Figure 1) shows rapid early gains (reaching 60 within the first day) followed by diminishing returns (~7 points over the remaining 3 days), driven by recipe convergence and lack of new data sources.

### Practical Implications

- Anyone who can automatically score desired behavior can have agents post-train models for it, given tokens and GPUs
- The system's design principles (separation of concerns, externalized state, productive loops) could generalize to other domains of autonomous research
- The complete research record serves as training data for future autoresearch models

## Conclusion

Athanor enables frontier agents to run AutoPostTrain end-to-end, demonstrating that a team of four agents can post-train a raw base model to the level of the vendor's instruct release in 104 hours for ~$12,000—without teacher models or human research advice. The agents achieve this by recombining known methods (SFT, GRPO, weight merging, self-distillation) and fixing problems their own measurements expose.

**Key limitations**: The result comes from one campaign with one base model and one agent model; the team reaches the vendor's instruct release but not its reasoning releases; much of the public training data was itself distilled from stronger models by its publishers.

**Future directions**: The authors point toward a broader autoresearch loop where agents construct evaluation suites, build the next research environments, run data flywheels, and where complete research trajectories become training data for models built to do autoresearch. The clearest observed limit—diversity of ideas—suggests that improving idea diversity (through agent heterogeneity or better exploration incentives) could be a key lever for scaling autonomous AI research.

---

_Markdown view of https://picx.dev/p/y3XvS4, served by PicX — AI-generated visual whiteboard summaries of research papers._