Post-Training at the Limit vs. a New Very-Large Base Model: A Technical Framework for Coding and Agents
This article compares two broad routes for advancing large language model capabilities: keeping the base model stable and scaling post-training—reinforcement learning, environment engineering, and long-horizon task training—versus rebuilding a much larger base model and trading capacity and knowledge density for a higher ceiling. It abstracts both options into general technical approaches, examines their principles, benefits, and risks, and outlines evaluation metrics for coding and agent tasks. It also provides a practical route-selection process and an illustrative training and evaluation pipeline. The central conclusion is that the choice should be driven by task distribution, environment quality, reward design, inference cost, and evaluation credibility rather than by a single leaderboard score.
In recent discussions of large model technology, a representative disagreement has emerged: when the base model still has untapped potential, should teams continue to push post-training to its limit—scaling reinforcement learning, environment engineering, and long-horizon task capabilities—or should they start over and build a new base model with a larger parameter count, trading capacity and knowledge density for a jump in capability? The first view emphasizes that the intelligence ceiling can be raised without changing the base model. The second emphasizes that a new base model determines a new ceiling. These are not merely disagreements over training techniques; they affect coding, agents, context utilization, evaluation credibility, engineering cost, and a range of deployment issues.
This article does not evaluate or recommend any specific product. Instead, it abstracts the two routes into general technical approaches, breaks down their principles, advantages, risks, and selection methods, and aims to help developers and enterprises build a more reliable judgment framework.
1. Route A: Keep the Base Model and Scale Post-Training to Push the Ceiling
“Keeping the base model” does not mean the base model is absent from training. It means the core pretrained weights and model architecture remain stable, while most compute and engineering investment goes into post-training. Post-training commonly includes supervised fine-tuning, preference optimization, reinforcement learning, rejection sampling, tool-calling training, and long-horizon task trajectory training. A common practice described in public materials is to expand the number of long-horizon task environments, increase coverage of environment types, and extend post-training time so that the model repeatedly trials and errors in real engineering task chains.
The core logic of this route is that pretraining determines the model’s lower bound and knowledge foundation, while post-training determines how high the model can reach on a particular task distribution. For coding and agent tasks, the model needs not only to “write code,” but also to read repositories, modify multiple files, execute commands, observe feedback, fix errors, and maintain state across multi-turn tool calls. These abilities are difficult to acquire naturally from pretraining corpora alone; the quality of post-training environments is often more critical than parameter scale.
Specifically, scaling post-training has three key levers.
First, long-horizon task environments. Short tasks can train single-step correctness, while long tasks are needed to train planning, state management, and failure recovery. For example, having a model complete a full chain in a simulated code repository—“locate the defect—modify multiple files—run tests—roll back based on errors—fix again”—is closer to real development than simply generating a function.
Second, environment diversity. Terminal environments, code repositories, cross-tool collaboration, filesystem operations, log analysis, and configuration changes impose different requirements on the model. The richer the environments, the less likely the model is to overfit to a single interaction pattern.
Third, training time and sampling scale. Reinforcement learning requires large amounts of trajectory sampling and reward feedback, and long-horizon tasks are especially compute-intensive. Simply increasing post-training time may bring significant gains while the base model still has potential, but it also amplifies flaws in reward design.
The main risks of this route are also clear: reward hacking, catastrophic forgetting, environment distribution drift, difficulty of long-horizon credit assignment, and rapidly rising post-training compute costs. If the reward function only rewards “tests pass,” the model may learn to bypass tests rather than truly fix problems. If the environment is too narrow, the model may fail in real repositories. Therefore, scaling post-training is not simply “stacking time”; it is systems engineering across environment engineering, reward modeling, and curriculum design.
2. Route B: Rebuild a Very-Large Base Model to Trade Capacity for a Higher Ceiling
The other route is to rebuild a new base model and push the parameter scale to the trillion level or higher. Its advantage lies in greater capacity, which can hold broader knowledge, more complex patterns, and multilingual and multitask representations. On long context, cross-domain reasoning, and few-shot generalization, a very-large base model usually has stronger potential. For coding and agent tasks, a large base model can provide better code semantic understanding, cross-file dependency modeling, and understanding of tool instructions.
However, a very-large parameter base model is not a case of “the larger the parameters, the better.” First, training cost, data quality, training stability, and inference cost all rise significantly. Second, parameter capacity does not automatically translate into long-horizon task ability; agents still require post-training and tool-use training. Third, very large models have higher deployment barriers, and latency, memory, and concurrency costs directly affect enterprise deployment. Finally, a base model update means that existing post-training assets, evaluation systems, and deployment pipelines must all be adapted again, and migration cost cannot be ignored.
Therefore, the real value of the new-base-model route is to “expand the capability boundary,” not to replace post-training. A larger-capacity base model without high-quality long-horizon environments and tool-calling training may not necessarily be superior in terminal agent tasks. Conversely, a model with an unchanged base model but post-training environments sufficiently close to the task distribution may achieve better cost-effectiveness in specific scenarios.
3. Coding and Agent Capabilities: What Metrics Matter
When discussing the two routes, the most common pitfall is looking at only a single measure. Internal impressions, public leaderboards, open-source rankings, and single-turn code-generation scores cannot directly represent real engineering capability. A more reasonable evaluation should cover the following dimensions.
Repository-level coding ability. This is not just generating a function, but whether the model can understand multi-file dependencies, modify interfaces, maintain style consistency, add tests, and handle regressions. Evaluation should use real repository snapshots, hide test cases, and record multi-turn repair success rates.
Terminal and command-line agent ability. A large amount of real development happens in terminal environments: executing commands, reading output, analyzing errors, modifying files, and verifying again. Evaluation should focus on task completion rate, average interaction turns, failure recovery rate, and dangerous operation rate.
Long-horizon task stability. In long tasks, models can easily lose goals, repeat ineffective operations, or declare completion too early. Context compression, state recording, plan updating, and rollback capabilities should be evaluated.
Effective utilization of the context window. A million-token context is a common selling point, but “fitting it in” does not mean “using it well.” It is necessary to test long-document retrieval, cross-file references, retention of key information, and stability under noise interference.
Cost and maintainability. This includes inference latency, token consumption per task, number of tool calls, post-training fine-tuning cost, and version migration cost. A solution with a slightly higher leaderboard score but double the cost may not be suitable for production.
Evaluation credibility. Public evaluations should consider data contamination, whether the evaluation environment is closed, whether tool calls are allowed, whether multi-turn interaction is supported, and whether the evaluation is publicly reproducible. Internal impression-based metrics can serve as directional references, but they cannot replace reproducible task sets.
4. Engineering Deployment: How to Choose a Route
When selecting a route, enterprises should not directly ask “which route is stronger,” but should first ask “what is the task distribution.” If the core scenarios are terminal operations, code repository maintenance, multi-tool collaboration, and long-horizon automation, then the match between post-training environments and the task distribution may be more important than parameter scale. If the scenarios require broad knowledge coverage, cross-domain reasoning, understanding of new languages and frameworks, and long-context synthesis, then the capacity advantage of a very-large base model deserves more attention.
An actionable evaluation process is as follows:
- Build an internal task set of 50–200 real tasks covering single-file, multi-file, terminal execution, tool calls, failure recovery, and long context.
- Fix tool permissions and the runtime environment, and record completion rate, interaction turns, token cost, latency, and dangerous operation rate.
- Compare candidate solutions in the same environment, and do not use vendor self-reported impression scores as the sole basis.
- For the post-training route, focus on verifying environment coverage and reward design; for the new-base-model route, focus on verifying inference cost and migration cost.
- Keep a small-scale gray release, observe failure modes in real user tasks, and then decide whether to expand investment.
5. Illustrative Training and Evaluation Pipeline
The pseudocode below illustrates the basic structure of scaled post-training and evaluation, independent of any specific product interface:
for stage in curriculum_stages:env_pool = build_environments(repo_tasks=stage.repo_tasks,terminal_tasks=stage.terminal_tasks,tool_tasks=stage.tool_tasks)for batch in sample_trajectories(env_pool, policy):trajectory = rollout(policy, batch, max_steps=stage.max_steps)reward = evaluate(trajectory, hidden_tests, safety_rules)policy = update(policy, trajectory, reward)eval_suite = load_internal_tasks(repo_level=True,terminal_agent=True,long_context=True,tool_collaboration=True)report = run_eval(policy, eval_suite, metrics=["task_success_rate","avg_turns","token_cost","latency","unsafe_action_rate"])
The key points are: the environment pool should cover real task chains; the reward function should constrain correctness, safety, and cost at the same time; and the evaluation set should hide tests and retain failure trajectories for analysis. Otherwise, scaled post-training can easily become “score farming in the training environment.”
6. Conclusion: It Is Not About Which Route Wins, but Whether It Fits
“Keep the base model and push post-training to the limit” and “rebuild a very-large parameter base model” are not two mutually exclusive routes. The former shows that when the base model’s potential is not exhausted, scaled post-training can serve as a first-stage rocket to raise coding and agent capabilities. The latter provides a larger capacity boundary and preserves room for knowledge breadth and complex representation ability. What really determines success is task distribution, environment quality, reward design, inference cost, and evaluation credibility.
For developers, the most pragmatic approach is to build their own task set and cost model, and replace marketing claims with reproducible results. For enterprises, priority should be given to solutions that match the business task chain, are maintainable, support gray release, and have controllable cost. Parameter scale and post-training investment are only means; whether the model can reliably complete real tasks is the final criterion.
