3-Trillion-Parameter Open-Source Model: A Technical Leap in Long-Horizon Agents and Professional Tool Calling

1. The Open-Source Scale Ceiling Rises Again

The open-source large model landscape has seen another round of scale breakthroughs. A research team recently released a new-generation open-source model with 3 trillion parameters and support for a 1-million-token context window, keeping it at the top of global open-source models by parameter count. Compared with the 2.8-trillion-parameter version released in July, the new version maintains its scale lead while shifting the focus toward “intelligence density”—the effective reasoning and execution capability carried per unit of parameters.

From an industry perspective, the release signals two key things. First, the capability gap between open-source models and leading closed-source models is narrowing rapidly, with overall intelligence now approaching the world’s leading closed-source models. Second, the inference cost advantage is substantial: at a comparable capability level, the calling price is roughly two-thousandths (about 0.2%) of mainstream closed-source offerings, opening new possibilities for cost-sensitive scenarios such as high-frequency calls and long-horizon tasks.

Note that the complete model weights are planned to be available for download about two weeks after the announcement. Developers will then be able to deploy the model themselves for internal R&D or embed it into end-user-facing products, under a fairly permissive license.

2. The Core Mechanism Behind the Capability Leap: Targeted RL Compute Investment

The most substantive change in this version compared with its predecessor is not the marginal increase in parameter count, but the large increase in compute devoted to the reinforcement learning (RL) stage. This design choice deserves developers’ attention, because it reveals an important path for improving current large model capabilities.

2.1 From a “Smart Brain” to “Agile Hands”

Traditionally, scaling up parameters mainly boosts a model’s static knowledge capacity and language understanding. RL-driven training, by contrast, focuses on building policy optimization that “gets smarter with practice” through repeated training across hundreds of domains. In engineering terms: the former expands the knowledge base, while the latter trains an executor that can invoke knowledge, plan steps, and verify results.

Specifically, on top of strong base reasoning ability (the “brain”), the model further develops professional tool-calling capability (the “hands”). This combination enables it to complete longer, multi-step complex tasks—exactly the core demand of long-horizon Agent scenarios.

2.2 Quantified Reference Points

On an authoritative intelligence index ranking, the previous model in this series already placed fourth globally and first among open-source models. The new version reaches or approaches the strongest closed-source models on coding, Agent, and knowledge benchmarks. The following sections break this down by scenario.

3. Long-Horizon Coding: From One-Shot Generation to Continuous Iterative Improvement

The coding gains in the new version are concentrated in two dimensions: professional tool use and long-horizon iteration.

3.1 Synergy with Professional Design and Development Toolchains

The model can proficiently call professional design and development tools, combining web search and 3D generation to deliver artifacts with complete interactive experiences. For web pages and games, the output shows clear improvements in composition, layout, animation effects, and overall completeness. This means the model no longer merely “writes a code snippet”—it can organize a runnable, experiential deliverable end to end.

3.2 RL-Enhanced Long-Horizon Coding

A representative internal test is worth a closer look: researchers asked the model to build a system that simulates human walking. The task involves controller design, simulation experiments, result analysis, problem localization, and parameter correction—naturally long-horizon, multi-step, and iterative.

The model’s execution flow was roughly as follows:

Initialization: build the simulation environment and walking controller
Iterative loop:
  1. Run the simulation and collect walking stability data
  2. Analyze failure modes (e.g., falling within the first few steps)
  3. Locate root causes (e.g., joint torque allocation, muscle moment arm calculation deviations)
  4. Correct controller parameters and calculation logic
  5. Retrain the controller and validate
Termination condition: sustained walking time meets the target and error terms converge

In this test, the model pushed the simulated human body from falling within the first few steps to taking alternating steps and walking continuously for 11.2 seconds. Along the way, it fixed 36 errors in the shoulder muscle moment arm calculations and retrained the controller. The value of this case lies in what it demonstrates: not the accuracy of a single code generation, but the sustained execution of an “analyze—locate—fix—verify” loop, which is precisely the core difficulty of long-horizon coding tasks.

4. 3D Creation: From Semantic Understanding to Printable Assets

In 3D content creation, the model demonstrates a fairly complete capability chain:

• Input parsing: accepts a text description, a sketch, or a reference image as input;
• Spatial inference: infers an object’s shape, proportions, and spatial relationships;
• Tool operation: directly operates professional modeling software to generate usable models;
• Scene assembly: further organizes outputs into complete interactive scenes;
• Post-processing: supports online preview and editing; finished assets can be downloaded directly for 3D printing.

Applicable targets include mechanical parts, architectural models, custom furniture, and other categories with demanding structural and proportional requirements. For developers, the engineering significance is a lower threshold from “idea to usable asset,” especially in scenarios that require rapid prototype production.

5. Financial Research: An End-to-End Delivery Paradigm for Complex Tasks

Financial research is a typical scenario for testing long-horizon Agent capability, because it inherently requires multi-source information integration and rigorous data verification. In this scenario, the new version can complete task chains that include:

1. Retrieving materials and summarizing information;
2. Cross-document data consistency checks;
3. Building financial models;
4. Running target screening and profitability analysis;
5. Delivering complete results end to end.

In two public benchmarks covering office and spreadsheet tasks, the model achieved the world’s best results, surpassing multiple mainstream closed-source models. This outcome shows that on structured data processing and document-intensive tasks, open-source models are already competitive head-to-head with leading closed-source solutions.

6. Practical Recommendations for Developers

Based on these capability characteristics, here are several implementation-level suggestions:

First, prioritize evaluating gains on long-horizon tasks. The model’s differentiated advantage is sustained execution and self-correction on multi-step tasks. Use tasks that “require several iterations to converge” as your evaluation set, rather than relying solely on single-turn QA benchmarks.

Second, watch how the context window and tool calling work together. The 1-million-token context provides room for long-document analysis and multi-turn tool calls, but pay attention to retrieval precision and cost control over long contexts. Combine engineering techniques such as segmented summarization and key-information indexing.

Third, adapt RL-trained capabilities to your scenarios. The policy optimization produced by RL training performs best in specific domains. In actual deployment, you can build small-scale feedback loops around your business domain to further unlock the model’s potential.

Fourth, plan deployment sensibly. Once the weights are open, choose between local deployment and cloud hosting based on data compliance requirements. For cost-sensitive, high-frequency calling scenarios, the cost structure of open-source deployment is usually more advantageous.

7. Conclusion

From 2.8 trillion to 3 trillion parameters, and from static knowledge capacity to RL-driven execution capability, this generation of open-source models has shifted its evolution logic from “scaling up” to “training capability.” Measured performance in long-horizon coding, 3D creation, and financial research shows open-source models moving from “usable” to “genuinely good to use,” approaching or even matching leading closed-source models on some professional tasks. For developers and enterprises, it is worth re-evaluating the role of open-source solutions in complex Agent workflows—they may no longer be just a cost-saving alternative, but a capability-equal, viable choice.