Beyond Scale: How Post-Training Creates the Capability Gap Between LLMs

    A controlled experiment shows that with the base model, architecture, and total and active parameter counts held fixed, extending post-training and reinforcement learning alone was enough to bring a model to parity with top open-weight models. This article explains why post-training has become a primary driver of model capability. It breaks model scale into four interdependent variables (total parameters, active parameters, training data, and training duration), explains what the fixed-scale experiment demonstrates, and shows how long chains of thought let smaller models trade compute time for reasoning depth. It also explains why that advantage hits diminishing returns on coding tasks, where high-quality executable environments and feedback data matter more than raw size, and closes with practical guidance on evaluating models against your own workloads and optimizing inference cost in production.

    Introduction: The Front Line for Capability Gains Is Moving Downstream

    Over the past year or two, the large-model community has run a telling controlled experiment: with the base model, network architecture, total parameter count, and active parameter count all held identical, simply extending the duration of post-training and reinforcement learning was enough to bring the model’s aggregate intelligence on authoritative third-party evaluations up to parity with leading open-weight models, placing it among the most capable open-weight models available.

    The value of experiments like this lies not in any single score but in the clean research variable they isolate: once “scale” is held fixed, nearly all of the capability gap comes from the post-training stage. This suggests we can no longer judge a model by parameter count alone. We have to weigh training data, training duration, inference cost, and the choice between dense and sparse architectures together. The analysis below covers four angles:

    1. How the four scaling variables trade off against one another;
    2. What the controlled experiment demonstrates;
    3. How long chains of thought help small-parameter models compensate for their size;
    4. Why the gains from long chains of thought diminish in coding tasks.

    I. The Four Axes of Scale: Parameter Count Is Only One

    Looking back at early training practice, a couple of common approaches now seem worth reconsidering:

    • Some models were built with excessively large parameter counts, while the scale of training data failed to keep pace;
    • Resource allocation leaned toward minimizing training cost, with too little thought given to long-term inference cost.

    A more sensible view breaks model scale into four interdependent variables:

    1. Total parameter count: sets the model’s capacity ceiling — how much knowledge, how many concepts and patterns it can hold;
    2. Active parameter count: in sparse architectures such as mixture-of-experts (MoE), each token activates only a subset of experts, and the compute for a single forward pass is determined by the active parameters;
    3. Training data scale: determines how fully the knowledge in the parameters is “filled in”;
    4. Training duration: determines how many rounds of optimization the model has gone through, including the time spent on post-training and reinforcement learning.

    These four are not independent. A common empirical result from scaling laws is that, under a given compute budget, parameter count and training data sit in an approximate power-law tradeoff. When the parameter count is fixed, too little data limits knowledge density; when data is abundant, the returns from piling on more parameters gradually taper off. On the inference side, total parameters affect memory footprint while active parameters determine the compute per step, and together they dictate deployment cost. A model with a large total parameter count but a small active parameter count can be fairly cheap to run per step, yet its memory and parallel-communication overhead can still be substantial.

    II. The Fixed-Scale Controlled Experiment: How Far Can Post-Training Go?

    The design of this experiment is essentially a controlled-variable approach:

    • Held fixed: the base model, model architecture, total parameter count, and active parameter count;
    • Single variable: the amount of investment in post-training and reinforcement learning (about one month).

    The result sends a clear signal: without adding any parameters, post-training and reinforcement learning were enough to push the model into the first tier of open-weight models. This isn’t so much one model “catching up” to another as it is validation that post-training itself offers a substantial, independent scaling space.

    Two caveats are worth noting:

    1. Leaderboards are a reference, not a conclusion. Third-party aggregate evaluations typically combine normalized scores across many benchmarks. They’re good for observing capability tiers side by side, but they rarely reflect real-world performance on specific business tasks.
    2. A tie doesn’t mean the models are the same. Two models with similar aggregate scores can differ sharply in how strong or weak they are across individual capability dimensions: one might be steadier at long-context handling, while the other generates code more accurately.

    What’s more interesting is where this experiment sits on the efficiency-versus-capability plane. If we treat “the inference cost required to reach a given level of capability” as the cost axis and “aggregate intelligence” as the capability axis, then the set of models that keep pushing cheaper solutions into higher capability ranges forms the Pareto frontier. The significance of this experiment is that it didn’t expand scale to grab the top of that frontier; instead, it contributed a new Pareto-optimal point in the mid-to-high capability band — the range where actual call volume is most concentrated. For token-priced API calls, that band often maps directly to the largest potential cost savings.

    III. Where Does Post-Training’s Scaling Space Come From?

    There are three main sources of the substantial gains that post-training and reinforcement learning can deliver.

    1. Distribution alignment: turning “knows how” into “does it right”

    During pre-training, a model learns to predict the next token, and this objective isn’t perfectly aligned with genuine human intent. Post-training uses supervised fine-tuning and preference alignment to steer the model’s output distribution toward what is “useful, correct, and properly formatted.” This step adds no parameters, yet it changes how the existing parameters are organized.

    2. Capability elicitation: latent ability gets activated

    A base model often already holds a considerable stock of knowledge and reasoning potential, but it struggles to invoke that ability reliably during free-form generation. Post-training effectively provides a large body of “demonstrations plus feedback,” teaching the model when to apply which capability and converting latent ability into stable performance.

    3. Verifiable reinforcement learning: learning to self-check from outcomes

    This is the fastest-growing approach of the past couple of years. When a task has an objective pass/fail criterion — whether code passes tests, whether a math answer is correct, whether a tool call succeeds — the model can sample multiple solutions to the same problem and grant positive reward only to the ones that pass. Through many rounds of iteration, the model gradually learns to:

    • spot problems on its own;
    • go back and check intermediate steps;
    • change direction when necessary.

    This is precisely where long chains of thought come from.

    It’s worth stressing that post-training is no “free lunch”:

    • Poorly designed rewards can invite “reward hacking,” where the model learns to cater to the scoring criterion rather than actually solve the problem;
    • If the reinforcement-learning stage lacks enough exploration diversity, it can narrow the model’s output style.

    So the scaling gains from post-training have a ceiling, and they depend heavily on the quality of the task environment and the feedback signals.

    IV. Long Chains of Thought: How Small-Parameter Models “Trade Time for Space”

    4.1 The “compute ceiling” of a single forward pass

    Mainstream Transformer decoding architectures have a fixed number of layers. For a given model, the compute needed to process each token is roughly constant, estimated as follows:

    1. Forward compute per token ≈ 2 × active parameter count (in FLOPs)
    2. Total compute for one reasoning pass ≈ 2 × active parameter count × input tokens × output tokens

    This means the amount of computation a small-parameter model can do in a single forward pass is limited. Faced with a complex problem, no matter how “hard” it tries, the depth of reasoning it can complete in one step is locked by the number of layers.

    4.2 Moving the compute into the inference stage

    Long chains of thought sidestep this limit cleverly. Each time the model generates a reasoning step, it writes the intermediate result back into the context; on the next step, those results re-enter the computation as inputs. From a compute perspective, the model is effectively drafting several extra rounds outside the original network, using the “context window” as an external memory:

    1. Step 1: Identify the problem type and list the known conditions
    2. Step 2: Feed the Step 1 result as input and try the first approach
    3. Step 3: Feed the results of the first two steps as input to verify and correct
    4. ...

    The whole computation gets spread across more forward passes. Reasoning that would have required a “deeper network” becomes “more rounds of shallow reasoning.” This also explains why, on some third-party aggregate evaluations, certain small-parameter models can buy themselves closer to the tier of mainstream models several times larger, simply by thinking longer.

    4.3 The returns are not linear

    This compensation comes at a clear cost:

    • Latency: the number of generated tokens directly determines response time;
    • Cost: both input and output tokens are billed, and a long chain of thought means output tokens multiply;
    • Diminishing returns: once a model gets stuck in repeated self-checking and redundant verification, the accuracy gains from extra thinking get smaller and smaller.

    So whether a long chain of thought is justified can’t be judged by capability scores alone; you also need two metrics:

    • cost per correct answer;
    • P95 response latency.

    Rough estimation formulas for both:

    1. def cost_per_correct(answer_tokens, input_tokens, price_in, price_out, accuracy):
    2. """Estimate the cost of answering one question correctly (use the same price units as your billing)"""
    3. cost = input_tokens * price_in + answer_tokens * price_out
    4. return cost / max(accuracy, 1e-6)
    5. # Example: cost-per-correct for a short vs. long chain on the same question
    6. short_chain = cost_per_correct(800, 1200, 1.0, 3.0, 0.55) # ~6.8
    7. long_chain = cost_per_correct(6000, 1200, 1.0, 3.0, 0.85) # ~25.4

    In this example, the long chain of thought raises accuracy from 55% to 85%, but the cost per correct answer climbs to about 3.7×. Whether that’s worth it depends on how the business weighs accuracy against cost.

    V. Coding Tasks: Why Long Chains of Thought Hit Diminishing Returns

    There’s a phenomenon worth thinking about: some small-parameter models match larger models on aggregate evaluations mainly by “thinking longer.” Yet on coding tasks, some models whose reasoning length isn’t especially long perform just as well. The reason lies in what makes coding tasks special.

    5.1 Code is verifiable

    Code comes with objective feedback signals by nature:

    • errors reported by compilers and interpreters;
    • results of unit and integration tests;
    • warnings from static analysis tools.

    These signals require almost no human annotation and can be generated automatically at scale, giving reinforcement learning a cheap and reliable “reward.”

    5.2 Small models can “try a few more times”

    For models with fewer parameters and limited single-step reasoning depth, the cost of trial and error on coding tasks is relatively low: write it wrong, run it, see the error, and fix accordingly. As long as you generate enough candidates and select from them, you can land on a correct answer. This is exactly why “trading time for space” works in coding scenarios. Rewards based on test cases are also one of the mainstream approaches for training coding ability with reinforcement learning today.

    5.3 Mid-sized models no longer lean on long chains

    The catch is that once a model’s scale crosses a certain threshold, the marginal benefit of extending the chain of thought further drops quickly. There are three reasons:

    1. Single-step reasoning is already good enough. Common tasks (understanding requirements, writing a module, locating an error) can be handled within relatively few reasoning steps.
    2. Long chains introduce redundancy. Excessive self-checking and repeated deliberation burn more tokens without improving accuracy.
    3. Feedback quality becomes the new bottleneck. At this point, what caps capability is no longer “whether it thought long enough” but “whether it has seen enough feedback, and whether that feedback is realistic.”

    So a judgment worth taking seriously is this: for coding tasks, a sparse model on the order of hundreds of billions of total parameters and tens of billions of active parameters may already be close to enough at the parameter level; beyond that point, the gap depends more on the quality of post-training data.

    5.4 What counts as a “high-quality executable environment”

    An executable environment refers to the complete context in which code can actually be run and receive feedback. It typically includes:

    • reproducible dependencies and runtimes;
    • representative test cases;
    • the full code-repository context;
    • engineering conventions that resemble real business practice.

    Building such environments costs far more than ordinary text annotation, yet it directly determines whether a model can learn to write code that is “runnable, maintainable, and convention-compliant.” The industry’s growing emphasis on building tasks and execution feedback around real repositories stems precisely from this.

    VI. Practical Guidance: Evaluate Models in Your Own Context

    1. Build your own evaluation set. Use third-party leaderboards to gauge capability tiers, but base the final selection on representative tasks from your own business.
    2. Measure end to end. For coding tasks, focus on compile pass rate, test pass rate, and human-review acceptance rate, rather than isolated point metrics.
    3. Compare with controlled variables. Fix the prompt, sampling parameters such as temperature, and budget ceiling, then compare “cost per correct answer” and P95 latency rather than scores alone.
    4. Match the inference budget to the task. Simple, high-frequency, templated tasks should favor short outputs; complex, low-frequency, high-value tasks can afford longer chains of thought.
    5. Value context and tools. Context-management ability, retrieval ability, and tool-call accuracy often determine real-world results more than a model’s own parameter count.
    6. Build a verifiable data flywheel. Feed errors, test results, and review feedback from live tasks back as training signals to form a continuously iterating feedback loop.

    VII. Deployment and Cost Optimization: Turning Post-Training Gains into Production Value

    For the capability gains from post-training to translate into real business value, they also depend on engineering:

    • Inference precision: use quantization and similar techniques to cut memory and compute overhead, provided precision is preserved or the loss stays controlled;
    • Batch scheduling: dynamically batch concurrent requests to raise throughput per unit of compute;
    • Output-length control: set a sensible maximum generation length and thinking budget to avoid wasting compute on ineffective long chains;
    • Cache reuse: cache results for identical or similar requests to avoid redundant inference;
    • Elastic resources: use cloud container platforms and elastic compute to scale on demand, and track latency and error rates with a monitoring and alerting system to balance cost against stability.

    Conclusion: From “Stacking Parameters” to “Building Environments”

    The core messages from this fixed-scale experiment are:

    • Post-training and reinforcement learning have become a source of capability growth on par with pre-training;
    • Scale is no longer the only variable — parameters, data, duration, and inference cost must be weighed together;
    • Small-parameter models can use long chains of thought to compensate for their size, but this compensation shows clear diminishing returns;
    • For coding tasks, once scale crosses a certain threshold, high-quality executable environments and feedback data may be the key to the capability ceiling.

    For developers, choosing a model shouldn’t come down to leaderboard rank alone; it should be built around an evaluation and cost-accounting system grounded in real tasks. For platform providers, cutting inference cost, improving inference efficiency, and building a verifiable data loop are the key paths to turning model capability into product competitiveness.