Amazon Publishes Its Post-Training Recipe: Eight Stages, No Secret Teacher

Amazon's research team has written a complete post-training pipeline into a paper titled Rufus-Air: An Open LLM Post-Training Recipe. Rufus is the name Amazon uses for its shopping assistant; naming the training recipe after it makes the deployment intent fairly obvious.

First, let's be clear about what post-training is. Pre-training lets a model learn to speak; post-training determines whether it can get things done. The former feeds massive amounts of text; the latter feeds tasks, gives rewards, and adjusts behavior. What the industry publishes publicly is often only results—for example, how many points a model scored on a leaderboard—and the specifics of training are glossed over with a line like 'we did careful post-training.' This paper does the opposite: it lays out the stage order, data composition, reward design, infrastructure, and results for each stage.

The base model is GLM-4.5-Air-Base, a 106B-total-parameter, 12B-activated-parameter MoE. Total parameters are how much stock is in the warehouse; activated parameters are how much is actually called on for each job. That is the benefit of MoE: parameters can be stacked large, while the cost of a single inference is calculated based on the activated portion.

The eight stages run in sequence:

1. SFT, supervised fine-tuning. Use existing question-answer pairs to teach the model basic format and speaking style.
2. Reasoning RL, reinforcement learning for reasoning. Train math, logic, and similar problems with standard answers.
3. Coding RL, reinforcement learning for code. Run test cases; score if they pass.
4. Instruction-Following RL. Practice 'if I ask for three paragraphs, don't write five.'
5. General Agent. Learn to call tools and execute multi-step tasks.
6. Coding Agent. Modify code in real repositories and run tests.
7. Search Agent. Practice retrieval, filtering, and assembling information into an answer.
8. RLHF, human preference alignment. Make outputs more like what people want.

There is a clear design along this line: rewards go from hard to soft. The first few stages use verifiable rewards: rule-based scoring, whether unit tests pass, so right and wrong are determinate. As tasks become harder to judge by rules later, the recipe switches to judge models or reward models for scoring, relying on soft judgment. First learn to get it right, then learn to do it well. The paper does not explicitly say what happens if the order is reversed, but one can imagine: letting a model align with human preferences before it has learned to get code running is like teaching calligraphy to someone who cannot write.

The engineering effort is also described in detail. It uses open-source components such as Slime, Megatron-LM, and SGLang, adapting them rather than rebuilding them. Most data is used as released, with no new human annotation and no internal distilled teacher model.

That last sentence is key. Many post-training recipes get stuck here: 'We have a stronger teacher model; distill it and performance goes up.' Saying that is as good as saying nothing, because others don't have that teacher and can't reproduce it. Amazon's version closes off that path: it runs hard with public data and open-source tools, and only what comes out that way can really be called reproducible.

Some people's first reaction to eight stages is that it burns GPUs. Indeed, running the full pipeline once will not use a small amount of GPU-hours. But the paper states its goal clearly: let other teams reproduce or reuse parts of it stage by stage. That means you don't have to run it from start to finish; teams lacking coding ability can go straight to stages 3 and 6, and those lacking tool-calling experience can look at stage 5. The recipe is split into eight modules that can be tackled independently, which is actually an opening for teams with limited compute.

There is another point worth noting: what this recipe best demonstrates may not be what it uses, but what it doesn't use. No new annotations, no distillation, no closed-source components—it pushes capabilities up with a sequence of stages and reward design. If this path can work reliably, the barrier to post-training will be somewhat lower than imagined.

Paper: https://arxiv.org/abs/2609.29421

Hugging Face Papers: https://huggingface.co/papers/2609.29421

If you could reproduce only one of these stages, which would you pick?