Post-Training vs. New Base Model Retraining: Which Wins for Coding and AI Agent Capabilities?

    This article compares two strategies for advancing open-source LLMs with strong coding and AI agent capabilities: squeezing post-training to the limit without changing the base model, versus retraining from a new, trillion-parameter base model. It clarifies three key terms (base model, post-training, and intelligence ceiling), breaks down each route's levers, risks, and trade-offs, and explains where each unit of compute yields a higher return. It also provides an engineering checklist for deep post-training—environment pools, reward shaping, training loops, curriculum learning, anti-forgetting monitoring, and evaluation—plus a cloud-infrastructure checklist and a practical conclusion for model-selection decisions.

    Over the past two years, open-source large language models have evolved along two distinctly different paths. Two models released less than a month apart both targeted code and agent capabilities and both chose to open their weights, yet their technical routes diverged sharply.

    Route one left the base model completely unchanged from the previous generation and poured all incremental investment into post-training. The official approach rested on three levers: expanding long-horizon task environments by tens of times, diversifying environment types, and significantly extending post-training duration.

    Route two rebuilt a base model with trillions of parameters from the ground up, then trained specifically around coding and agent capabilities.

    One side squeezes post-training to the limit without changing the base; the other starts over and reprices the capability ceiling with a new base model. Setting aside the marketing narrative, this is really a collision of two resource-allocation philosophies. For teams that need to make model-selection decisions, reproduce experiments, or build their own training pipelines, arguing about which is stronger is largely pointless. The more useful questions are: where does each unit of compute yield a higher return, and where are the risk boundaries of each approach.

    1. Aligning the terminology: three concepts first

    1. Base model: a general-purpose model obtained through large-scale self-supervised pre-training. It determines the innate ceiling of knowledge coverage and reasoning potential.
    2. Post-training: the stage, built on top of the base model, that uses supervised fine-tuning, preference alignment, reinforcement learning, and other methods to turn “being able to talk” into “being able to do.” The primary source of current agent capabilities is reinforcement learning with verifiable rewards: code that runs, tests that pass, and format checks that succeed—results that are objective and automatically judgeable, and therefore naturally suited as reward signals.
    3. Intelligence ceiling: the capability limit that post-training can approach but struggles to break through from nothing. The base model determines where the ceiling is; post-training determines how close you can get to it. This is the key to understanding the two routes.

    2. Route one: deep post-training without changing the base

    Deep post-training yields high returns for one root reason: the base model’s capabilities are underutilized. During pre-training, the model has seen massive amounts of code and text, but it hasn’t necessarily learned stable tool calling, multi-step planning, and error recovery. Post-training is precisely what converts this “potential” into reliable behavior. Each of the three levers addresses a different problem.

    1. Expanding long-horizon task environments: solving sample starvation

    What agent reinforcement learning lacks most is not the number of problems but complete tasks that are “interactive, verifiable, and provide feedback.” A real engineering task may involve reading code, locating the problem, editing files, running tests, and rolling back and retrying—over a dozen steps, each requiring environment support.

    Expanding environments by tens of times brings several direct benefits:

    • A wider task distribution, covering code repositories of different sizes, languages, and architectures;
    • More diverse trajectories sampled by the same model, yielding more stable gradient estimates;
    • Reduced overfitting to a few high-frequency tasks.

    But expansion is not the same as piling up volume. A qualified environment needs at least three things: a deterministic initial state, verification logic that runs automatically, and replayable interaction logs. For tasks that can’t meet these three points, reward noise will swallow the gains from expansion.

    2. Diversifying environment types: solving transfer fragility

    Training in only one type of environment easily leads the model to learn that environment’s “dialect”—specific directory structures, command conventions, or error-message formats. Once the environment style changes, performance drops noticeably.

    Mixing scenarios such as terminal operations, code repositories, cross-tool collaboration, and document processing is essentially multi-domain curriculum learning. It forces the model to build capabilities on “task semantics” rather than “interface details,” which matters more for generalization to real business. Building and maintaining such diverse environments is costly and requires standardized environment encapsulation and a unified verification interface.

    3. Extending post-training duration: solving under-convergence

    At the same data scale, more training steps mean the policy explores the state space more thoroughly—especially in multi-step tasks, where composite behaviors like “retrieve first, then modify, then verify” only emerge later.

    But longer duration doesn’t automatically mean better results. At least three preconditions must be met simultaneously:

    • Reasonable learning-rate decay and regularization scheduling to avoid repeated oscillation over noise in the later stages;
    • The reward signal not being exploited through loopholes by the policy;
    • Reliable checkpoint evaluation that can distinguish real improvement from overfitting.

    Otherwise, the extra training time only amplifies existing bias.

    4. How much can grow without changing the base: ceiling and cost

    This route’s ceiling is determined by the base model’s knowledge boundary and reasoning potential. Domain knowledge the base has never encountered and entirely new reasoning patterns are hard for post-training to conjure from nothing.

    It also has several typical risks:

    • Overfitting: treating the training environment as the evaluation set produces inflated scores. Evaluation environments must therefore be strictly isolated from training environments, with contamination detection.
    • Catastrophic forgetting: when long-horizon reinforcement learning pushes the policy toward high-reward regions, general dialogue, instruction following, and safety alignment can degrade. General data needs to be mixed in proportionally, with continuous regression evaluation.
    • Entropy collapse: the most subtle problem in long-horizon reinforcement learning. The policy becomes increasingly “certain,” and once it encounters new tools, new languages, or new frameworks outside the training distribution, performance drops sharply.

    More realistically: once the base model stops upgrading, the capability gap of the next generation will eventually show. Deep post-training is more like “fully utilizing existing capacity” than “expanding the factory.”

    3. Route two: rebuilding the base, repricing the capability ceiling

    The gains of a new base model are equally direct:

    • Greater capacity, higher knowledge density, and better innate coverage of long-tail domains;
    • A new architecture can rebalance long context, sparse computation, and attention design without being constrained by the old structure;
    • Post-training starts from a higher, “cleaner” baseline, with a larger potential space.

    The costs are equally clear: pre-training cost rises sharply with parameter count, one training cycle is measured in months, and once the architecture is set it’s hard to turn back. Early versions of a base-model generation often underperform a mature old base on tool calling and long-horizon execution.

    Therefore, a new base model is better suited as a long-term play: trading one generation of time for the next generation’s post-training ceiling. For teams under heavy short-term delivery pressure, betting hastily on a new base model usually carries more risk than reward.

    4. Comparing the two routes

    Dimension Deep post-training New base retraining
    Where incremental investment goes Post-training stage Pre-training stage
    Cost per iteration Relatively controllable Very high, measured in months
    Time to results Fast Slow
    Capability ceiling Constrained by the existing base Higher, can be redesigned
    Main risks Overfitting, forgetting, entropy collapse Training instability, uneven early capabilities
    Suitable scenarios Tight delivery timeline, need to quickly improve coding and agent performance Long-term compute planning, need to position next-generation capabilities

    The two routes are not either/or. A common real-world approach is to deepen post-training as the main line to stay competitive, while using part of the compute to explore a new base model and leave an interface for the next iteration.

    5. Engineering checklist for deep post-training

    If you choose to squeeze post-training first, the following elements determine the return on investment.

    1. Environment pool: treat environments as products

    Every task needs three things: a reproducible initial state, an automated verification script, and replayable logs. Environment encapsulation should use a unified interface for easy parallel sampling and result aggregation.

    1. # Illustrative: a framework-agnostic unified environment interface and task description
    2. class TaskSpec:
    3. repo_url: str # code repository URL
    4. base_commit: str # fixed initial commit to ensure a consistent initial state
    5. setup_script: str # dependency installation and initialization
    6. issue_desc: str # task description
    7. test_command: str # automated verification command
    8. timeout_steps: int # maximum number of interaction steps
    9. def reset(spec: TaskSpec) -> State:
    10. """Prepare a clean initial state at the fixed commit"""
    11. def step(state: State, action: Action) -> tuple[State, bool, dict]:
    12. """Execute one tool call or file operation; return the new state, whether it's done, and process info"""
    13. def evaluate(spec: TaskSpec, state: State) -> float:
    14. """Run the verification script and return a task reward between 0 and 1"""

    2. Reward design: from sparse outcomes to layered shaping

    The final reward for long-horizon tasks is very sparse: across dozens of steps, only the last step yields a signal. Process rewards can be added to alleviate this, but you must prevent the policy from gaming them.

    1. def shaped_reward(spec: TaskSpec, state: State, info: dict) -> float:
    2. outcome = evaluate(spec, state) # core signal: whether verification passes
    3. # auxiliary signals: small weights only on metrics that are hard to game
    4. coverage = info.get("test_coverage_delta", 0.0)
    5. repeat_penalty = 0.01 * info.get("repeated_actions", 0)
    6. length_penalty = 0.01 * max(0, info.get("steps", 0) - spec.timeout_steps)
    7. return outcome + 0.1 * coverage - repeat_penalty - length_penalty

    Two principles: auxiliary-term weights always stay below the outcome term; and any metric the policy can easily inflate should never enter the reward function.

    3. Training loop: rollout, scoring, update

    1. for batch in env_pool.sample(batch_size): # each batch mixes different task types
    2. trajectories = []
    3. for spec in batch:
    4. state = reset(spec)
    5. traj = []
    6. for step_id in range(spec.timeout_steps):
    7. action = policy.act(spec, state, traj) # decide the next action based on the history trajectory
    8. state, done, info = step(state, action)
    9. traj.append((action, info))
    10. if done:
    11. break
    12. r = shaped_reward(spec, state, aggregate(info for _, info in traj))
    13. trajectories.append((traj, r))
    14. # normalize advantages within groups of multiple samples of the same task to reduce variance from reward-scale differences
    15. advantages = group_normalize(trajectories)
    16. policy.update(advantages)

    4. Curriculum learning and difficulty filtering

    Sample in layers by task pass rate. Tasks with a pass rate stuck near 100% or near 0 both provide weak learning signals: the former pose no challenge, and the latter usually indicate a problem with the environment itself. Prioritize tasks whose pass rate sits in the middle range.

    5. Anti-forgetting and anti-collapse monitoring

    • Periodically evaluate on a general-capability regression set that also covers safety-alignment samples;
    • Monitor the policy’s output entropy and diversity, and roll back to an earlier checkpoint when a sustained decline appears;
    • Configure mixed-training ratios by category—general, coding, agent, and so on—to avoid a single data type crowding out other capabilities.

    6. Evaluation system: look at structure, not just the total score

    Public leaderboards are useful for cross-comparison, but decisions should rely on metrics close to your business:

    • Task success rate and consistency across multiple runs;
    • Average interaction steps and the proportion of invalid calls;
    • First-pass rate and rework rate;
    • Unit-test pass rate and number of code-review issues.

    Evaluation environments must be isolated from training environments, with regular contamination detection.

    6. Cloud deployment: a supporting infrastructure checklist

    Long-horizon agent training places specific demands on infrastructure, which can be grouped into general capability requirements:

    • Compute: unified scheduling of heterogeneous compute resources, plus priority isolation between training and evaluation tasks;
    • Environment: large numbers of parallel sandboxes requiring elastic creation and teardown at millisecond-to-second latency, isolated via containers to prevent cross-task contamination;
    • Data: high-throughput, low-cost object storage for massive interaction trajectories and checkpoints, with hot/cold data tiering;
    • Observability: unified logging and monitoring to trace every tool call, reward change, and abnormal interruption, and to locate the root cause of training oscillations.

    7. Conclusion

    • Deep post-training: suited to teams with tight delivery timelines that want to quickly improve coding and agent performance on an existing base. The prerequisite is a high-quality environment pool, clean verification signals, and strict evaluation isolation.
    • New base retraining: suited to teams with long-term compute planning that need to position next-generation capabilities. It buys a higher ceiling at the cost of a longer cycle and greater uncertainty.
    • At the execution level: success or failure often depends not on parameter scale or post-training duration itself, but on three pieces of “slow work”—environment quality, reward design, and the evaluation system. Base models can be swapped, but environment assets and evaluation capabilities are the accumulations that can be reused over the long term.