From Parameter Competition to Scenario Delivery: Post-Training Practices for Large Models
The focus of large model development is shifting from scaling parameters to delivering capabilities in real-world scenarios. This article examines the value and allocation of post-training compute, the expansion of reinforcement learning across multiple domains, end-to-end delivery for long-horizon agents, 3D modeling workflows, and best practices for interpreting evaluation results, engineering implementation, and risk management.
1. From Parameter Competition to Scenario Delivery
In recent years, the primary metric for large model research and development has been parameter scale. As training data, compute power, and architectural design mature, the gains from simply increasing parameters are diminishing. Consequently, the industry’s focus has shifted to two questions: how to reliably convert post-training compute into model capabilities, and whether these capabilities can be successfully delivered in actual business scenarios.
This shift requires technical teams to simultaneously focus on three tracks: model capability, engineering infrastructure, and business implementation. Relying solely on parameter count or a single benchmark score is insufficient to determine if a model can handle specific tasks.
2. The Value and Allocation of Post-Training Compute
Pre-training determines a model’s general knowledge and foundational representations. Post-training dictates its performance in instruction following, tool calling, multi-step reasoning, and task completion. Common post-training stages include supervised fine-tuning, preference optimization, and reinforcement learning.
Whether the investment in post-training compute yields returns depends on three conditions:
- The distribution of training tasks aligns with the target scenario.
- The reward signals accurately reflect task completion.
- The training process maintains stability and efficiency at scale.
In Mixture of Experts (MoE) architectures, the total parameter count determines the model’s capacity ceiling, while the parameters activated per inference determine the single-pass computational cost. These two must be evaluated separately. Reporting only the total parameter count fails to explain inference costs or the model’s performance on specific tasks.
3. Scaling Reinforcement Learning Across Domains
The challenge of scaling reinforcement learning (RL) from a few tasks to hundreds of downstream domains lies in the scalable construction of environments and rewards. Each domain requires independent task definitions, success criteria, and execution environments.
3.1 Reward Design
Verifiable rewards are suitable for tasks with clear success criteria, such as coding, mathematics, and structured output (e.g., test pass rates or format validation). Open-ended tasks typically rely on scoring models or human preference data, which are more expensive and less stable. In practice, both types of rewards are often combined, with periodic sampling checks to detect biases in scoring models.
3.2 Task Environments and Sandboxes
Coding tasks require isolated execution environments. Sandboxes should restrict network access, file system permissions, and single execution duration to prevent unauthorized read/write operations or resource exhaustion during training. The input, output, and exit status of each execution should be logged for post-mortem debugging.
3.3 Infrastructure Reconstruction
Large-scale reinforcement learning imposes three main infrastructure requirements:
- Long-context inference: Long sequences amplify the memory footprint of key-value caches, necessitating paging management and on-demand garbage collection.
- Training efficiency: Sampling and parameter updates should be asynchronous to minimize device idle time.
- Scheduling systems: Task durations vary significantly across domains, requiring queue allocation based on priority and resource needs.
Below is a conceptual structure for task registration and reward calculation, intended for illustrative purposes:
from dataclasses import dataclassfrom typing import Callable@dataclassclass TaskSpec:name: strprompt_builder: Callable[[dict], str]verifier: Callable[[str, dict], float] # Returns a reward between 0 and 1timeout_s: int = 300def run_rollout(policy, task: TaskSpec, sample: dict) -> float:prompt = task.prompt_builder(sample)output = policy.generate(prompt)return task.verifier(output, sample)
Adding a new domain only requires implementing the corresponding prompt construction and verification functions, keeping the main training pipeline unchanged. This separation helps control maintenance costs.
4. Long-Horizon Agents and End-to-End Delivery
Long-horizon tasks involve multi-step planning, repeatedly reading environmental states, calling tools, and correcting errors. When evaluating such tasks, the focus should be on whether the final deliverable runs and meets the requirements, rather than whether individual steps appear correct.
End-to-end delivery acceptance criteria typically include:
- The project structure is complete, and dependencies can be installed successfully.
- The build and run processes do not encounter fatal errors.
- Each functional point passes automated testing individually.
- Configuration, documentation, and requirement specifications are consistent.
An illustrative evaluation framework is shown below, where the execution function represents a hypothetical sandbox interface:
def evaluate_project(workdir: str, checks: list[str]) -> dict:results = {}for cmd in checks:code, log = run_in_sandbox(cmd, cwd=workdir, timeout=600)results[cmd] = {"passed": code == 0, "log_tail": log[-2000:]}passed = sum(r["passed"] for r in results.values())return {"score": passed / len(checks), "details": results}
Scoring based on individual check items makes it easier to locate issues than holistic scoring, and facilitates regression comparisons after model iterations.
5. 3D Modeling: From Description to Usable Model
Generating 3D models based on text descriptions, sketches, or reference images typically involves the following pipeline:
- Input understanding: Identifying the object’s category, shape, proportions, and spatial relationships.
- Code generation: Translating geometric information into parametric modeling code.
- Execution and validation: Running the modeling code, generating multi-view renders, and comparing them with the input views.
- Iterative refinement: Modifying the code based on errors or consistency scores until requirements are met.
There are three key points in this pipeline. First, a single reference image only provides partial geometric information; dimensions and constraints must be explicitly inferred by the model or supplemented by the user. Second, the generated modeling code must be executable, and failed runs should return error messages for the next correction iteration. Third, leveraging external tools to obtain geometric feedback usually reduces the error between the generated result and the input, as tools provide verifiable intermediate results.
Illustrative code:
def reconstruct_model(views: list[bytes], spec_text: str, max_iters: int = 3):code = llm_generate_cad_code(spec_text, views)mesh = Nonefor _ in range(max_iters):ok, mesh, err = execute_cad_code(code)if not ok:code = llm_fix_code(code, err)continuescore = multiview_consistency(mesh, views)if score > 0.9:return meshcode = llm_refine_code(code, score)return mesh
Here, execute_cad_code and multiview_consistency are hypothetical helper functions; their actual implementation depends on the modeling kernel and rendering method used.
6. How to Properly Interpret Evaluation Results
Evaluation metrics are easily misinterpreted, commonly in the following scenarios:
- Comprehensive benchmark scores are derived by weighting multiple sub-tasks; the composition and weights of each sub-task should be examined.
- Internal benchmarks are usually closer to actual business scenarios, but their results cannot be directly compared with public benchmarks.
- Overlap between training data and test sets (data contamination) will inflate scores; undisclosed or regularly updated test sets should be used.
- Results with tools enabled and disabled represent different settings and should not be compared in the same table.
- Single-run results have inherent randomness; the mean and variance of multiple runs should be reported.
7. Engineering Implementation Recommendations
- Clearly define deliverables, translating “whether the task can be completed” into automatically verifiable check items.
- Conduct phased evaluations in a limited scope first, and expand coverage only after confirming stability.
- Set resource and permission limits for sandboxes, and retain logs and artifacts for each execution for auditing.
- For cost-sensitive scenarios, comprehensively compare activated parameter count, context length, and response latency, rather than just looking at the per-call price.
- Establish a fixed regression test suite that must be re-run after any model version or prompt updates.
8. Risks and Precautions
- Generated code and modeling results require manual review before production use.
- A long context does not guarantee that the model can accurately utilize all the information within it; critical information should be confirmed via retrieval or segmentation.
- The copyright and licensing of training data and generated content need separate verification.
- When automatically executing generated code, default to the principle of least privilege, and restrict network and file access.
