Breakthroughs in Post-Training Techniques: Enhancing LLM Code and 3D Creation Capabilities

I. Background: Post-Training as the Key Path for Model Capability Evolution

In recent years, the evolution of large language models (LLMs) has shifted from a sheer parameter scale race to refined capability polishing centered around “post-training.” Post-training refers to the process of enhancing a model’s abilities in specific task domains after the base model has completed pre-training, utilizing methods such as supervised fine-tuning, reinforcement learning, rejection sampling, and preference alignment. The technical investment in this phase often determines a model’s usability and cost-effectiveness in real-world production environments.

A recently released next-generation post-trained model has achieved significant leaps in two vertical domains: code generation and 3D modeling. Its core approach is not simply scaling up parameters, but conducting deep post-training optimization based on previous versions. This substantially enhances the model’s performance in terminal tasks, structured script writing, and spatial reasoning. This article will analyze these advancements from three dimensions: code capabilities, cost control, and 3D creation practices, providing reusable engineering recommendations for developers.

II. Code Capabilities: Dual Optimization of Terminal Task Performance and Cost

2.1 Terminal Task Benchmark Performance

In the realm of code generation, Terminal Bench is a critical benchmark for measuring whether a model can perform complex operations in a real command-line environment. This benchmark requires the model to understand system-level concepts such as file systems, process management, package dependencies, and environment variables, and to generate executable Shell scripts or command sequences.

According to public benchmark data, this post-trained model scored 65.7 on Terminal Bench, securing a leading position among domestic models and falling only slightly behind top-tier international closed-source models. Notably, this score was achieved without relying on external toolchain orchestration, indicating that the model’s understanding of the terminal environment and its code generation capabilities have been internalized.

For developers, this means that in daily scenarios like writing automation scripts, configuring CI/CD pipelines, and server maintenance, they can directly describe their requirements in natural language. The model then generates high-quality command-line scripts, significantly reducing the cost of manually looking up documentation and debugging.

2.2 Cost Control: Cost-Effectiveness Among Frontier Models

Beyond performance metrics, cost is a practical factor highly scrutinized by enterprises and developers. In the Terminal Bench evaluation, this model was identified as one of the most cost-effective solutions among frontier models. Although some lightweight models have lower per-call costs, their task completion rates and output quality exhibit noticeable gaps, leading to higher comprehensive costs.

From an engineering perspective, the key to cost control lies in the “first-time pass rate.” If a model-generated script requires repeated corrections to run, the overall consumption will rapidly escalate, even if a single call is cheap. The high pass rate of this model in terminal tasks grants it a superior comprehensive cost advantage in actual production workflows.

2.3 Developer Practice Recommendations

In practical usage, developers are advised to adopt the following pattern:

# Example: Generating a deployment script via natural language
# Input prompt:
# "Write a bash script that checks all .log files in a specified directory,
#  archives them by date to /archive/YYYY-MM-DD/, and compresses logs older than 7 days"
# Simplified model output example:
#!/bin/bash
LOG_DIR="/var/log/app"
ARCHIVE_DIR="/archive"
TODAY=$(date +%F)
mkdir -p "$ARCHIVE_DIR/$TODAY"
find "$LOG_DIR" -name "*.log" -type f -exec mv {} "$ARCHIVE_DIR/$TODAY/" \;
find "$ARCHIVE_DIR" -name "*.log" -mtime +7 -exec gzip {} \;

The generation quality of such scripts directly dictates the efficiency of operations automation. It is recommended to introduce a human review step for critical tasks and manage the model-generated scripts using version control tools.

III. 3D Modeling and Spatial Reasoning: From Script Generation to Full-Chain Creation

3.1 Dimensions of 3D Creation Enhancement

The model’s enhancements in 3D modeling are primarily reflected in three aspects:

• 3D Creation Capability: Ability to generate construction scripts for 3D geometry based on natural language descriptions.
• Spatial Reasoning Capability: Understanding the relative position, rotation, scaling, and hierarchical relationships between objects.
• Tool Script Writing: Directly generating script code tailored for professional modeling tools without relying on middleware protocols.

In CAD-related benchmarks, the model scored 92.7 points when utilizing tools, demonstrating outstanding performance among open-source models and further narrowing the gap with top-tier international closed-source models.

3.2 Direct Script Writing: Eliminating Middleware Dependencies

Traditionally, integrating LLMs with 3D modeling tools often requires relying on MCP (Model Context Protocol) or other middleware protocols, where an intermediate layer translates natural language instructions into API calls recognizable by the tool. While flexible, this approach increases system complexity and latency.

