Can Extreme Post-Training on an Unchanged Base Model Beat a Trillion-Scale New Base?
This article compares two model-development routes: aggressively improving post-training without changing the base model, versus adopting a larger new base model. It explains how post-training scaling works through long-horizon environments, environment diversity, and longer training runs, then covers the practical engineering details needed to build this kind of system, including sandboxes, reward design, synthetic data, training loops, observability, and evaluation. The key takeaway is that neither route wins universally; the better choice depends on the target scenario, reliability requirements, deployment cost, and measurable productivity on real tasks.
1. Two Technical Routes, One Goal
When two models released within the same time window are placed side by side, one of the most interesting differences is whether the base model was changed.
- Route A: Keep the base model unchanged and push post-training further. The new version uses the same base model as the previous version. All incremental gains come from post-training stages such as reinforcement learning. The goal is to raise the model’s effective capability ceiling.
- Route B: Replace the base model and jump in parameter scale. The parameter count increases from hundreds of billions to the trillion scale. The base model is typically trained with next-token prediction on datasets containing trillions of tokens, followed by post-training on coding and agentic tasks.
The two routes also share several obvious similarities: both treat coding and AI Agent capabilities as core battlegrounds, both release open-weight models, and both extend context windows to the million-token scale. These shared constraints make the comparison meaningful.
Before going further, it helps to clarify one concept. Model capability can be roughly divided into two layers:
The base model determines the stock of knowledge and capabilities, while post-training determines how much of that stock can actually be invoked.
An analogy from software engineering is useful. The base model is like the foundation and load-bearing structure, while post-training is like the upper-layer application that is continuously iterated. With the same foundation, an application can be polished to a fairly high level of completeness, but the foundation still defines the ultimate ceiling.
Therefore, the question of “which one is stronger” cannot be answered without considering several prerequisites: whether the base model still has untapped potential, whether post-training investment still produces meaningful returns, and whether the target scenario matches the strengths of each route.
The following sections focus mainly on Route A, because it involves many engineering details that are easy to misunderstand.
2. What Route A Actually Does: Three Levers of Post-Training Scaling
Post-training usually starts with supervised fine-tuning. This quickly improves instruction following, format compliance, and basic coding ability. After that, however, gains often flatten out.
Continuing to invest more resources without changing the approach often yields little improvement. The reason is that the data is mostly static question-answer pairs. The model learns what a “standard answer” looks like, but does not learn how to complete a task through long, iterative trial and error.
Post-training scaling is designed to address this weakness. It turns post-training from occasional patching into a systematic engineering effort that can be expanded continuously. According to publicly disclosed information, this upgrade mainly pulls three levers.
2.1 Lever 1: Long-Horizon Task Environments
In the past, one training sample often corresponded to a single prompt-response pair. Long-horizon task environments require the model to complete one task across dozens or even hundreds of interaction steps. Examples include:
- Reading logs, changing configurations, and rerunning tests;
- Locating defects in a large code repository and submitting a patch;
- Calling multiple tools together to process a data workflow.
These samples naturally bring sparse rewards and credit-assignment problems. A final test may pass, but it is difficult to tell which step was correct. It is also hard to distinguish between “succeeding after thirty attempts” and “finishing in three steps.”
To mitigate this, several techniques are needed: process feedback, such as error messages and outputs from each command; group comparison, where multiple samples of the same task are compared relatively; and trajectory replay.
The publicly mentioned “long-horizon task environments that are dozens of times longer” and “coverage of terminal, repository, and cross-tool collaboration environments” correspond to these changes.
2.2 Lever 2: More Diverse Environment Types
The more diverse the tasks, the less likely the model is to exploit shortcuts. Long-horizon tasks can also amplify another problem: small deviations between reasoning and execution can accumulate along the tool-calling chain. The model may form habits that look reasonable but actually drift in the wrong direction.
Multiple environment types act like a regularization term in training. They force the model to learn general methods, such as reading before modifying, validating in small steps, and rolling back after failure, instead of memorizing fixed answers from one type of repository.
2.3 Lever 3: Longer Training Duration
This point is the simplest and also the most easily misunderstood. Previously, post-training emphasized sample efficiency: one dataset might be fine-tuned repeatedly for a few rounds.
Long-horizon tasks are much more expensive to sample. One trajectory may contain hundreds of tool calls and must actually execute in a sandbox. Sampling is therefore more expensive, slower, and more likely to fail. To obtain enough effective gradient signals, training duration and compute must be increased significantly.
This also explains why post-training can scale in a way similar to pre-training: it consumes compute that can be parallelized and verified, rather than relying on scarce, high-quality human annotation.
2.4 What the Training Signal Tells Us About the Boundary of Intelligence
In one sentence:
Post-training learns strategies; pre-training learns knowledge and capabilities.
Reinforcement learning can combine, optimize, and amplify capabilities that already exist, but it is difficult for it to create knowledge or capabilities from nothing if the base model does not already have them.
There is also a theoretical basis for this. When the exploration required by reinforcement learning is already covered by pre-training, additional investment tends to produce diminishing returns.
For a new version whose base model remains unchanged, the most important question is whether the growth comes mainly from activating latent capabilities that were already present but unused, or mainly from more sophisticated task design and reward design. Both can make the model stronger, but the first implies that there is still remaining headroom, while the second implies that gains may plateau sooner.
3. Practical Engineering: Building a Post-Training Agent System
If you plan to attempt something similar on your own model, several engineering details often determine success or failure.
3.1 Sandboxes: Isolation, Reproducibility, and Scalability
Agents need to execute commands, read and write files, and access the network. The training environment must be an isolated sandbox that can be created and destroyed on demand. At minimum, it should provide three things:
- Resource isolation: Each task runs in an independent instance with CPU, memory, and runtime limits. This prevents runaway processes from taking down the whole training cluster.
- Controlled state: Each run starts from a clean snapshot. When necessary, the state of key steps can be captured for replay.
- High parallelism: Training throughput depends on how many tasks can run at the same time, not just how many GPUs are available.
In cloud environments, container platforms can be used to elastically schedule environment pools, while object storage can be used to store trajectories, checkpoints, and replay data.
3.2 Rewards: Prioritize Verifiability, With Process Signals as a Supplement
def score_trajectory(traj, max_steps: int) -> float:# Outcome reward: use automatically verifiable tests (illustrative implementation)tests = run_tests(traj.workspace)result = sum(1 for t in tests if t.passed) / len(tests)# Process reward: penalize redundant steps and resource consumptionefficiency = max(0.0, 1.0 - traj.steps / max_steps)return 0.8 * result + 0.2 * efficiency
- Unit tests and static checks are the most reliable reward sources: objective, automatable, and difficult for the model to “argue with.”
- Safety and compliance checks, such as dependency scans and code-style tools, can serve as auxiliary rewards. However, their weights should not be too high, otherwise the model may learn to please the checker instead of solving the real problem.
- Pure preference scoring, such as “is the code elegant?”, is suitable for cold starts and style alignment. At scale, it can be exploited more easily and should be used cautiously.
3.3 Data: Task Synthesis, Difficulty Stratification, and Contamination Isolation
Real tasks are scarce and expensive to annotate, so programmatic synthesis is often necessary. Starting from a runnable repository, you can automatically generate defect injections, remove or modify tests, or introduce dependency conflicts. This produces paired “initial state + acceptance criteria” data. Two additional steps are important:
- Sample by difficulty level so that rewards contain both positive and negative examples within a group. This prevents training signals from degrading.
- Strictly separate training and evaluation sets to prevent training tasks or trajectories from leaking into benchmark scores.
3.4 Training Loop: Policy Optimization Driven by Group Comparison
# Pseudo-code: a rollout optimization loop with group-relative advantage on top of a remote policy modeldef rollout_batch(policy, tasks, group_size: int):records = []for task in tasks:env = create_sandbox(task) # One isolated sandbox per tasktraj = []try:for step in range(task.max_steps):action = policy.sample_action(traj, env.observation())obs, done, info = env.execute(action)traj.append((obs, action, info))if done:breakfinally:env.destroy() # Always clean up the environment, whether successful or notrecords.append({"task": task,"traj": traj,"reward": score_trajectory(traj, task.max_steps),"tokens": count_tokens(traj),})return recordsdef train_step(policy, tasks, group_size=8, max_tokens=8192):records = rollout_batch(policy, tasks, group_size)# Group by task and compute relative advantage within each groupgroups = group_by_task(records)for group in groups:rewards = [r["reward"] for r in group]mean, std = statistics(rewards)for r in group:# If all samples in the group have the same reward, the advantage is 0.# That group contributes no gradient, so task sampling must provide enough difficulty diversity.r["advantage"] = (r["reward"] - mean) / (std + 1e-6)# Policy update: filter out abnormally long trajectories and weight by token count# to stabilize long-horizon training.update_policy(policy, records, max_tokens=max_tokens)
This pseudo-code contains several practical details:
- Using
try/finallyensures that sandboxes are always reclaimed, preventing zombie processes from accumulating during long training runs. - Grouping by task and computing group-relative advantage removes the need for a separate value model. This saves both memory and engineering effort.
- If all samples in a group have the same score, the advantage is zero and that group contributes no gradient. This highlights the importance of difficulty-stratified sampling.
- Filtering out overly long trajectories prevents a few “runaway” samples from dominating the gradient for the whole batch.
3.5 Observability and Evaluation Feedback
During training, the following metrics should be recorded continuously:
- Task pass rate;
- Average number of steps;
- Token consumption;
- Reward distribution, especially whether within-group variance stays in a reasonable range;
- Sandbox failure rate, which helps distinguish “the model cannot do the task” from “the environment is unstable.”
When these metrics saturate and improvements across task types flatten, it usually means it is time to stop increasing investment and shift toward consolidation and tuning.
The inference side also deserves attention. For example, workflows that require the model to first give a conclusion or plan, then execute and verify, can help constrain behavior. Long-horizon tasks also need enough context budget, and the inference service layer should include logging, monitoring, alerting, rate limiting, and authentication.
4. Where the Gains Come From and Where They Hit a Ceiling
Sources of gains. Post-training can keep producing improvements as long as the base model still has capabilities that it “knows but does not use well.” In that case, the main gains are reliability and autonomy, not new knowledge. As task chains become longer, overall completion probability is the product of the success probabilities at each step. If single-step reliability improves from 90% to 95%, the overall completion rate in a ten-step task rises from about 35% to about 60%. This is the mathematical reason why long-horizon task training can produce obvious benefits.
# Chain calculation: how step-level reliability affects overall completion rate (illustrative)def completion_rate(step_success: float, steps: int) -> float:return step_success ** stepsfor p in (0.90, 0.95, 0.98):print(f"Step success rate {p:.0%}, 10-step completion rate {completion_rate(p, 10):.1%}")# Output: 90% -> 34.9%, 95% -> 59.9%, 98% -> 81.7%
Signals of hitting a ceiling. Continuing to dig deeper yields diminishing marginal returns quickly when the following happens:
- A new version only updates the base through fine-tuning and keeps the base architecture unchanged. This suggests the base still has untapped potential and further post-training still has room. If the base itself is rebuilt, it often means the old base is approaching a bottleneck.
- Post-training gains come mainly from more complex task synthesis and reward design rather than structural changes in capability. This is closer to “reward approximation” than to a “capability leap.”
- After replacing the base model, achieving the same improvement requires several times more post-training investment.
Whether one route can “win” ultimately depends on whether the base model’s remaining potential is exhausted more slowly than competitors’ new base models iterate. It is not determined by a single benchmark score.
5. How to Evaluate Credibly: Do Not Rely Only on Leaderboards
When faced with marketing claims from two different routes, developers need a reproducible evaluation method.
5.1 Reference Value of Three Types of Data
| Data Type | Advantages | Limitations | Recommendation |
|---|---|---|---|
| Vendor internal hands-on evaluations | Close to subjective user experience | Small samples, opaque standards, prone to selective presentation | Use only as qualitative clues |
| Public benchmark leaderboards | Easy for horizontal comparison and reproduction | Possible training-set overlap and targeted optimization | Look at relative positions under the same environment and tool configuration |
| Proprietary task-set evaluation | Closest to real business needs | Requires investment in building and maintenance | Use as the main basis for selection |
The original post mentions two public benchmarks located in terminal or command-line environments, corresponding to terminal tasks and command-line agent exams. These environments overlap heavily with software-development workflows, but exposure to similar tasks during training does not guarantee direct transfer to your own system.
5.2 A Minimum Viable Evaluation Workflow
# Illustrative example: automated evaluation over a real task set, with item-by-item scoringEVAL_CASES = [# task_id, initial repository snapshot, list of acceptance commands, internet allowed, timeout in seconds("bugfix_login_timeout", "repo://samples/login-service@v3", ["make test"], False, 1800),("refactor_api_client", "repo://samples/client-sdk@v7", ["make lint", "make test"], False, 1800),("migrate_ci_pipeline", "repo://samples/ci-config@v2", ["make ci-check"], True, 2400),]def run_eval(model, cases, retries: int = 3):rows = []for task_id, repo, checks, online, timeout in cases:ok, steps, tokens, seconds = run_agent_case(model, repo, checks, online, timeout)rows.append({"task": task_id,"success": ok,"steps": steps,"tokens": tokens,"latency_s": seconds,"cost": estimate_cost(tokens, seconds),})return summarize(rows) # Outputs task pass rate, average steps, tokens, and cost
- Extract tasks from real tickets and defect records. Run each model at least three times and take the average to reduce randomness.
- In addition to pass rate, record steps, tokens, latency, failure types such as timeouts, loops, or unintended file changes, and manual review time.
- Run the same evaluation script fairly across both routes. Avoid mistakes such as comparing the latest version against an older version.
6. Recommendations for Developers
- Define the scenario first, then discuss strength. If the main focus is terminal or command-line agents, and tasks are concentrated on code fixes, configuration changes, and log troubleshooting, the post-training route often delivers the most direct benefits. For long-chain, open-ended research tasks, base-model scale and knowledge coverage may matter more.
- Pay attention to context and stability. A million-token window is only an upper limit. What really affects experience is retrieval accuracy, forgetting rate, and inference latency under long contexts.
- Consider deployment cost. Larger models generally require more inference memory, have higher latency, and cost more per token. These factors must be weighed against expected concurrency and budget.
- Build a continuous evaluation mechanism. Use your own task set as a regression baseline and retest immediately after each new release, rather than doing a one-time comparison and locking in a choice long-term.
7. Conclusion
“Extreme post-training without changing the base model” and “a trillion-scale new base model” are essentially two different ways of allocating resources. The first believes the existing base still has untapped potential and is willing to use post-training compute to realize it. The second believes a deeper base provides structural advantages and is willing to make a large investment for it.
From an engineering perspective, post-training scaling provides a reusable, verifiable, and measurable path to capability growth. It is especially valuable for teams with limited budgets or for teams that need to iterate quickly on an existing base model. However, it has clear boundaries: when the base model’s potential is exhausted, when task environments become homogeneous, and when reward designs are gradually figured out by the model, returns will decline quickly.
Therefore, the real deciding factor in this contest is not a single leaderboard ranking. It is which route produces more value per unit cost and iterates faster in the target scenario. For developers, the most reliable approach is not to bet on one side, but to build your own task-set evaluation and cost model, and let data rather than slogans make the decision.
