How Large Language Models Improve: From Pretraining to Vertical Industry Deployment

    Model performance does not depend on model size alone. This article explains how pretraining, verifiable-reward reinforcement learning, retrieval, workflow design, and agent evaluation contribute to real-world outcomes. It also presents a practical method for distinguishing knowledge gaps, reasoning limitations, execution failures, and cost issues before investing in model upgrades or fine-tuning.

    Frequent model releases often lead teams to focus on one question: how much better is the next model than the previous one? For developers and businesses, a more useful question is: where exactly is the current task failing, and can switching models solve it?

    The same unexpected output may have very different causes. The model may not have access to the latest business rules, may be unable to plan a multi-step task, or may fail to verify the result after successfully calling a tool. These problems look similar on the surface but require different solutions involving knowledge access, model capability, or execution workflows. Treating them as the same issue can increase training and inference costs without improving delivery outcomes.

    1. Pretraining Builds General Capabilities, but Model Size Is Not the Only Variable

    Large language models typically learn by predicting the next token. Although the objective is simple, training on broad, high-quality data encourages models to learn relationships between words, common document structures, and patterns for communicating and solving problems across different scenarios.

    When given new input, a model can reuse these patterns to summarize documents, generate code, or perform multi-step analysis. However, producing a plausible answer does not mean the answer is correct. It also does not mean the model knows an organization’s latest policies or data.

    When training data and computing resources are properly aligned, larger models generally have a higher capability ceiling. This is especially relevant for tasks that require combining information from multiple sources, handling exceptions, or transferring knowledge to unfamiliar problems. However, parameter count is not an independent measure of quality. Data quality, coverage, training completeness, and model architecture also affect results.

    For field extraction, fixed-format conversion, and simple routing, a smaller model may be the better choice if it meets the acceptance criteria. For tasks involving scattered evidence, conflicting rules, or multiple decisions, it is worth evaluating whether a more capable model produces a meaningful improvement.

    Model selection should begin with a baseline built from the same business samples, input materials, and acceptance criteria. If two models receive different documents or have access to different tools, it becomes difficult to attribute the performance difference to the models themselves. Only by isolating these variables can a team determine whether an improvement comes from a model upgrade or from better context and workflow design.

    2. Verifiable-Reward Reinforcement Learning: Improving Capabilities Through Outcome Checks

    Supervised fine-tuning and reinforcement learning with verifiable rewards address different problems.

    Supervised fine-tuning primarily teaches a model from example answers. It is useful for standardizing output formats, writing styles, and common processing steps. Reinforcement learning with verifiable rewards allows a model to generate an answer or execution process, after which a verifier determines whether the result is valid and provides a training signal for updating the model’s policy.

    This approach is valuable when a team cannot easily write a complete reference solution for every problem but can reliably determine whether a result is correct.

    Consider a data reconciliation task. Demonstrations can teach the model which fields should appear in a discrepancy report. A verifier can then check whether the details reconcile with the general ledger, whether the discrepancy amount uses the correct accounting definition, and whether the cited records actually exist.

    The first method teaches the model how to structure the report. The second constrains it to produce a result that can pass recalculation. The two methods can complement each other, but memorizing a report format does not mean the model has learned to reconcile data correctly.

    In many cases, the main bottleneck is the verifier rather than training compute. If the verifier checks only output formatting, the model may produce a structurally correct report with incorrect amounts. If it checks only the final total, it may miss detailed discrepancies that cancel each other out.

    A verifier should prioritize non-negotiable constraints. Known-correct and known-incorrect samples should be used to test false positives and false negatives. Some tasks also require separating automatically verifiable facts from content that depends on human judgment.

    For example, a system may automatically verify whether an analysis cites valid records, but citation count alone cannot determine whether the analysis is complete. Expert review is still required for such aspects. An easily measured proxy should not automatically become the quality objective.

    3. Vertical Industry Deployment: Distinguish Knowledge Gaps from Capability Gaps

    Being “expert-level” in a vertical domain should be defined through a bounded set of tasks. The key questions include:

    • Can the model make the correct decision when the necessary information is available?
    • Can it identify missing information when the materials are incomplete?
    • Can it raise items for confirmation when rules conflict?

    A single benchmark score cannot replace this evidence. In particular, high accuracy on routine samples does not prove that the model can handle rare exceptions.

    A practical diagnosis can begin with a controlled experiment: provide the model with the relevant rules, data, and examples, then observe whether the errors disappear.

    • If performance improves substantially after the materials are added, prioritize knowledge access. Put reviewed documents into a retrieval workflow and record their sources, versions, and effective dates so that answers can be traced to evidence. For frequently changing policies and pricing definitions, updating the knowledge source is usually easier to maintain than repeatedly retraining the model.
    • If the model still makes frequent errors with complete information, distinguish reasoning errors from formatting errors. If the conclusion is correct but the structure is wrong, try output constraints or supervised fine-tuning first. If the model consistently confuses rule priority or misses boundary conditions, compare task decomposition, a stronger model, and post-training rather than immediately launching a large-scale fine-tuning project.
    • If the conclusion is correct but execution fails, inspect the tools and workflow. Missing parameters, insufficient permissions, timeouts, and changes in external state can all cause failure. Switching models may not help. First distinguish tool-call failures, operations that did not take effect, and failures to verify the result. Then define retry or human-escalation conditions for each category.

    This diagnostic order makes it possible to fix clear problems through retrieval, validation, or workflow changes before investing in post-training. Post-training is easier to justify when the error is reproducible, the training objective is clear, and the improvement can be measured on an independent test set.

    4. Deploying AI Agents: Validate Business State, Not Just Natural Language

    When a model can retrieve data, call tools, and update business state, system acceptance should not focus only on what the model says. It must also verify what actually happened.

    For example, a response stating that “the record has been updated” does not prove that the write succeeded. The system must check whether the target state took effect and whether any unrelated records were changed.

    A safer architecture allows the model to interpret intent, extract parameters, and select authorized operations. Deterministic code should then handle permission checks, data validation, and submission.

    Read-only queries, draft generation, and production writes should use different permission levels. Irreversible operations or actions with a broad impact should display the proposed changes and require confirmation before submission.

    Writes that may be retried after a timeout require idempotency controls and result queries. Otherwise, one logical operation may be executed more than once.

    Evaluation should also be layered:

    1. Check whether the output can be parsed by downstream systems.
    2. Verify facts, citations, and business rules.
    3. Confirm that the actual business state satisfies the acceptance criteria.

    Test sets should include not only routine business cases but also missing information, conflicting rules, tool timeouts, and duplicate submissions.

    Deployment can proceed gradually:

    • Validate performance through offline replay.
    • Observe production inputs without triggering formal writes.
    • Gradually enable a small number of low-risk operations.

    If the error rate, human handoff rate, or tail latency exceeds business tolerance, the system should be able to roll back to the previous version or transfer the task to a human workflow.

    5. Cost Accounting: Compare the Cost of a Successful Delivery

    Token pricing reflects only part of inference cost. Long contexts, redundant output, multi-turn retries, retrieval, tool execution, and human review can all change the total cost.

    A low-cost model may not be cheaper if it frequently requires retries or manual correction. Conversely, using an expensive model for large volumes of simple tasks may create unnecessary spending.

    A more meaningful metric is:

    Cost per successful task = total model, tool, and human-processing costs generated during the measurement period ÷ the number of tasks that pass the unified business acceptance criteria

    The numerator should include resources consumed by failed tasks. The denominator should not count tasks that only generated an answer but did not complete acceptance.

    When comparing approaches, teams should also report success rate, tail latency, and human handoff rate. Otherwise, a system might appear cheaper simply because it refuses to handle difficult tasks.

    If task types vary significantly, report results by complexity and risk category. This makes it possible to decide which tasks should use rules or lightweight models, which should be assigned to more capable models, and which require human review.

    Large language models can improve through several paths. Pretraining expands general capabilities. Verifiable-reward reinforcement learning improves problem-solving behaviors that can be checked objectively. Retrieval supplies current evidence. Workflows constrain execution and verify results.

    Businesses do not need to invest in every path at once. A more effective starting point is to define one business task with clear acceptance criteria, establish a baseline, identify the main failure cause, and use the same evaluation framework to determine whether a proposed change is worth deploying.