Two Paths in the LLM Race: Post-Training Optimization vs. Rebuilding Larger Base Models
Chinese LLM competition is shifting from "who has more parameters" to "who can get more real work done." This article examines the two dominant technical routes—deep post-training optimization on existing bases versus training larger foundational models from scratch—and explains why long-horizon agent environments, realistic coding evaluations, and total cost of ownership matter more than benchmark scores when assessing model capability.
In recent years, competition among Chinese large language models has gradually shifted from “who has more parameters” toward “who can get more real work done in actual tasks.” Model scale still matters, but in scenarios such as coding, terminal operations, cybersecurity, complex reasoning, and multi-tool collaboration, the end-user experience is rarely determined by parameter count alone. A base model’s architecture, training data, inference strategy, tool-calling ability, and the task environments used during post-training all directly affect whether a model can reliably complete complex work.
From a technical standpoint, current approaches fall into two broad categories. The first keeps the existing base model unchanged and continuously unlocks its potential through large-scale post-training, reinforcement learning, and simulated real-world task environments. The second involves redesigning or retraining an ultra-large foundation model, using greater parameter capacity and broader pretraining data to push the ceiling of capability higher. The former is like deeply polishing an existing system; the latter is closer to building an entirely new, larger infrastructure.
1. Post-Training Is Not Simple Parameter Tuning
Many people still think of post-training as tweaking a few learning rates, adjusting prompts, or adding a small amount of instruction data. This view is clearly outdated compared with current practice. For models that already have strong foundational capabilities, post-training can cover supervised fine-tuning, preference optimization, process rewards, reinforcement learning, tool-use training, and long-horizon task training.
This is especially true for coding and agent tasks, where a model must solve not an isolated problem but a continuous chain of tasks. For example, the model may need to first understand requirements, then search the codebase, modify multiple files, run tests, locate failures, and keep fixing issues based on logs. If training only includes single-turn Q&A, the model may generate plausible-looking code but struggle to work continuously in a real environment.
More effective post-training approaches therefore build complete task environments that let the model repeatedly practice in scenarios close to actual engineering work. These environments can include code repositories, terminals, test systems, documentation, simulated network requests, and permission control modules. The model’s output is no longer judged by whether the answer “sounds human,” but by objective signals: whether the program runs, whether tests pass, whether errors decrease, and whether the task is completed.
The core shift in this kind of training is transforming the model from a “text generator” into a “task executor.”
2. Long-Horizon Task Environments Determine the Agent Ceiling
For a traditional language model, answering a question may require only a few hundred tokens. But for complex engineering tasks, a model must stay aligned with its goal across dozens or even hundreds of interactions, continuously correcting its own behavior. Long-horizon tasks have therefore become a key benchmark for agent capability.
Long-horizon task training typically involves three critical components.
The first is state management. The model must know what has already been done, which files were modified, which tests failed, and what to do next. Without adequate context management, models tend to repeat actions or forget early constraints.
The second is error recovery. Real environments do not always run smoothly—code may fail to compile, dependencies may be missing, and test results may not match expectations. A strong agent should not simply terminate when it hits an error; it should read logs, analyze causes, adjust its approach, and try again.
The third is goal decomposition. Complex requirements usually cannot be completed in one pass; they need to be split into subtasks and executed step by step according to dependencies. The model must not only write code but also plan tasks, schedule validation, and check results at key milestones.
Adding more long-horizon task environments therefore tends to improve real-world experience far more than simply adding more Q&A samples. But this also significantly raises training costs, since every complete task may involve environment setup, code execution, test wait times, and multi-round strategy search.
3. The Advantages—and Real Costs—of Ultra-Large Base Models
The other path is scaling up the foundation model and redesigning the training data, model architecture, and training pipeline. Ultra-large models theoretically offer greater knowledge capacity, stronger pattern abstraction, and better modeling of complex relationships, making them well suited for cross-domain knowledge, long-context reasoning, and multi-step tasks.
A larger base model can deliver three kinds of benefits.
First, broader knowledge coverage. The model can memorize and connect more types of text, code, and specialized material, giving it stronger transfer capability in unfamiliar domains.
Second, richer representations. Complex tasks require simultaneously understanding semantics, structure, constraints, and causality. As parameter count grows, the model may form more fine-grained internal representations.
Third, a higher capability ceiling. As task difficulty rises, smaller models may quickly hit capacity bottlenecks, while an ultra-large base still has room for further optimization.
However, parameter count does not equal real-world performance. Ultra-large models face the same challenges of data quality, optimization stability, inference cost, memory footprint, and deployment complexity. If post-training is insufficient, the model may simply have a larger knowledge reserve without being able to reliably complete real work. For enterprises, per-call latency, resource consumption, and concurrency capacity often matter more than a single top score achieved in a lab setting.
4. How to Properly Evaluate Coding Capability
Coding ability should not be judged solely by whether code is generated. It should be broken down into at least the following dimensions:
- Requirement understanding. Can the model identify explicit requirements, implicit constraints, and edge cases?
- Code generation. Can the model produce code that is well-structured, consistent in style, and maintainable?
- Repository-level modification. Can the model understand dependencies across multiple files and make systematic changes?
- Debugging. Can the model locate problems based on compilation errors, runtime logs, and test results?
- Verification. Does the model proactively run tests instead of declaring a task complete based on surface inspection?
- Engineering planning. Can the model decompose complex requirements, control the scope of changes, and reduce the risk of introducing regressions?
In real-world development, the last three dimensions usually matter more than single-shot code generation. A model that writes beautiful functions is not necessarily able to deliver feature changes in a real project; conversely, a model with less elegant code style that can consistently run tests and fix problems often has more production value.
That is why terminal tasks, code repository tasks, and agent benchmarks attract so much attention—they are closer to developers’ actual workflows. The model must not only “say it right” but also “get it done.”
5. Benchmark Results Cannot Be Read Without Their Test Conditions
When comparing models, public benchmarks provide useful references, but a single score should never be equated with overall capability. Evaluation results are affected by at least the following factors:
- Task type. Some tests focus on code completion, others on repository-level fixes, command-line operations, or tool calling and multi-round planning. Different models may perform very differently across task categories.
- Tool permissions. Whether the model can access files, execute programs, or read web resources affects results. If test environments differ, scores are not strictly comparable.
- Inference budget. Some systems allow the model more rounds of thinking and retries. Response times are longer, but completion rates may be higher. Comparisons should therefore also account for latency, call counts, and resource consumption.
- Success criteria. Judging whether the final text looks correct is a completely different level of difficulty from requiring code to pass tests and tasks to execute end to end. Enterprise internal evaluations should prioritize verifiable metrics, such as test pass rate, one-shot completion rate, amount of manual rework, average task duration, and error recovery count.
6. The Two Paths Are Not Mutually Exclusive
Post-training optimization and rebuilding larger base models are not an either-or choice. The ideal development path typically starts with high-quality pretraining to establish the capability foundation, then uses real-world task environments for reinforcement learning, and finally combines inference strategies, tool systems, and deployment optimization into a complete product.
If a base model still has substantial untapped potential, prioritizing post-training likely offers better return on investment. It does not require rebuilding the entire training pipeline, can quickly focus on coding, terminal operations, and enterprise workflows, and iterates more easily based on user feedback.
If the model has already plateaued across multiple tasks, or needs to cover more complex knowledge domains, then switching base models, scaling up, and redesigning the training pipeline may be more worthwhile—but this route carries higher data, compute, and engineering risks.
7. Enterprises Should Focus on Total Cost
For enterprise users, choosing a model should never come down to leaderboards alone. It is advisable to build an evaluation framework covering the following metrics:
- Task completion rate on business-specific workloads;
- Usability rate of generated code or documentation;
- Stability across multi-round tasks;
- Average response latency;
- Resource cost per task;
- Private data isolation capability;
- Security boundaries for tool calling;
- Recovery capability after failures;
- Whether results are easy to audit and trace.
In security-sensitive scenarios, the model’s file permissions, network access scope, and command execution ability should be restricted, with complete logs retained for every operation. The more capable an agent becomes, the greater the potential risk—sandboxing, tiered permissions, human approval, and rollback mechanisms are essential constraints.
In summary, ultra-large parameters provide a wider capacity envelope, while post-training builds stronger task-execution habits. The former determines how high a model might go; the latter determines whether it can work reliably in real environments. Future LLM competition will not revolve solely around parameter scale—it will gradually shift toward data quality, task environments, inference efficiency, security governance, and overall delivery capability.
The question truly worth watching is no longer “who has more parameters,” but: given a fixed budget of cost, time, and permissions, can a model complete complex work consistently, reliably, and verifiably? That will become the core standard for measuring the value of next-generation intelligent systems.
