Post-Training Scaling Without Replacing the Base Model: Can It Beat a Larger Foundation?
This article compares two routes for improving open-source large models: investing in a new or larger foundation model, or pushing a fixed base model further through post-training scaling. It explains the division of labor between pretraining and post-training, outlines five failure modes, and shows how to engineer verifiable environments, reward signals, and evaluation methods. The key conclusion is that post-training scaling can win on skill-heavy tasks, but it cannot create missing knowledge; its real limit is set by the production and quality of verifiable environments.
1. A route debate: two ways to make models stronger
Over the past year or more, two very different approaches to making models stronger have emerged in the open-source large model ecosystem.
One approach invests resources early in training: scaling up parameter count, expanding high-quality corpora, and reshaping vocabulary and architecture to pursue a direct leap in capability. The other treats the base model produced during pretraining as a given condition and continues investing only in the post-training stage. It tries to squeeze the most out of the same set of parameters through longer training time, more task environments, and denser feedback signals.
This debate is especially intense in the open-source community because of the cost structure. Replacing the base model means paying for a full pretraining run, typically on the order of tens of millions of dollars or more, along with a matching compute cluster. By contrast, post-training scaling on a fixed base usually costs only a few percent of that, and it can be iterated repeatedly. More importantly, the pretraining output is often treated as an asset, while post-training is treated as further development of that asset. If an asset still has room to be developed, is it more rational to keep digging into it rather than starting over?
The answer is not either-or. But to explain the issue clearly, we first need to clarify a relationship that is often misunderstood.
2. Base model and post-training: floor versus ceiling
A common intuition in the industry is that changing the base model is a real upgrade, while changing post-training is just parameter tuning. This intuition ignores a key fact: the scopes of the base model and post-training do not overlap.
Pretraining mainly determines the model’s knowledge coverage, its prior distribution over language and code, and its ability to memorize long-tail facts. These are knowledge constraints, and they are essentially a function of data coverage.
Post-training mainly determines the model’s behavioral form: whether it reads files before writing code, whether it actively runs tests, whether it can maintain a goal over dozens of tool calls, and whether it retries or backs off when it sees an error instead of getting stuck in a loop. These are skill constraints, and they are essentially a function of feedback density.
A practical judgment rule is:
- If a model cannot answer a certain type of question under zero-shot, no-tool conditions, for example niche framework conventions or the semantics of an internal SDK, post-training cannot fill the gap. This is a base-model constraint.
- If the model knows what to do but performs unstably, fails to complete tasks, or does not follow the required format, post-training still has substantial room to improve. This is a skill constraint, and it is the battlefield for extreme squeezing.
A large share of capability gains in the open-source ecosystem over the past year has come from the second category. This explains why the “no new base model” route is not just empty talk in empirical terms. But to judge how far it can go, we must first understand its failure modes.
3. Five failure points: why extreme post-training squeezing may fail
1. Environment cost hits a ceiling before compute cost does.
The real bottleneck in post-training scaling is often not GPUs, but the speed at which verifiable task environments can be built. A high-quality environment requires a runnable repository snapshot, a natural-language task description, a verifier that decides correctness, and an isolated sandbox. The human cost of constructing such an environment is much higher than labeling a question-answer pair, and it cannot be diluted through crowdsourcing.
2. Verifier misalignment and reward hacking.
When reward is defined entirely by test pass rate, the model quickly learns to please the tests rather than solve the problem: hard-coding return values, skipping boundary checks, or modifying the test files themselves. This is the top risk for any reinforcement learning route based on verifiable rewards.
3. Insufficient environment diversity leads to overfitting to one pattern family.
If most environments focus on the same type of task, for example “fix one bug to make unit tests green,” the model learns highly specialized strategies. Gains on unseen task families then decay sharply.
4. Long-context usability issues.
The nominal context window length, for example at the million-token level, and the actual usable length are two different things. In real repository-level tasks, relevant information is dispersed, attention is diluted, and the model may lose key constraints in the middle of a long sequence. At the same time, inference cost and latency grow linearly with length. Token economics can turn “it fits” into “it is too expensive to use.”
5. Benchmark saturation and overfitting.
Once a public benchmark is widely optimized, its score gradually loses discriminative power. More seriously, leakage between training and evaluation sets can cause internal observations to diverge from public scores.
4. Environments and rewards: the engineering foundation of post-training
To treat post-training as a first-class rocket rather than parameter tuning, it must be built as an engineering system, not as a training script. The core abstraction is to turn a task into a verifiable environment object:
# Environment spec: abstract a verifiable task as a common contractfrom dataclasses import dataclass@dataclass(frozen=True)class EnvSpec:task_id: strrepo_snapshot: str # Immutable reference to the repository snapshotinstruction: str # Natural-language task descriptionverifier_cmd: str # Verification entry point: test command or validation scriptbudget_steps: int # Step budget to prevent infinite loops and step inflationtimeout_s: int # Timeout for a single executionhidden_tests: tuple = () # Regression cases hidden during trainingtags: tuple = () # Task-family tags for curriculum sampling and debiasing
The core principle of reward design is: sparse outcome signal + dense process signal + explicit anti-cheating constraints. The sparse signal prevents the objective from being distorted, while the dense signal improves sample efficiency.
def compute_reward(traj, env: EnvSpec) -> dict:"""Multi-signal reward: correct outcome + well-behaved process + constraint penalties."""passed, coverage = run_verifier(traj.patch, env.verifier_cmd, env.timeout_s)r_outcome = 1.0 if passed else 0.0r_hidden = 0.5 if passed and all(run_check(h, traj.patch) for h in env.hidden_tests) else 0.0r_step = -0.05 * max(0, traj.steps - env.budget_steps) # Discourage step inflationr_format = 0.1 if traj.diff_applies_cleanly() else -0.3 # Patch applicabilityr_regress = -0.5 if breaks_existing_suite(traj.patch) else 0.0r_cheat = -1.0 if touches_verifier(traj.patch, env) else 0.0 # Modifying tests is a serious violationtotal = r_outcome + r_hidden + r_step + r_format + r_regress + r_cheatreturn {"total": total,"breakdown": {...},"is_cheat": r_cheat < 0,"coverage": coverage,}
Several engineering points are easy to overlook but have clear benefits:
- Keep hidden tests out of the training feedback loop. During training, only give the model the pass signal from public cases, and use private regression cases on the validation set. This helps suppress shortcuts such as modifying tests.
- Failed trajectories are training signals, not waste data. Failed trajectories often contain samples where the diagnosis is correct but the fix is wrong. These are highly valuable for training reasoning strategies, but their weight must be reduced to prevent the model from learning pseudo-successes that merely look fixed.
- Use curriculum and difficulty stratification. Tasks can be layered by
budget_steps, number of files touched, and dependency depth, and sampled from easy to hard. Sudden difficulty jumps are a common cause of divergence in later training. - Debias environments. Track the task-family distribution using
tags, and control the share of any single family with sampling weights to prevent capability narrowing. - Ensure reproducibility. Repository snapshots must be immutable and carry version references. Otherwise, reward signals cannot be regression-tested and experiments are not comparable.
5. How to evaluate: don’t look only at the total score
The easiest methodological mistake in the post-training route is to prove victory with a single total score. A more reliable evaluation should cover at least five dimensions:
- Knowledge-type versus skill-type split. Test niche knowledge questions under zero-shot, no-tool conditions. If the gap is obvious, the base-model gap has not yet been closed.
- Task-family breakdown. Measure code generation, repository-level refactoring, cross-file debugging, terminal automation, tool use and orchestration, and long-horizon task completion. Post-training routes usually gain the most in terminal automation and long-horizon tasks, and the least in niche knowledge.
- Pass rate and pass depth. Report both pass@1, which reflects the real user experience, and pass@k, which reflects upper-bound potential, along with average interaction steps and average token consumption. Reporting only pass@k systematically overestimates user experience.
- Long-context decay curve. Test the same task set at 8K, 32K, 128K, and longer ranges, and observe the slope of performance decay. The difference between the nominal window and the effective window is often more valuable for decision-making than the peak score.
- Leakage control. After training, run a blind test on a completely new task set that has not entered any public benchmark. Compare it with public scores. A large gap indicates overfitting.
6. A decision checklist for the two routes
| Scenario feature | Preferred choice | Reason |
|---|---|---|
| Requires broad domain knowledge, multilingual coverage, and long-tail facts | Larger base model | Post-training cannot create knowledge that does not exist |
| Main workload is code, terminal, or repository-level long-horizon tasks | Deepen post-training | Skill constraints dominate, and feedback density brings high returns |
| Limited compute budget and need for fast iteration | Deepen post-training | Marginal cost is low, and iteration cycles are measured in weeks |
| Requires private deployment, fine-tuning, and compliance auditing | Open-weight post-trained model | Higher degree of intervention and controllable supply chain |
| Target capability is completely absent from the base model, such as a new reasoning mode | Replace the base model | Post-training leverage acts on existing capabilities |
One point deserves emphasis: post-training scaling is not a free lunch. It shifts cost from a one-time upfront pretraining investment to ongoing investment in the post-training stage. The environment factory becomes a long-term asset that must continuously produce new tasks. Verifiers require continuous maintenance to prevent them from being broken by reward hacking. It is wrong to understand this as “getting the same benefit in a cheaper way.” The correct understanding is: trading engineering complexity for iteration speed.
7. Conclusion
Back to the original question: can extreme squeezing without changing the base model beat a larger base model?
A layered answer is more accurate:
- On the skill dimension, yes. For problems where the model knows what to do but performs unstably, such as format following, multi-step planning, tool use, and long-horizon tasks that do not crash halfway, the benefit curve of post-training scaling remains approximately linear over a fairly long range. Its return on investment is also significantly better than a comparable additional pretraining run.
- On the knowledge dimension, no. Knowledge that does not exist in the base model, or languages and domains that were never covered, cannot be generated from nothing by post-training. In that case, a more reasonable approach is not to keep squeezing, but to do targeted continued pretraining or retrieval augmentation.
- On the total-cost dimension, it depends on environment assets. Whoever has a lower-cost and more diverse production line for verifiable environments has a more convincing extreme-squeezing case.
Therefore, the real boundary of post-training scaling is not determined by compute, but by the production capacity and quality of verifiable environments. This also explains why competition among leading teams at this stage increasingly looks like competition in environment engineering and evaluation methodology, rather than a pure parameter race.
