Ultra-Large Open-Source Models Enter the Delivery Era: From Parameter Races to Scenario Delivery
An open-source model with 2.8 trillion total parameters and a 1-million-token context window has arrived, signaling that open-source LLMs are shifting from a parameter race toward scenario delivery. This article examines that shift in practice—how sparse MoE architectures decouple parameter count from compute, why long context demands engineering optimization to be usable, how verifiable-reward reinforcement learning scales task learning across hundreds of domains, and what end-to-end coding and 3D-generation benchmarks actually measure. It also offers a three-stage enterprise adoption path and practical strategies for inference cost, security, and quality control, so readers can turn model capability into stable, measurable delivery.
A recently released open-source model with 2.8 trillion total parameters and a 1-million-token context window remains among the largest open-source models in the world. According to its official documentation, the model shows clear gains on tasks such as code generation, 3D content creation, financial research and analysis, and long-horizon agent execution, with full weights set to be released two weeks later. The announcement quickly drew widespread attention.
Notably, the model also ranks first among open-source models on a third-party composite intelligence leaderboard, and its gap to top-tier closed-source models on capabilities like coding and tool calling has narrowed to single-digit percentage points. The message this release sends to the industry is clear: open-source LLMs are at a critical juncture, moving from a “parameter race” toward “scenario delivery.” But leaderboard scores are not productivity, and parameter scale is not cost control. The real question enterprises must answer is: how do these capabilities translate into stable, reusable, measurable business value?
1. Where the Competition Is Heading: From “How Big the Model Is” to “How Well It Delivers Tasks”
Over the past few years, progress in model capability has been driven largely by scale in parameters and data, and “bigger is stronger” was once the industry consensus. But as the parameter counts of leading models keep climbing, the competitive logic is shifting on three fronts.
1. Architectures are moving from dense to sparse, so parameters and compute are no longer a simple equation. A new generation of trillion-parameter models generally adopts a Mixture-of-Experts (MoE) architecture: the total parameter count includes a large number of expert networks, but only a small subset is activated per token. As a result, the compute required for a single inference is no longer linear in the total parameter count. MoE has two direct consequences: first, memory capacity demand remains high; second, the hardware configuration for serving is determined more by memory capacity and memory bandwidth than by raw compute. For enterprises and developers, this means that selection should account for total parameters, activated parameters, and the memory footprint required for deployment, rather than fixating on the “trillion” figure alone.
2. The capability focus is shifting from “generating text” to “completing tasks.” Models are evolving from conversational tools into agentic executors that plan tasks, call tools, read and write files, run tests, and self-correct based on feedback. The measure of this capability has changed accordingly: it is no longer just “does the answer sound right,” but “does the code compile,” “does a multi-step task run end to end,” and “can the final deliverable be put to use directly.”
3. Value measurement is shifting from “leaderboard ranking” to “delivery cost.” Take an internal scenario as an example: whether a deep-analysis report can form a closed loop from data collection and cross-validation to a finished draft, or whether a multi-step agent task can complete reliably within a limited token and tool-call budget, directly determines the return on investment.
This trend is especially evident in two directions: code and 3D content generation. I cover each of these capabilities in more detail later in this article.
2. Long Context: From “Fitting It In” to “Making It Useful”
Million-token context is often advertised as “read an entire codebase at once,” but in engineering terms, there is a meaningful gap between “fitting it in” and “using it well.”
First, attention computation and cache overhead grow quickly with context length. The compute for standard attention grows quadratically with sequence length, and during decoding, generating each token requires reading the key-value cache (KV Cache) of all preceding tokens. The cache footprint can be roughly estimated as:
KV cache memory ≈ 2 (K and V) × layers × KV heads × head dimension × sequence length × bytes per element(Mechanisms like GQA that share KV heads can significantly reduce this value)
As an example, with 70 layers, 8 KV heads, a head dimension of 128, and FP16 precision, a 64K-token context requires roughly 17GB of memory for the KV cache alone. In long-context scenarios, memory usage often exceeds the model weights themselves and also squeezes out room for concurrent batching. In practice, additional memory is usually reserved for runtime activations and communication buffers.
Second, attention effectiveness needs dedicated optimization. When the context length far exceeds the training distribution, key information may sit in the middle of the sequence. The common “lost in the middle” phenomenon reduces retrieval accuracy for key information. In practice with retrieval-augmented generation and long-document question answering, it is often more effective to place key information at the beginning or end of the context, split long documents into hierarchical summaries, or replace “load everything at once” with “load in segments plus retrieve on demand,” rather than simply enlarging the context window.
Third, interactive agents are more sensitive to latency and cache reuse. Such tasks typically go through dozens of interaction rounds, each carrying the long context again. If the prefix cannot be reused, the latency and cost from repeated computation accumulate rapidly.
For these problems, engineering has a set of relatively mature optimization techniques, including:
- Chunked prefill: split the prefill of a long context into smaller chunks and schedule them together with decoding requests, avoiding a long input blocking other requests;
- Paged key-value cache management: allocate the cache by pages to reduce memory fragmentation;
- Prefix cache reuse: share cached results for fixed prefixes such as system prompts and project conventions across sessions;
- Sparse or linearized attention: introduce sparse or linear attention mechanisms in some layers to reduce the computational complexity of long sequences;
- Speculative decoding: use a small model to “guess” multiple tokens first, then have the large model verify them in parallel, reducing the number of serial decoding steps.
3. Post-Training and Reinforcement Learning: From “General Alignment” to “Scalable Task Learning”
If pretraining provides the foundation of knowledge and capability, post-training determines the quality of task completion. The official positioning frames the new model as a post-training version of the previous generation: the core change is a substantial increase in post-training compute, along with expanding the scope of reinforcement learning (RL) to hundreds of downstream domains. This approach aligns with the industry consensus of “driving reasoning capability with verifiable rewards.” When the task scope expands from “a few” to “hundreds of domains,” the training infrastructure must be restructured accordingly, with the focus typically on the following four areas.
1. Verifiable rewards: the prerequisite for scaling RL. For tasks whose results can be judged automatically, such as whether code compiles and passes tests, whether a math answer checks out, or the reconstruction accuracy of a 3D model, the reward signal can be objective, cheap, and scalable. It is worth noting that reinforcement learning mainly improves sampling efficiency, optimizes reasoning strategies, and strengthens failure recovery; it cannot conjure up knowledge that was not learned during the pretraining stage.
2. Sandbox infrastructure: the “testbed” for agents. Agents need to execute commands, run tests, and call modeling tools during both training and inference. The sandbox isolates these execution environments and enforces resource quotas on CPU, memory, disk, and runtime, preventing runaway processes from taking down the entire cluster.
3. Long-context inference: “practice the long trajectory in pieces.” A long-horizon agent task can involve dozens of tool calls and an extremely long trajectory. Recomputing from scratch every time becomes prohibitive. Common industry practices include computing and caching history segments in pieces and training only on the new segments; using curriculum learning to gradually increase task length; and bucketing by trajectory length to reduce padding waste.
4. Scheduling systems: keeping compute from sitting idle. RL training alternates between two phases: generating trajectories and updating parameters. If the two are strictly serial, the inference cluster used for generation and the training cluster used for updates take turns sitting idle. The current mainstream approach uses a “unified training-inference” architecture, where the same pool of GPUs plays different roles in different phases, or an asynchronous pipeline that overlaps generation and updates, improving overall cluster utilization.
The following illustrative code for an RL training loop reflects the combined approach of “verifiable rewards + sandbox execution + long-trajectory truncation”:
# RL training loop (illustrative): verifiable rewards + sandbox execution + long-trajectory handlingfor step in range(total_steps):# 1. Sample from a multi-domain task pool; bucket by trajectory length to reduce padding wastetasks = task_pool.sample(batch_size, strategy="length_bucketed")# 2. Generate trajectories in parallel inside isolated sandboxes# - Fixed max turns and timeouts to prevent runaway behavior# - Truncate or summarize trajectories that exceed the context budget, keeping key informationrollouts = rollout_engine.generate(policy=model, tasks=tasks,sandbox=sandbox_pool,max_turns=40, timeout_per_turn=60,context_budget=1_000_000,)# 3. Score with an automated verifier: did it compile, do all unit tests pass, is the task completerewards = [verifier.score(task, traj)for task, traj in zip(tasks, rollouts)]# 4. Group-relative optimization: normalize scores within a group, no separate value network neededadvantages = group_relative_normalize(rewards, group_size=8)# 5. Parameter update: under an async pipeline, weights lagging several versions behind can keep generating new trajectoriesmodel.update(rollouts, advantages, clip_range=0.2)
This approach also has several implementation details worth noting:
- Reward shaping: it can help to add signals such as “stop ineffective exploration early” and “reduce meaningless tool calls.” However, overly strong penalties can make the model overly conservative and cause it to give up too early, so the parameters need to be tuned carefully.
- Sandbox non-determinism: software version drift and network jitter can make the same task produce different results, adding noise to the reward signal. Sandbox images must be versioned and reproducible.
- Data contamination: if evaluation problems leak during training, scores become inflated. The evaluation set must be strictly isolated from the training task pool.
- Training-inference consistency: subtle differences between the training and inference frameworks in numerical precision and sampling strategy can cause real-world behavior to deviate from the values observed during training.
4. Coding Agents: Testing “End-to-End Delivery” with Terminal Benchmarks
Coding is one of the most commercially valuable scenarios for LLMs today. But most traditional code benchmarks focus on “single-file function completion” or “generating a whole block of code at once,” which is clearly different from real development: real developers face large multi-file projects, rely on command-line toolchains, dependency management, version control, and test frameworks, and problems often require multi-step exploration to pinpoint.
Terminal-interaction benchmarks represented by Terminal-Bench 4.0 are designed to close this gap. Models must complete tasks such as building, testing, and debugging in a real or simulated terminal environment, and they must execute commands in an actual Linux environment.
According to public information, K3.1 Pro scored 65.7% on this benchmark, surpassing GPT-6 Astra’s 58.2% and coming within less than one percentage point of Claude Opus 5.5’s 66.4%. K3 scored 55.95% on an internal long-horizon code benchmark at Kimi, and K3.1 Pro improved that to 61.2%, an increase of more than five percentage points.
The value of these benchmarks lies in what they measure: “end-to-end delivery” rather than “local code quality”:
- Environment awareness: whether the model can understand project structure, dependency configuration, and build scripts;
- Multi-step debugging: after a build failure, whether it can read the error, locate the root cause, and iterate on a fix, rather than retrying blindly;
- Long-horizon consistency: dozens of steps into a task, whether it still remembers the original goal and works within the project’s constraints.
End-to-end capability is also used to test models in complex 3D scenarios. According to official demonstrations, K3.1 Pro built an Eastern-mythology celestial palace above a sea of clouds in Unreal Engine 5.8, and separately built from scratch in Godot 4.7.2 a 3D action-adventure game with five exploration areas and a two-phase boss battle. These cases were all completed by the model end to end, spanning multiple stages such as scene construction, gameplay logic, resource management, and build and release.
It is worth noting that the evaluation numbers released officially retain two decimal places, making cross-validation by the technical community easier. Enterprises that want to reproduce such evaluations can borrow from the task organization patterns used in public practice:
{"suite_name": "internal_coding_agent_eval","task_groups": {"terminal_multi_step": ["environment setup and dependency fixes", "build failure localization", "test completion"],"repo_level": ["cross-file feature implementation", "bug fixing", "code refactoring"],"long_horizon": ["build a small service from scratch", "full-stack development of a small tool"]},"repeats_per_task": 3,"scoring": {"primary": "acceptance script pass rate","secondary": ["interaction turns", "token consumption", "runtime"]}}
A phenomenon that is often overlooked in evaluation conclusions is that a model’s ranking can differ across different public benchmarks. One model may come close to top closed-source models on terminal tasks yet still trail by several percentage points on 3D reconstruction benchmarks. Different benchmarks measure different dimensions, and the task difficulty, evaluation methods, and scoring scripts all differ. Therefore, enterprises should base model selection on private evaluation sets that closely match their own business.
5. 3D Content Generation: Procedural Reconstruction and Tool Calling
3D generation is another fast-evolving capability. Its mainstream technical approach can be summarized as “using procedural modeling as an intermediary”: instead of outputting mesh vertices directly, the model generates executable modeling code or scripts, such as Python API calls, and the underlying modeling kernel performs the geometric construction and then exports to a common 3D format. This approach has three notable advantages:
- Editable: the result exists as a parametric script, so designers can change parameters and regenerate rather than face a “black-box mesh”;
- Iterative: rendered results can be fed back to the model as visual feedback, which it uses to correct shape, proportion, and detail;
- Verifiable: whether geometry is closed, whether volume and bounding box are reasonable, and whether the face count exceeds limits can all be checked automatically.
In terms of input form, there are three common types:
- Text descriptions: rely on the model’s understanding of object structure and spatial relationships;
- Sketches: require the model to infer a 3D structure from 2D lines;
- Reference images: usually multi-view renders, requiring the model to infer shape, proportion, and spatial relationships.
The CAD-Recode research proposed by the University of Pennsylvania and others follows a similar idea: first, a vision-language model understands multi-view images and generates CAD code, then a CAD kernel reconstructs the 3D model, and the “code-render-feedback” loop is used to iteratively refine the result.
At the evaluation level, benchmarks such as BenchCAD assess exactly this kind of “multi-view image → CAD code → 3D model” reconstruction capability. According to official data, K3.1 Pro scored 92.7% on BenchCAD with tool use, still trailing Claude Opus 5.5’s 96.2% and GPT-6 Astra’s 95.9% by a few percentage points.
This result is not accidental. Technical analysis has pointed out that a model’s 3D capability relies heavily on tool-calling ability: the model generates procedural modeling code, while geometric computation is handled by a dedicated modeling kernel. Models with stronger pure-code ability tend to achieve better results on 3D reconstruction tasks by leveraging tools. However, procedural reconstruction still has limitations on freeform surfaces, organic shapes, and fine textures; relative to technical approaches such as generative 3D reconstruction and neural radiance fields, it is more complementary than a replacement.
The commercial value of this capability should not be underestimated either. As a rough estimate, a 1% measurement error is amplified to 10 centimeters on a 10-meter bridge component, and would exceed the tolerance range on a precision part at the 0.1-millimeter scale. Therefore, in industrial settings, model-generated results must be reviewed by engineers and validated through simulation before being put to use.
It should be noted that claims circulating in public discussion, such as a model “building a complete 3D scene by itself” or “generating a playable game end to end,” still need to be reproduced and verified in a controlled environment. Reproduction should at least confirm whether external asset libraries were used, whether there was human intervention, and whether the final product runs independently.
Beyond code and 3D, document-intensive industries are also benefiting. Financial research is a case in point: such tasks inherently require long context, multi-source cross-validation, and structured output. Financial reports can run to hundreds of pages, and prospectuses and annual reports are even larger. A model can extract key financial metrics from an ultra-long context, compare data definitions across periods, identify inconsistencies in statements, and produce structured analytical conclusions. But this is only “assistive analysis” and should not be treated as investment advice: data timeliness, definitional differences, and source reliability all require human verification.
6. From Evaluation to Production: An Enterprise Adoption Path and Cloud Support
No matter how capable a model is, it must land in a concrete business to create value. Based on the technical characteristics above, I recommend that enterprises follow a three-stage path: “evaluate first, pilot in small steps, then measure and scale.”
Stage 1: Evaluate first. Identify high-value, high-frequency, automatically verifiable scenarios, such as code assistance, document analysis, report generation, and 3D concept design. Build a private evaluation set of no fewer than 100 cases for each scenario and define the core metrics:
- task completion rate;
- average interaction turns;
- token consumption per task;
- human rework rate.
Stage 2: Pilot in small steps. Pick one or two scenarios with clear pain points for a 4–8 week pilot, running in a “human-in-the-loop” mode where business experts review model outputs, and continuously collect failure cases to feed back into optimization.
Stage 3: Measure and scale. Establish a unified model-serving gateway that handles authentication, rate limiting, routing, caching, and metering in one place; incorporate the private evaluation sets into a continuous integration pipeline so that any change to the model or service configuration automatically triggers regression tests, preventing “an upgrade that causes a regression.”
At the infrastructure level, training trillion-parameter models, running long-context inference, and supporting large-scale agent concurrency all require complete platform capabilities. Baidu AI Cloud provides scheduling and training support for large-scale AI compute through its Baige AI Heterogeneous Computing Platform, while the Qianfan platform provides model development, fine-tuning, and inference services. Together with cloud infrastructure products such as object storage, message queues, logging, and monitoring and alerting, these can help enterprises build a complete pipeline from data management, training, and evaluation to inference serving, reducing the cost of building and operating infrastructure themselves.
7. Cost and Risk Control: Making Every Unit of Compute Pay Off
As capability increases, so do inference costs and potential risks. The following governance strategies apply to the vast majority of LLM applications.
Inference cost control:
- Prefix caching: keep fixed, unchanging content such as system prompts, project conventions, and codebase indexes organized at the front of the context so the prefix cache hits as much as possible;
- Model routing: handle simple tasks (such as format conversion and summarization) with smaller models or rules, and call the large model only for complex reasoning tasks;
- Result caching: apply semantic caching to queries with high determinism and set sensible invalidation policies;
- Output length and turn limits: set a token budget and a maximum number of interaction turns for each task to avoid agents falling into “useless loops”;
- Scheduling optimization: use continuous batching and reasonable batch sizes to balance throughput and latency.
Security and risk control:
- Least privilege: sandboxes should block outbound network access by default, mount the file system read-only, and keep sensitive credentials out of the context;
- Human confirmation for high-risk actions: destructive actions such as deleting data or pushing production changes must be approved by a human;
- Content compliance: outputs need to pass compliance review and data redaction;
- Traceability: keep complete audit logs of the input, tool-call chain, and output for each invocation to meet compliance requirements.
Quality assurance:
- Verifiable output: have the model produce structured results (such as JSON) and validate them with schema checks and business-rule checks in code;
- Idempotent tools: tools called by agents should be idempotent to avoid side effects from repeated execution;
- Evaluation regression: embed the private evaluation sets into the model upgrade process, and judge “whether the new version is better” with data rather than intuition.
Conclusion
From trillion parameters to million-token context, from terminal coding agents to 3D content generation, the capability boundaries of open-source LLMs are expanding at an unprecedented pace. But for enterprises and developers, the real dividing line is not “how strong the model is,” but “whether capability can be turned into stable, controllable, measurable delivery.”
Returning to the judgment at the outset: parameter scale determines the ceiling of capability, while scenario delivery determines the floor of commercial value. At the turning point from a “parameter race” to “scenario delivery,” whoever strengthens the “four cornerstones” of evaluation systems, sandbox infrastructure, scheduling systems, and cost governance first will be able to translate model capability into real productivity faster.