The capability enhancements of this model allow developers to directly write modeling tool scripts (such as Blender’s Python API or CAD system macros) to construct and refine assets. The model understands core concepts like the modeling tool’s object model, material system, and geometric operations, generating directly executable script code.

Below is an illustrative example of modeling script generation:

# Example: Generating a Blender modeling script via natural language
# Input prompt:
# "Create an indoor forest scene in an airport: the ground is a light wood grain material,
#  evenly distribute 20 trees ranging from 2-4 meters in height, with semi-transparent green canopies,
#  and a soft point light array at the top"
import bpy
import random
# Clear default scene
bpy.ops.object.select_all(action='SELECT')
bpy.ops.object.delete()
# Create ground
bpy.ops.mesh.primitive_plane_add(size=50)
ground = bpy.context.active_object
ground.name = "Ground"
# Create wood grain material
mat_ground = bpy.data.materials.new(name="WoodFloor")
mat_ground.use_nodes = True
bsdf = mat_ground.node_tree.nodes["Principled BSDF"]
bsdf.inputs["Base Color"].default_value = (0.76, 0.60, 0.42, 1.0)
ground.data.materials.append(mat_ground)
# Generate trees
for i in range(20):
    x = random.uniform(-20, 20)
    y = random.uniform(-20, 20)
    height = random.uniform(2.0, 4.0)
    bpy.ops.mesh.primitive_cylinder_add(
        radius=0.15, depth=height, location=(x, y, height/2))
    trunk = bpy.context.active_object
    trunk.name = f"Tree_Trunk_{i}"
    bpy.ops.mesh.primitive_uv_sphere_add(
        radius=random.uniform(0.8, 1.5),
        location=(x, y, height + 0.5))
    crown = bpy.context.active_object
    crown.name = f"Tree_Crown_{i}"

This script generation capability allows 3D content creators to focus more on creative ideation and aesthetic control, leaving repetitive modeling operations to the model.

3.3 Online Preview and Editing: A Full-Chain 3D Creation Loop

The model’s capabilities have been synchronized with online platforms, offering online preview and editing features for 3D content. Users can directly view the 3D scenes generated by the model in their browsers and make real-time adjustments. Completed models support various output formats:

• 3D Printing: Export standard format files to interface directly with 3D printing equipment.
• Video Export: Render the 3D scene into a video file for content sharing.
• Dynamic Photos: Export as an interactive dynamic image format, suitable for mobile sharing scenarios.

This full-chain loop significantly shortens the path from “natural language description” to “deliverable 3D content,” providing significant efficiency boosts for independent creators, small studios, and educational scenarios.

IV. Engineering Implementation Recommendations and Considerations

4.1 Security Boundaries for Script Generation

When using the model to generate modeling or terminal scripts, the following principles are recommended:

• Sandbox Execution: Run model-generated scripts in an isolated environment to prevent unintended impacts on production systems.
• Version Control: Incorporate generated scripts into version control tools like Git for easy tracing and auditing.
• Parameter Validation: Manually review sensitive parameters in scripts, such as file paths, network addresses, and system commands.

4.2 Adaptation Strategies for 3D Creation Scenarios

• Phased Generation: For complex scenes, break down requirements into multiple phases: “geometry construction -> material assignment -> lighting setup -> camera configuration,” generating and validating step by step.
• Asset Reuse: Save common components generated by the model (like trees, fixtures, furniture) as templates for rapid scene assembly later.
• Performance Considerations: Pay attention to polygon counts and texture resolutions when generating scripts to avoid export models being too large, which can cause rendering or printing failures.

4.3 Balancing Cost and Performance

For high-frequency code generation tasks, combine caching mechanisms with batching strategies to reduce redundant calls. For 3D modeling tasks, since the content generated in a single call is relatively complex, explicitly state the output format and precision requirements in the prompt to avoid extra costs from repeated corrections.

V. Conclusion

The continuous evolution of post-training techniques is transforming LLMs from “general-purpose conversational assistants” into “vertical domain productivity tools.” In code generation, the simultaneous optimization of terminal task performance and cost control brings automated script writing into a practical phase. In 3D creation, direct script writing capabilities and full-chain tool integration are lowering the barrier to 3D content production.

For developers, understanding the model’s capability boundaries and engineering implementation methods is more critical than solely focusing on benchmark scores. It is advisable to start with small-scale pilots in actual projects, progressively accumulating prompt templates, script review standards, and cost monitoring mechanisms, ultimately forming a reusable intelligent creation pipeline.