Chinese Large Language Models Are Splitting Into Two Paths: Deep Post-Training vs. Larger Foundation Models
As Chinese large language models enter a rapid release cycle, vendors are emphasizing stronger coding ability, agentic capabilities, and longer context windows. This article compares two competing approaches: squeezing more capability out of an existing base model through intensive post-training, and building a new base model with a larger parameter scale. It explains how pre-training sets the lower bound of model knowledge while post-training shapes behavior and task reliability, why post-training can act as a major growth engine under the right conditions, how to read public benchmarks critically, how to build an internal evaluation system, and how to choose between the two paths based on task type, cost structure, and team capabilities.
Introduction: Two Paths Collide at the Same Time
Chinese large language models are entering a high-frequency release period. New versions are appearing in rapid succession, and most promotional materials focus on the same set of capabilities: stronger programming ability, stronger agentic ability, and as long a context window as possible.
Two types of approaches stand out when compared side by side:
- Deep-post-training approach: Keep the existing base model unchanged and concentrate effort on post-training. Expand the number of task environments by an order of magnitude, substantially diversify environment types, and significantly extend training time. The goal is to unlock the full potential of the base model and push coding ability to a higher level.
- New-base-model approach: Design a new base model with a larger parameter scale and directly trade larger parameter count for a broader capability surface.
This article does not compare specific products. It answers two questions: To what extent can post-training replace a larger base model? What criteria should enterprises and development teams use when choosing between these two paths?
1. Clarifying the Concepts: Pre-Training Sets the Lower Bound, Post-Training Shapes the Upper Bound
Many discussions treat “switching to a new base model” as technical advancement and “adjusting post-training” as a patch. A more accurate distinction is based on the nature of the investment.
Pre-training shapes a model’s knowledge foundation. The model performs massive parameter updates over massive corpora. Language patterns, code structures, and domain knowledge are compressed into the weights. This determines what a model is potentially capable of doing. Keeping an existing base model or switching to a new one means returning to a training process at the level of trillions of tokens, with compute and timelines measured in months.
Post-training shapes a model’s behavioral form. Post-training usually includes three stages:
- Instruction tuning and code instruction tuning, which teach the model to follow instructions and generate runnable code.
- Human preference alignment, which makes responses more consistent with expected usage patterns.
- “Environment-based training” centered on reinforcement learning, where the model repeatedly attempts tasks and learns from feedback in interactive environments.
Post-training determines how stably a model can perform and how it approaches a task.
An analogy helps clarify this:
- Pre-training is like classroom learning: build foundations in language, mathematics, and programming.
- Post-training is like hands-on training in a real lab or engineering environment: face real projects, make mistakes, redo tasks, and learn until delivery becomes reliable.
A programmer with a strong foundation but no real project experience is unlikely to become a reliable engineer. Conversely, someone with gaps in their foundation cannot fix every weakness through practice alone.
A common misunderstanding is that post-training creates a separate track outside pre-training. In practice, post-training mainly involves examining content generated by the model itself and judging its quality. This is the core logic behind recent post-training methods built around verifiable rewards, often referred to in the industry as RLVR:
- Code can run tests: Whether test cases pass is an objective signal and is suitable for reinforcement learning.
- Terminal tasks can be checked by final state: Whether files are modified correctly and whether services start can also be judged objectively.
From an engineering perspective, the two paths represent two different investment structures:
- Switching to a new base model resembles a large one-time capital expenditure. The bill is clear, but the capability improvement is broader.
- Continuously deepening post-training resembles ongoing operational investment. Its returns depend on three factors: accumulation of environment assets, training stability, and data feedback from real business use.
This also explains the precondition for “extreme squeezing” of a base model: the base model still has untapped potential, and business requirements are focused enough.
2. The Deep-Post-Training Path: Why Post-Training Can Be the Primary Engine
Post-training becomes the main engine not because of one clever trick, but because three conditions hold at the same time.
2.1 Training Compute: Treat Reinforcement Learning as a Systems Engineering Problem
From a paradigm perspective, the core change in this generation of post-training can be summarized with a simple formula: post-training = RL + Environments. Compute and data for reinforcement learning are no longer just a small appendix after pre-training.
The difficulty lies in training instability. The policy model continuously interacts with the reward model or verifier, and three common failure modes appear:
- Reward hacking: The model does not truly solve the problem but exploits weaknesses in the judging logic.
- Entropy collapse: The model converges too early to a few fixed patterns, reducing exploration.
- Long-context overflow: As context length increases, memory usage for sampling and backpropagation rises sharply.
Long-context training is especially likely to hit the memory wall. In practice, several techniques are usually combined:
- Use sequence parallelism to split long sequences across multiple devices.
- Use sequence packing to reduce padding waste.
- Use gradient checkpointing to save activation memory.
“Throwing more compute at the problem” only works if stability engineering is in place. Otherwise, extra compute simply produces more failed experiments.
2.2 Number and Diversity of Environments: Helping the Model “See More”
In reinforcement learning, environments provide states, actions, and feedback. Environments in traditional games or control tasks are often simple and rule-based. Coding and terminal scenarios are very different:
- State is a continuously changing file system.
- Actions are a series of shell commands, code edits, or tool calls.
- Feedback comes from compilers, test cases, or the runtime behavior of services.
When vendors introduce this type of approach, they often emphasize “richer environment types,” such as terminal environments, code repository environments, and cross-tool collaboration environments. The value of expanding the environment pool lies in combinatorial diversity:
- If a single type of environment is scaled up repeatedly, the model may only learn one type of pattern.
- If mixed training is performed across environment types, the model can learn to explore in unfamiliar environments, act carefully, and roll back when problems occur.
Engineering teams need to guard against two problems:
- Task contamination: Evaluation questions leak into training environments, causing inflated scores.
- Distribution shift: Training environments differ from production environments in permissions, dependencies, or network settings, making learned policies difficult to transfer.
Therefore, environments themselves need version control: container images, dependency lists, initialization scripts, and verification answers should all be managed as versioned assets.
2.3 Training Duration: The Learning Curve Effect for Long-Horizon Tasks
Why is extending post-training time especially important? The root cause is a change in task granularity.
| Task granularity | Typical form | Feedback signal | Effect of a single step |
|---|---|---|---|
| Short tasks, such as code generation | Completing a function or fixing a single-line bug | Timely and explicit | Directly determines the result |
| Long-horizon tasks, such as terminal agents | Debugging, refactoring modules, cross-repository changes, and verification | Delayed and indirect | A single mistake may surface only after dozens of steps |
Feedback for long-horizon tasks is delayed and sparse. The model must learn through many trial-and-error steps when to roll back and when to ask for help. This kind of strategic capability is difficult to memorize. It requires enough samples across many rounds.
A simplified illustrative curve helps explain the pattern:
def capability(task_steps: int, training_samples: int) -> float:"""Illustrative function: demonstrates the shape of a learning curve, not real experimental data.task_steps: average steps per task, training_samples: post-training sample scale"""reach = 1 - 1 / (1 + task_steps / 10) # Base-model potentialreturn reach * (1 - 0.6 ** (training_samples / 1000))
The parameters do not come from measured data. They are used to illustrate two points:
- When base-model potential, or
reach, remains unchanged, scores rise monotonically as samples increase, but marginal returns gradually diminish. This corresponds to the limit of “squeezing” the base model. - Longer tasks lead to a smaller
reach. Even with an unlimited amount of post-training data, the ceiling is lower.
This is the basis for the larger-base-model path: when base-model capability becomes the bottleneck, adding more post-training cannot break through the ceiling.
This also echoes the earlier conclusion: pre-training sets the lower bound, and post-training shapes the upper bound. Post-training can become the primary engine only when the base model itself has enough exploitable potential.
3. How to Read Benchmarks: From Leaderboards to Real Capability
When new versions are released, vendors usually provide two kinds of information:
- Internal perceived improvements, such as “50% better coding feel.”
- Public benchmark rankings, such as first place among open-source models on two terminal or CLI-oriented benchmarks.
These claims have reference value, but they are easy to misread. The key questions are: what is measured, how it is measured, and whether it can be reproduced.
3.1 What Each Type of Claim Actually Indicates
Internal perceived improvement depends on the test set and evaluation method:
- If test questions overlap with training environments, the improvement may appear overly optimistic.
- “Perceived” quality is subjective. If evaluated by internal personnel, it may be more influenced by expectation effects.
“Open-source first” on a public benchmark is worth attention, but the qualifying conditions matter:
- Benchmark scope changes over time: A model may be first on one version of a leaderboard but not disclose performance across the full leaderboard.
- Parameter-scale limits: One approach is to divide models by parameter scale, such as tens of billions or hundreds of billions of parameters, achieve first place within a smaller parameter range, and then emphasize only “open-source first.” Models with different parameter scales are not on the same starting line.
- Partially open-source: Models that release only some weights should not be strictly compared with fully open-source models.
- Opaque evaluation settings: Different sampling temperatures, maximum steps, tool sets, self-verification policies, and retry counts can directly change conclusions.
More important is whether independent benchmarks point in the same direction. If multiple independent benchmarks focus on terminal or command-line agent scenarios, this indicates that resources in this generation of post-training are highly concentrated there. These scenarios closely match how intelligent coding tools perform multi-step tasks in a command-line environment.
What does “coding ability” specifically mean? From an engineering perspective, it includes at least five layers:
| Capability layer | Focus | Common evaluation methods |
|---|---|---|
| Language understanding | Accuracy of types, syntax, and framework conventions | Code completion and compile-pass rates |
| Engineering practice | Understanding of project structure and dependencies | Repository-level Q&A and defect localization |
| Executability | Whether generated code can actually run | Unit tests, compilation, and static checks |
| Agentic execution | Multi-step planning, tool calls, and error recovery | Terminal-task benchmarks |
| Security and compliance | Whether vulnerabilities or policy violations are introduced | Security scanning and compliance review |
Post-training can most directly improve the third and fourth layers, which are the strengths of the deep-post-training path. The first and second layers depend mainly on the base model and are the main focus of the new-base-model path. Different vendors choose different benchmarks, so looking only at aggregate scores can easily lead to partial conclusions.
3.2 Terminal-Based Benchmarks: Important, but Not Blindly Trustworthy
Terminal-based benchmarks measure whether a model can complete a closed loop in a real command-line environment: read code, locate the problem, modify code, and verify the result. This closely matches how developers use intelligent coding tools in daily work.
Their strength lies in objective judgment:
- Whether test cases pass is determined by programs, not subjective human scoring.
- Environments and tasks are reproducible and suitable for horizontal comparison.
- They are close to real development workflows, so conclusions are easier to apply to practical work.
They also have clear limitations:
- Heavy reliance on infrastructure: Image versions, dependency packages, and network availability can affect results.
- Scores may focus on final outcomes: A strategy of blind trial and error plus repeated verification may inflate scores, while the steps and compute consumed are not reflected in the score.
- Limited coverage: Single-file repair tasks are more common, while long-cycle refactoring and cross-team collaboration scenarios are less covered.
When selecting a model in practice, it is advisable to look at task completion rate together with cost consumption. One-step completion and completion after twenty trial-and-error steps may receive similar scores on a leaderboard, but their production bills can differ dramatically.
4. Build Your Own Evaluation: Bring Selection Decisions Back to Your Business
Public leaderboards can only be used for initial screening. Reliable decisions come from an internal evaluation set that is structurally similar to your business. A minimal viable evaluation plan can be built in four steps.
Step 1: Define the task set. Sample 50 to 200 tasks from real R&D scenarios, covering four categories:
- Troubleshooting
- Code refactoring
- Dependency upgrades
- Automated script writing
Each task needs a clear judging criterion: test cases, output verification, or human scoring rules.
Step 2: Build reproducible sandbox environments. Each task corresponds to a container image and initialization script. Once started, the task can be executed and judged automatically. Illustrative code:
from dataclasses import dataclassfrom typing import Callable@dataclassclass Task:task_id: strinstruction: str # Natural-language instruction for the modelimage: str # Container image tagsetup_script: str # Environment initialization scriptverify: Callable[[], dict] # Returns {"passed": bool, "detail": str}@dataclassclass RunResult:task_id: strmodel_tag: strpassed: boolsteps: int # Number of tool-call stepsinput_tokens: int # Input tokensoutput_tokens: int # Output tokenswall_time: float # End-to-end latencydef evaluate(model_tag: str, tasks: list[Task], max_steps: int = 50) -> list[RunResult]:"""Illustrative framework: each task runs in an isolated sandbox, is judged automatically, and records cost.This is only an evaluation skeleton and does not include any specific product APIs."""results = []for t in tasks:sandbox = Sandbox(image=t.image) # Start isolated containertry:sandbox.run(t.setup_script) # Initialize environmenttrace = agent_loop(t.instruction, sandbox, model=model_tag, max_steps=max_steps)verdict = t.verify() # Judge by test cases / verification scriptresults.append(RunResult(t.task_id, model_tag, verdict["passed"],trace.steps, trace.input_tokens,trace.output_tokens, trace.wall_time))finally:sandbox.close() # Ensure environment is cleaned upreturn results
Step 3: Control variables and sample multiple times.
- Control variables: When comparing different models, keep sampling parameters, maximum steps, tool sets, and runtime environments consistent.
- Repeated sampling: Run each task 3 to 5 times and compare pass rates rather than single results.
- Fine-grained reporting: In addition to pass rates, record average steps, token consumption, and timeout rates.
- Archive failure samples: Store failed samples and execution logs centrally in object storage for later post-training or workflow optimization.
Step 4: Establish a regression mechanism. Every time a model is upgraded, run the same evaluation set to form a longitudinal comparison curve. Teams usually can only call existing model interfaces and cannot control internal training. The variables they can control are limited to “prompts, tool orchestration, and context management.” The value of a regression mechanism is to see clearly which capabilities improve after an upgrade and which ones regress. Longitudinal curves are often more informative than a single cross-model ranking.
5. Cost: Parameter Scale Does Not Equal Real Cost
The claim of a “3-trillion-parameter new king” itself deserves caution.
First, parameter scale does not equal activated compute. Current mainstream large models often use a Mixture-of-Experts, or MoE, architecture. Total parameter count determines the model’s potential capability reserve, while the number of parameters actually activated during each inference determines compute cost. A model with a huge total parameter count may activate far fewer parameters per inference. Judging cost only by total parameter count can lead to completely wrong conclusions.
Second, deployment form determines total cost of ownership. Parameter scale directly affects memory usage and the minimum deployment threshold:
- Models with hundreds of billions of parameters and many activated parameters are difficult to serve with high concurrency on a single machine.
- Such models are often more suitable for cloud-based invocation, with token-based billing and elastic scaling.
- Some models support a “no-think” or fast-answer mode. Enabling this mode for routine Q&A can significantly reduce unnecessary reasoning output and lower costs.
Third, context length is a hidden cost. Long context is essential for agentic scenarios, but input tokens accumulate across turns, and costs grow with task duration.
Fourth, the cost of the post-training path lies on the training side. The deep-post-training approach spends most of its compute on post-training and evaluation. It requires the ability to continuously run reinforcement learning experiments, which is unrealistic for most enterprise application teams. A more realistic approach is: use the post-trained model versions delivered by vendors, and focus your energy on evaluation and business refinement.
Cost estimation formula (used to estimate the direct cost of a single task):
Cost per task ≈ average input tokens × input price+ average output tokens × output price+ retry count × cost per round+ sandbox and tool execution overhead
Retry count is often overlooked. A 10-percentage-point lower success rate can increase actual costs by more than 20%.
6. Selection Advice: When to Choose Deep Post-Training and When to Choose a New Base Model
6.1 Decision Checklist
| Dimension | Lean toward deep post-training | Lean toward a new base model |
|---|---|---|
| Task type | Terminal operations, code patches, script writing | Long-cycle refactoring, cross-domain knowledge reasoning |
| Base-model status | The existing base model can run tasks but is unstable | The existing base model frequently fails in critical steps |
| Data conditions | Real business data feedback is available | Data is scarce and general knowledge is more important |
| Team capability | Has post-training and evaluation engineering capabilities | Prefers to use mature capabilities directly |
| Cost structure | Can sustain continuous training investment | Prefers pay-per-call costs |
6.2 Risks of Each Path
Risks of the deep-post-training path:
- High dependence on a specific base-model version. If the base model is updated, post-training results may need to be revalidated.
- Complex environment engineering. It is easy to fall into the trap of “benchmark scores improve, but production experience does not.”
- Training instability may cause investment and returns to become disproportionate.
Risks of the new-base-model path:
- Long delivery cycles make it difficult to respond quickly to business changes.
- If general base-model capability is insufficient, there is limited room for post-training to compensate.
- Inference costs per call are higher, so returns are diluted more slowly in high-frequency scenarios.
6.3 Four-Step Enterprise Implementation
- Define the evaluation set first: Build a baseline with 50 to 200 real tasks, and clarify pass criteria and cost limits.
- Run a small-scale validation: Compare candidate models on 10 to 20 tasks, focusing on stability and cost for terminal-related tasks.
- Use a small-traffic rollout: Integrate the model into real workflows, such as code review assistance or alert triage assistants, and record failure samples.
- Establish an upgrade regression mechanism: Run regression evaluations after every model upgrade to confirm that capabilities have improved and that no regressions have occurred.
7. Conclusion: The Common Goal of Both Paths
“Extreme squeezing without changing the base model” and “a new base model with 3 trillion parameters” may appear opposed, but they are essentially answering the same question: Given limited compute, how can we more quickly improve the real usability of a model?
- The value of the deep-post-training path is that it proves post-training is not just parameter tuning. When the base model still has untapped potential, post-training can become the primary growth engine.
- The value of the new-base-model path is that it raises the capability ceiling. When the base model becomes the bottleneck, a larger and better-designed base model is the route that lifts the ceiling.
For developers and enterprises, the more practical stance is: do not blindly trust parameter scale, and do not underestimate post-training. Build your own evaluation system. Only by measuring with your own business tasks can you determine which path delivers higher returns and whether its costs are acceptable.
