A New Ultra-Scale MoE Flagship Model: Specs, Benchmarks, and Agent Coding Practice
A new ultra-scale MoE flagship model combines 2.8 trillion total parameters, about 104 billion active parameters, a 1M-token context window, and native vision, alongside a faster, higher-priced tier. This article breaks down its specs, explains how its capability gains come from heavier post-training, and reads its Terminal-Bench and long-horizon coding scores. It then covers million-token context engineering, six practices for shipping long-horizon coding agents, cost-optimization and model-routing strategies, and what to prepare before deploying the open weights privately.
In late October 2026, a Chinese team launched a new generation of ultra-scale MoE flagship model, together with a high-speed version released the same day. Based on the public information, the main focus of this update is not larger parameter counts, but three shifts:
- Heavier post-training investment: Larger-scale post-training and reinforcement learning are used to close the gap in agent execution and long-horizon task capabilities.
- A split product lineup: The high-speed version handles interactive scenarios, while the standard version handles long-horizon offline tasks.
- Openness moved forward: The plan to release weights was announced first, and license details are to be clarified gradually.
Developers face a direct question: how should you prioritize parameter count, context length, native vision, the high-speed version, and open weights? Can high scores in terminal coding and long-horizon tasks translate into results in your own business scenarios? This article starts with a breakdown of the specs, then examines where the capability gains come from, what the benchmark scores mean, agent engineering, and cost and model selection. It ends with an action list.
1. Specs at a Glance: Understand the Numbers Before Comparing Models
| Dimension | Specification | Key takeaway |
|---|---|---|
| Architecture | Mixture of experts (MoE); 2.8 trillion total parameters, ~104 billion active (marketed as a “3-trillion-class” model) | Total parameters set capacity; active parameters set compute cost |
| Context window | 1M tokens | Suited to whole-codebase analysis, long documents, and long conversations; pair with compression and retrieval |
| Multimodal | Native vision; accepts text and image input | Handles screenshots, charts, interfaces, and design mockups directly |
| High-speed version | Comparable intelligence to the standard version; ~2–3x output speed; ~2x the price | Built for latency-first scenarios; weigh against actual value |
| Availability | Web, mobile, office suite, coding tools, open APIs | Individuals and teams can migrate in stages |
| Open weights | Weights to be released in early November; license not yet announced | High value for private deployment, but check the license terms first |
1. Total parameters and active parameters are two different ledgers. This generation’s iteration changed only the post-training investment substantially. Total parameters are unchanged from the previous generation (released in July 2026, 2.8 trillion). When reading parameter counts, distinguish two kinds of overhead:
- Total parameters determine the model’s capacity ceiling. They correspond to the GPU memory or RAM the deployment needs, because all model weights must be resident.
- Active parameters determine the actual compute per inference. Only about 104 billion parameters take part in the forward pass per token, so latency and per-request inference cost depend mainly on this part.
As a result, a “trillion-scale parameter count” does not mean trillion-scale compute consumption. In long-context scenarios, attention compute also grows quadratically with context length, and the KV cache expands linearly with concurrency. When evaluating a model, look at both per-call cost and concurrent capacity and time to first token.
2. A large context window must be paired with engineering practices. 1M tokens is roughly equivalent to several million Chinese characters, or a small-to-medium-sized codebase. But the longer the window, the greater the attention overhead and KV cache, and the model may also use information in the middle of very long inputs less effectively. So a long context window does not mean you can feed every long task in at once. Context engineering techniques such as retrieval, chunking, and summarization remain necessary (see Section 4).
3. Native vision means a unified input interface. The model understands images directly, so the business side no longer needs to maintain a separate vision pipeline for screenshots, charts, or scanned documents. In scenarios such as financial research, charts in research reports and screenshots of financial tables can go straight to the model for interpretation. In frontend and creative work, UI screenshots and design mockups can serve directly as the basis for revisions. However, this only solves “being able to see.” For precise values, you still need calculation or validation tools as a safety net.
4. The high-speed version is essentially a trade of cost for latency. At the same level of intelligence, output speed increases 2–3x and the price is about 2x that of the standard version. A rough estimate of the unit latency cost per output token puts the high-speed version at about 0.67–1x the standard version. In other words, if the faster speed delivers enough value, the unit latency cost may stay level or even drop. Common acceleration techniques include speculative decoding and model distillation, which typically come at the cost of extra compute or storage. Whether the high-speed version is worthwhile depends on whether your business is “waiting for people to read” or “waiting for machines to run”:
- In chat Q&A, real-time code completion, and similar scenarios, a response that is one second slower directly hurts the experience, so the value of speed is clear.
- In batch code generation and offline long-horizon tasks, no one is waiting at the screen. As long as total throughput is sufficient, the standard version usually offers better cost-performance.
2. Where the Capability Gains Come From: Heavy Post-Training and Multi-Domain Reinforcement Learning
The most notable aspect of this upgrade is that total parameters stayed the same while capabilities improved markedly. This indicates that the main source of the gains is the post-training stage, specifically two changes:
- Substantially more post-training compute: More compute is invested on the same foundation model, powering larger-scale supervised fine-tuning and preference optimization.
- Reinforcement learning extended to hundreds of downstream domains: Feedback signals are expanded from “whether the answer is appropriate” to “whether the task is actually completed.”
The technical logic behind this is to replace human preference ratings alone with verifiable feedback. Coding, 3D creation, financial research, and long-horizon agents all happen to be tasks whose success or failure can be judged by objective signals:
- Code can be judged as passing or failing through compilation and unit tests.
- 3D scenes can be judged against render output, geometry, and material checks.
- Financial analysis can be validated against real data.
- Agent tasks can be judged by whether the final state meets the goal.
By practicing repeatedly in domains with these feedback loops, the model learns execution capabilities: decompose the goal, call tools, check intermediate results, and correct errors. This goes beyond fluent expression at the text level. The direct implications for developers are:
- This generation’s gains are most pronounced on tasks that can be verified automatically.
- If your scenario cannot produce a clear verification signal, you will still need to compensate with prompt design, workflow orchestration, and human review.
3. Reading the Benchmarks: What Terminal Coding and Long-Horizon Code Scores Tell Us
3.1 Terminal Coding: Real Environments, Limited Resources, Test-Driven
On Terminal-Bench 4.0, the model’s score jumped to 65.7%. That is higher than two comparable closed-source flagship models, which scored 58.2% and 66.4%, and the gap to the latter has narrowed to 0.7 percentage points.
This type of benchmark has three defining characteristics, which are also why it is worth attention:
- Tasks are completed in a terminal close to a real development environment, such as fixing a broken build, resolving dependency conflicts, or writing automation scripts.
- Tasks run in resource-constrained environments, so the model must make trade-offs within limited compute and permissions.
- Every task comes with dedicated tests, and the criterion is whether the tests actually pass, not whether the answer looks reasonable.
This maps to the core capabilities of agentic coding: completing multi-step operations autonomously under real constraints, with passing tests as the finish line. According to third-party data, the model also ranks among the leaders in the distribution of score versus cost per task, which means stronger capability does not necessarily mean higher cost. The capability gap between closed-source flagships and smaller open-source models is narrowing, making engineering implementation and cost control the deciding factors.
3.2 Long-Horizon Code Tasks: The Gain Is “Staying on Track”
On a long-horizon code benchmark (Kimi Code Bench 3.0 Long-horizon), this generation scored 61.2%, compared with 55.95% for the previous generation on the same foundation model. That is an improvement of more than 5 percentage points. Note that this long-horizon benchmark is vendor-built, so cross-generation comparisons within it are more meaningful than cross-vendor comparisons.
The difficulty of long-horizon tasks lies not in whether the model can handle a single step, but in whether it can:
- remember the original goal after many steps;
- get back on track after hitting errors along the way;
- avoid continuing to “work hard” in the wrong direction.
An improvement of more than 5 percentage points suggests that the model’s stability and self-correction in multi-step reasoning are improving. For tasks such as refactoring, batch fixes, and going from requirements to implementation, this stability often matters more than the ability to solve isolated problems.
3.3 Case Insights: Complex Tasks Rely on Combining Tools
The vendor’s long-horizon engineering showcases include:
- Using a real-time 3D creation engine to build an Eastern-mythology-style game scene.
- Calling procedural modeling tools to generate 3D assets.
- Layering in multiple rounds of editing and render iteration.
Together, these cases point to one conclusion: complex creative tasks do not depend on “generating a perfect result in one pass,” but on “model + toolchain + multiple rounds of iteration.” The coding agent is only the orchestrator in this pipeline; the rendering engine, modeling tools, and validation scripts form its “hands and feet.”
3.4 There Is Still a Gap Between Scores and Your Business
Benchmark scores only indicate a baseline; they cannot replace business-specific evaluation:
- Benchmark tasks are fairly generic and cannot cover your coding standards, internal frameworks, and business constraints.
- Vendor self-testing and third-party data may differ in methodology.
- If your business data overlaps heavily with public corpora, scores may also be inflated.
The right approach is to build your own evaluation set (see Section 7). Measure the model’s value with your own metrics, such as task pass rate, rework rate, and human intervention rate.
4. Engineering with a Million-Token Context: Organize in Layers, Don’t Feed Everything at Once
A 1M-token window changes how long tasks are engineered: entire codebases, multi-turn conversations, and long documents can all fit in the context at once. In practice, however, three principles apply.
1. Organize the context in layers. Manage it across three tiers: stable, semi-stable, and dynamic.
- Stable layer: System prompt, output format constraints, coding standards. Keeping this prefix stable improves prefix-cache hit rates and reduces redundant computation.
- Semi-stable layer: Architecture notes, key API documentation, design decision records. These switch with the task.
- Dynamic layer: Code snippets relevant to the current task, retrieval results, tool outputs, and error logs.
2. Retrieval and chunking are still necessary. The “lost in the middle” phenomenon with very long contexts is a widely discussed concern in the industry, and overly dense information also drives up costs. A more reliable approach is to use keyword or vector retrieval to locate relevant snippets first and then let the model reason over them. For long documents, summarize first and follow up on specific details.
3. The toolchain for long tasks must be auditable. When a single context cannot hold all the information, tool-call logs themselves serve as traceable “external memory.” The following is sample code for the main loop of a long-horizon agent:
MAX_STEPS = 40COMPACT_EVERY = 12 # Compact into a summary every 12 completed stepsdef run_long_task(task, model, tools, memory):for step in range(1, MAX_STEPS + 1):prompt = memory.build(task, recent=8) # Keep only the last 8 turns of raw interactionsaction = model.plan(prompt, tools=tools) # The model decides the next actionif action.type == "finish":return verify(task, action.result) # Automatic verification decides completionresult = tools.run(action) # Executed with restricted permissionsmemory.append(step, action, result)if step % COMPACT_EVERY == 0:# Compress early interactions into a structured summary: goal, completed, outstanding, key decisionsmemory.compact(model)return {"status": "max_steps_reached", "memory": memory.snapshot()}
This code reflects three key points:
- Cap the number of steps: Prevent the agent from looping indefinitely in the wrong direction and keep costs under control.
- Compact memory: Replace raw conversation history with structured summaries.
- Explicit acceptance criteria: Completion is decided by verification results, not by the model claiming it is “done.”
5. Putting Long-Horizon Agents into Production: Six Engineering Essentials
Stronger models are only a prerequisite. Whether a long-horizon agent can be deployed reliably depends on the engineering system built around it.
1. Make tasks verifiable. Turn vague requirements into acceptance conditions that can be checked automatically:
# Example: In a restricted sandbox environment, automated checks serve as the agent's acceptance criteria# 1) The build must pass# 2) All unit tests and newly added regression tests must pass# 3) Static checks must report no new warnings# 4) Contract tests for key APIs must passrun_build && run_unit_tests && run_regression_tests && run_static_checks && run_contract_tests
The more objective the acceptance criteria, the more easily the model can correct itself within the feedback loop.
2. Apply least privilege and sandbox isolation. Terminal agents have permissions that make them both powerful and risky. Run them in isolated containers, restrict filesystem access and outbound network traffic, and require human confirmation for high-risk actions such as deletion, deployment, and writes to production environments.
3. Design tools for idempotency and observability. Tool interfaces should be idempotent and return clear error codes on failure. Logs should include the tool name, a summary of inputs, duration, and result status, making it easy to trace why something failed. Here is an example of a well-formed error response:
{"ok": false,"tool": "run_tests","error_code": "TIMEOUT","message": "Test execution exceeded the 30-second limit","retryable": true,"trace_id": "req-20261024-0001"}
4. Build in human collaboration and checkpoints. For long-horizon tasks, set checkpoints by phase (plan approval, changes to critical files, before commit) and have people confirm key decisions. Save a rollback-able version at every step so that when an error occurs, the task can return to the most recent stable state.
5. Set cost budgets and routing rules. Set limits on steps, tokens, and spend for each task, with automatic degradation or handoff to a human when exceeded. Treat “failure” as a normal path: when the budget runs out, preserve intermediate artifacts so a person can take over.
6. Ensure observability. Record the full trace of every task, including the model version, prompt version, per-step latency and token usage, and tool-call results. Only then can online issues be traced from “the model is not good enough” to “which part of the workflow went wrong.”
6. Cost Optimization: Standard vs. High-Speed Versions and Task Routing
Cost optimization starts with measurement. Begin by answering four questions:
- How many tokens does a single task consume?
- How high is the retry rate?
- What is the first-attempt success rate?
- How high is the human intervention rate?
On that basis, you can take four measures:
- Trim prompts: Remove redundant instructions and keep the prefix format stable.
- Use prefix caching: Keep the system prompt and fixed context stable to reuse the cache and reduce redundant computation.
- Trim inputs: Deduplicate retrieved snippets and truncate tool outputs to the necessary fields.
- Batch asynchronously: Send non-real-time tasks through batch APIs and schedule them for off-peak hours.
Finally, add tier-based routing: send simple tasks to smaller, faster models, standard tasks to the flagship model, and reserve the high-speed version for latency-sensitive interactive scenarios. The following is sample routing logic:
def choose_mode(task) -> str:# Illustrative logic; adjust thresholds based on business evaluation and cost budgetsif task.kind == "chat" and task.estimate_tokens < 8000:return "fast" # Short Q&A: prioritize latencyif task.requires_vision or task.steps > 10:return "standard" # Multimodal/long-horizon tasks: standard version balances cost and throughputif task.in_batch_pipeline:return "standard" # Batch tasks: no one is waiting, so prioritize cost controlreturn "small" # Simple tasks such as formatting and classification: use a lightweight model
Beyond routing, you can further increase throughput on top of the standard version with techniques such as speculative sampling and batching. These are general-purpose inference optimizations, not specific to any one model.
7. Open Weights: Three Things to Confirm Before Private Deployment
According to the vendor’s plan, the full model weights are due to be released before November 4, while the license has not yet been announced. For industries sensitive to data leaving their premises, such as finance, manufacturing, and government and public sector organizations, the value of open weights is clear:
- Data stays on the internal network, meeting compliance requirements.
- The model can be further fine-tuned on business-specific data.
- The inference process is fully controllable and easy to audit.
However, privately deploying a trillion-scale parameter model is not lightweight:
- Memory threshold: MoE models need all expert parameters resident in GPU memory. At common precisions, trillion-scale parameters require on the order of several terabytes of memory, typically demanding multi-GPU, multi-node deployments.
- Engineering cost: High-concurrency inference requires inference engine optimizations such as expert parallelism, paged attention, and continuous batching. KV cache management is especially critical for long-context scenarios.
- Iteration pace: Hardware and inference frameworks evolve quickly. Validate business results through open APIs first, then assess the return on private deployment.
Before the license is announced, teams can prepare three things in advance:
- License review: Have legal and security teams assess the license type in advance and clarify the boundaries for commercial use, modification, and redistribution.
- Evaluation set preparation: Assemble a business evaluation set so you can run a baseline as soon as the weights are released.
- Compute budgeting: Estimate memory and hardware needs based on concurrency and context length.
Cloud platforms such as Baidu AI Cloud (service availability and pricing vary by region) provide mature, general-purpose approaches for this kind of work:
- Use a container platform for elastic scaling of inference services.
- Use object storage to centrally manage weights and evaluation data.
- Use monitoring and alerting services to track latency, failure rates, and token consumption.
- Use logging services to retain audit records.
8. Action List: A Timeline to Follow
Near term (start now)
- Request access to the open APIs and run a small-scale evaluation with 10–20 real business tasks, focusing on the completion and rework rates of long-horizon tasks.
- Review your existing agent toolchain and fill gaps in sandbox isolation, idempotency, error codes, and logging.
- Assess the value of the high-speed version with A/B comparisons in interactive scenarios, tracking changes in user satisfaction and task completion rates.
Mid term (around the weight release in early November)
- Complete the license review and compute estimates, and define the scope of the private deployment pilot.
- Stand up inference services, evaluation pipelines, and monitoring on a cloud platform to close the “evaluate–deploy–rollback” loop.
- Build a business evaluation set and version your prompts and model configurations so each iteration’s results can be compared.
Long term
- Establish a model routing and cost control mechanism that assigns tiers by task type.
- Make verifiability and observability of long-horizon agents part of your architecture baseline.
- Keep tracking model iterations and keep the evaluation set in sync with the model.
Conclusion
In terms of specs, this generation of ultra-scale MoE model has a clear profile: total parameters are unchanged, capabilities are improved through heavy post-training investment, input formats are expanded with native vision, latency-sensitive scenarios are served by the high-speed version, and private deployment needs are addressed with open weights. In terms of benchmarks, its agentic coding capability in terminal environments has reached the same tier as comparable closed-source flagships, and the stability of long-horizon code tasks continues to improve.
For developers, the real dividing line is not whether to adopt the new model, but the engineering capability built around it: whether tasks can be verified clearly, whether the toolchain is secure and auditable, whether costs are measurable and controllable, and whether results are backed by your own evaluation set. Whoever gets these four things right can turn model capability into lasting business value.
