Practical Approaches to LLM Post-Training and Code Agent Advancements

Over the past six months, the competitive focus in the large language model (LLM) domain has shifted from “who has the largest base parameters” to “who has the most robust post-training and comprehensive toolchains.” A notable trend is that certain new model versions have achieved generational leaps in key metrics such as general intelligence, code generation, and terminal tasks without expanding their parameter scale, while also significantly reducing API prices. This reflects an industry-wide reevaluation of compute allocation and agent engineering. This article deconstructs the underlying logic behind this capability leap from a technical perspective and provides actionable implementation references.

1. The Technical Rhythm: Base Models Set the Ceiling, Post-Training Determines the Delivery

Reviewing the evolution over recent months, a clear “build the skeleton first, then forge the capabilities” path emerges:

Phase	Technical Action	Core Objective
Phase 1	Release of ultra-large parameter open-source base models	Validating foundational engineering capabilities like operator optimization and compiler principles
Phase 2	Iteration of desktop intelligent coding tools	Integrating command-line capabilities into a GUI; embedding browsers, visual annotation, and plan/goal dual modes
Phase 3	Anonymous models participating in blind arena tests	Verifying new version lineage through community fingerprint comparison
Phase 4	Release of the master post-trained version	Committing to fully open weights and reducing API prices by about one-third

This timeline reveals a critical judgment: The base model determines the capability ceiling, while post-training determines how well that capability is realized. Although the first-generation ultra-large base models performed well in certain niche scenarios, their pass rate on terminal task benchmarks—which test real-world command-line fundamentals—was only about 13%. This indicates that parameter scale does not automatically translate into engineering usability. The missing piece is “reinforcement learning oriented towards real-world task distributions.”

2. Why “Compute over Parameters” is a Pragmatic Choice

Many vendors perform routine fine-tuning when releasing their “.1” versions. However, versions that deliver generational improvements typically undergo joint reinforcement learning (RL) retraining. The technical logic can be broken down into three points:

1. Parameter Scaling Hits Diminishing Marginal Returns

Once base parameters reach the trillions, the unit compute yield from further scaling decreases significantly. Conversely, allocating equivalent compute to the post-training phase, especially multi-domain joint RL, directly optimizes the model’s performance on real-world tasks.

2. Post-Training Requires “Task Environments,” Not “Static Corpora”

The effectiveness of reinforcement learning relies heavily on environment quality. A mature code agent toolchain provides an ideal training ground:

• Sandbox environments: Safely execute generated code and verify correctness.
• Terminal tools: Simulate real command-line operations, covering the file system, process management, package installation, etc.
• Browser tools: Support web information extraction and interaction, bridging gaps in visual understanding.
• Plan/Goal dual modes: Enable the model to learn long-period task decomposition and state tracking.

3. Joint RL Spans Over a Hundred Domains to Avoid “Over-Specialization”

Single-domain RL often leads to performance degradation in other tasks. Joint RL uses multi-domain mixed sampling to maintain a balance across code, math, logic, terminal operations, and visual annotation tasks, ultimately achieving significant progress in general intelligence indices.

3. Engineering Essentials for Code Agents: Terminal, Vision, and Long-Period Planning

From a developer’s perspective, the most intuitive manifestation of this capability leap is the reinforcement of code agents in the following three dimensions.

1. Terminal Tasks: From “Writing Code” to “Running Commands”

Terminal task benchmarks test real-world command-line fundamentals, such as:

• Locating and fixing build scripts in unfamiliar directories;
• Using package managers to install dependencies and resolve version conflicts;
• Combining commands via pipes for log analysis.

These tasks require the model to not only understand individual commands but also possess state tracking and error recovery capabilities. By introducing terminal environments during the post-training phase, models learn stable strategies like “check the directory structure first, then execute operations” through trial and error.

# Example: Common decision chain for a model in terminal tasks
ls -la
cat package.json
npm install
npm test
# If it fails, roll back and adjust dependency versions based on the error message

2. Visual Annotation: Enabling Models to “Read” UIs

Visual annotation capabilities within graphical interfaces allow models to understand the position and semantics of UI elements like buttons, input fields, and tables. This is crucial for automated testing, web data extraction, and desktop application operation. After introducing visual annotation tasks in post-training, models can combine screenshots with DOM structures to generate more accurate interaction actions.

3. Long-Period Agents: Plan and Goal Dual Modes

Long-period tasks often require dozens or even hundreds of steps. The plan/goal dual mode allows the model to both decompose high-level goals and maintain low-level execution plans. For example:

• Goal mode: The user provides a high-level objective like “fix the CI failure in this repository.”
• Plan mode: The model automatically generates a plan: “check CI logs -> locate failed test cases -> modify code -> verify locally -> commit,” updating the state after each step.

This capability demands higher standards for RL reward design: feedback must evaluate not only the final result but also the rationality of intermediate steps.

4. Cost Structure Changes: Implications of a One-Third API Price Reduction

A roughly one-third reduction in API prices means that for developers and enterprise users:

1. High-frequency invocation scenarios become viable: Such as code completion, unit test generation, and log analysis.
2. Marginal costs for long-period agents decrease: The total cost of multi-step reasoning and tool invocation becomes more controllable.
3. Pilot projects scale to production more easily: Budget is no longer the primary bottleneck.

Combined with the improvement in general intelligence indices (an increase of about 11 points from the initial version, ranking among the global top tier), this represents a “capability up, cost down” combination, offering substantial benefits to the developer ecosystem.

5. Best Practices: Maximizing Post-Trained Code Agents

1. Define Task Boundaries and Leverage the Toolchain

• For terminal tasks, prioritize executing and verifying the model in a sandbox; avoid direct operations in production environments.
• For visual annotation tasks, provide clear screenshots or DOM structures to reduce ambiguity.
• For long-period tasks, use plan mode to let the model output a step list first; execute only after human confirmation.

2. Build a High-Quality Feedback Loop

Although post-trained models are powerful, they still require human feedback to align with specific business standards. Recommendations include:

• Recording model failure cases and regularly compiling them into new evaluation sets.
• Setting up human review nodes for critical tasks.
• Utilizing the model’s plan mode to output intermediate states for easier issue localization.

3. Prioritize Open Weights and Local Deployment

With fully open weights, enterprises can deploy on their own infrastructure, integrating general cloud capabilities like container platforms, object storage, and logging services to build private code agent services. This satisfies data compliance requirements and further amortizes costs through scaled invocations.

6. Conclusion

The greatest insight from this round of model evolution is not that “bigger parameters are better,” but rather that post-training quality and toolchain completeness determine a model’s actual productivity. By utilizing joint RL across over a hundred domains and combining it with engineering capabilities like terminal operations, visual annotation, and long-period planning, models can achieve generational improvements without expanding parameter scale. For developers and enterprises, this means lower trial barriers and a higher ceiling for task automation. Moving forward, those who refine their post-training and toolchains most effectively will likely dominate the code agent track.