Last night I was on a walk, listening to an episode of the Latent Space podcast with Eiso Kant of Poolside AI. At some point he says he has “a not commonly held opinion that reinforcement learning will move earlier and earlier into training”1, out of post-training, through mid-training, into pre-training.
I stopped walking for a moment because I realized I no longer knew what these words mean. Pre-training, post-training. We don’t even talk about plain “training” anymore. Everything is either pre or post, and the thing in the middle that both prefixes point at doesn’t have a name of its own. Or rather, it does now: we started calling it “mid-training”, because we found things to do in the middle, but that was after we had a pre and a post to flank it!
I think I’ve been on this ride before. Maybe I can predict how it ends?
An unlived (by me) history
The terms used to make sense. In the transfer-learning days, people
pre-trained a representation before training it on the task they
actually cared about, or so I hear, I’m a young’un. The “pre” made
sense, it hooked into a training run that came later. Then the
foundation model era arrived, the “pre” stage became the enormous thing
that made the base model, and the industry kept a prefix that was now
without a referent. “Post-training” followed, and now we have a pipeline
that reads pre-training -> ??? ->
post-training, where the unnamed thing in the middle is,
apparently, training, but it doesn’t actually happen.
The reason nobody minded is that the words now had meanings of their own, and everybody already knew what happened where. Pre-training means next-token prediction, on a mostly natural corpus, at enormous scale, to acquire general capabilities, producing the base model. Post-training means comparatively small runs of supervised and preference learning, on curated or synthetic data, to shape behavior, modifying the base model. It made sense.
But things change, and it didn’t make sense anymore. RL at pre-training time breaks the idea that the objective is roughly equivalent to the phase. Massive synthetic reasoning corpora break the idea that natural-data implies pre-training. Continued pre-training breaks the checkpoint boundary. Model-generated curricula make data provenance weird. And that’s why the claim that made me pause did just that. If pre-training is a methodology, RL can’t move into it. If it’s merely a position in time, it can, but then the word tells you almost nothing about what’s happening there. Two people can use these terms correctly today and mean entirely different things, and in my experience, they often do.
An old friend
I’ve spent a good chunk of my life around compilers, and this is why I say I know this discussion. This is exactly what happened to the frontend/backend dichotomy.
It was textbook-clean, and I learned it very early on! The frontend parses and does semantic analysis, producing an intermediate representation, the backend optimizes it and emits machine code. It made sense.
Then compilers got real smart-like and ruined it for all of us. Type inference became cross-cutting. Typed macros did semantic analysis in the middle of expansion. Constant evaluation started running substantial programs while allegedly still in the frontend. Optimizations crept in before the IR existed, lowering became partial and gradual, and JIT compilation makes everything messy. MLIR introduces many different IRs, which is cool, but means that answering where the frontend ends is a silly question now.
And of course, we invented the middle-end2. It’s the target-independent work after the language-specific work and before the machine-specific work, which is to say, we found a bunch of interesting things to do in the middle (now where have I heard that before?). LLVM now uses the term earnestly, even if it’s Monty-Python-level silly, because it’s useful shorthand.
Mid-training is the middle-end of AI. That sentence makes about the same amount of sense no matter if you know none, either, or both of those terms, but I think it’s true anyway.
How it ends
I’d argue that among people who actually build compilers, frontend/backend has mostly fallen out of favor as technical vocabulary3. The words survive, but their meaning changes, and “the Clang frontend” or “the RISC-V backend” tells us which part of the repository we find it in, and it’s relative to the rest of the compiler’s architecture. When precision matters, the compiler people around me name operations instead, and talk about parsing, elaboration, monomorphization, lowering, instruction selection, register allocation.
AI lingo hasn’t made that transition yet. People still say things like “compute should move from post-training into pre-training” as if those were technically meaningful. This works if our conversation partners know the shape of our system and our umbrellas, much like “the Clang frontend” only has meaning to people who know its architecture. But we use the terms in conversations across institutional boundaries where these terms might not map anymore.
To be fair, I don’t think the words persist out of laziness or inertia. There are structural reasons for them. Labs have pre-training and post-training teams with separate compute budgets and scaling narratives organized around the split. The words also feature in org charts and budget lines, and those exist regardless of the terms’ technical merit.
Compilers similarly have frontend and backend teams. The trouble only starts when someone conflates org chart words with technical terms.
And so whether RL should happen in pre- or post-training looks like a question about learning to some and a question about team responsibilities to others.
Fin
I don’t have a replacement taxonomy. I don’t think we need better umbrella terms necessarily. My guess is that the words will fall out of favor in most technical circles, and stay around in narrower contexts, like the compiler terms did.
So after a moment of confusion I realized that Eiso’s opinion isn’t even all that provocative, even if he delivered it as a spicy take. I agree that reward-derived signal can show up wherever it’s useful in the training lifecycle (he said, full of half-knowledge). The main thing that it upsets is terminology.
Footnotes
1. He points at DeepSeek’s R1-Zero work as early evidence, and Poolside’s own research into turning web data into something that “teaches the model to think earlier in its training”. Needless to say, I have not validated these claims, but it’s a fun idea, and I like fun ideas.
2. A contradiction in terms, of course, because ends famously come either in singles, or in twos, if you count the start. The term is at least as old as 1980, when Benjamin Brosgol wrote about the “Middle End” of the PQCC Ada compiler (the scare quotes are his, not mine). Apparently it sounded silly to compiler people 45 years ago, too.
3. Maybe I’m in a bubble here. I mostly see the dichotomy in textbooks and hobbyist material these days, and that’s where it still belongs, because it’s a fine pedagogical distinction. It’s just not where the actual boundaries of things lie.