Hands-On With China's Massive MoE Model: Near-Flagship Performance at One-Fifth the Inference Cost

A “Blind Test First, Claim Later” Release — and What It Signals

A Chinese AI team recently released a large model with roughly 3 trillion total parameters, officially positioned as “the most capable model the company has shipped to date.” Alongside the standard version, it launched a high-speed variant with an identical intelligence level but 2–3x faster output. The context window reaches 1 million tokens, with native support for visual understanding.

More interesting to developers than the parameter count is the release path: before its official debut, the model was evaluated anonymously under a codename on third-party benchmark platforms, where developers could test it blind. Its identity was only claimed at launch. This “enter the arena anonymously, take the hits, then step forward” flow is the exact reverse of the traditional “publish a technical report first, then ship the product.”

The shift matters for practical reasons. Anonymous blind testing strips away brand bias: scores come entirely from real callers’ experience and task pass rates. For users, that is more informative than a vendor’s self-reported benchmark suite; for the vendor, it doubles as a low-cost stress test in real-world scenarios. Expect this “validate anonymously first, announce officially later” pattern to show up more often in how Chinese models iterate.

Three Trillion Parameters Doesn’t Mean Three Trillion in Cost: Doing the MoE Math

First, clarify what the parameter count means. The 3 trillion figure refers to total parameters. The model uses a Mixture of Experts (MoE) architecture — according to public reports, roughly 2.8 trillion total parameters, of which only about 104 billion are activated per inference.

That distinction is the key to its cost advantage. In a traditional dense model, every parameter participates in every forward pass. MoE instead uses a routing mechanism to assign each token to a small number of “experts,” leaving the rest dormant. As a result:

• Memory footprint scales with total parameters (expert weights still need to be loaded or sharded across devices);
• Compute consumption scales with activated parameters (only a small fraction runs per inference);
• Inference cost is therefore far below that of a dense model with the same total size.

A simplified sketch of the routing logic (pseudocode, for illustration only):

# Pseudocode: sparse activation in a MoE forward pass
def moe_forward(token_repr, experts, router, top_k=2):
    # 1. Routing scores: pick the best-matching experts for each token
    scores = router(token_repr)            # [num_experts]
    topk_idx = top_k_indices(scores, top_k)
    # 2. Activate only the top_k experts; the rest stay idle
    outputs = []
    for idx in topk_idx:
        outputs.append(experts[idx](token_repr))
    # 3. Merge expert outputs weighted by routing scores
    return weighted_sum(outputs, scores[topk_idx])

This logic explains how “3 trillion parameters” and “low price” can coexist: total parameters set the capability ceiling, activated parameters set the per-inference cost, and the architecture decouples the two. But there are trade-offs. MoE places heavier demands on memory bandwidth, expert-parallel communication, and load balancing (preventing a handful of experts from being overwhelmed). The engineering complexity is not trivial. The low price isn’t free — it’s paid for with architecture.

Benchmark Breakdown: Where the Gap Has Truly Closed — and Where It Hasn’t

Officially published benchmark results are as follows (values are percentages or scores, for horizontal comparison only):

Benchmark	This model	Closed-source flagship A	Closed-source flagship B
Terminal operation tasks	65.7%	58.2%	66.4%
Long-horizon software engineering	51.7%	42.5%	46.3%
Comprehensive agentic evaluation	43.2	32.8	42.6
3D reconstruction tasks	92.7%	95.9%	96.2%

Taken item by item, the picture can’t be summed up as “beats everything”:

First, terminal operations and agentic tasks are clear strengths. Terminal operation tasks test a model’s stability across multi-step command execution and environment interaction; the comprehensive agentic evaluation is closer to “holding it together over long task chains.” Leading on both suggests targeted optimization in tool calling, multi-turn planning, and error recovery — precisely the engineering-oriented capabilities developers use most.

Second, the advantage in long-horizon software engineering is substantial. Benchmarks in this category typically require cross-file modifications within a sizable codebase, with dependency awareness and consistency maintained throughout. A 51.7% vs 46.3% gap can translate into “one or two fewer rework cycles” in practice. Combined with the 1M-token context window — which lets the model ingest a mid-sized repository in a single pass and avoids context fragmentation caused by repeated retrieval — these scores have solid support.

Third, 3D reconstruction still lags noticeably. 92.7% vs 96.2% is a 3.5-point gap. These tasks demand extremely precise spatial reasoning and faithful reproduction of visual detail, indicating that deep multimodal understanding still trails top closed-source models. It’s a reminder that having vision capability and having production-grade vision capability are two different things; scenarios involving fine-grained spatial judgment need additional validation.

Fourth, the gap to the strongest closed-source models has narrowed to single-digit percentage points. Across these benchmarks, the difference is on the order of 0.7 percentage points (benchmarks weight differently; this is a magnitude description only). That puts the model in the “viable substitute” range for most general tasks, while the hardest edge cases still call for task-specific canary testing.

One-Fifth the Price: Where the Confidence Comes From

The price advantage stacks up across three layers:

1. Architecture: sparse activation pushes per-inference compute down to the activated-parameter level — the most fundamental cost lever;
2. Engineering: the high-speed version’s inference optimizations raise output speed 2–3x, increasing throughput per unit of time and amortizing the per-token serving cost;
3. Strategy: low pricing buys call volume and real-world feedback, which in turn feeds iteration — the same philosophy as the anonymous blind testing.

Developers should stay clear-eyed, though: a low unit price is not the same as a low total cost. What you should calculate is “cost per completed task,” not just “price per million tokens.” If the model needs more retries, longer prompts, or more frequent human review on complex tasks, the real spend can exceed that of a nominally pricier option. Run A/B comparisons on real business samples and track “comprehensive cost per successful task” as the metric.

Deployment Advice: What to Adopt First, What to Hold Back

Based on the analysis above, a scenario-by-scenario read:

• Good candidates for early adoption: repository-level code understanding and cross-file edits, terminal command orchestration, multi-step agent workflows, and mixed document-and-screenshot understanding. These map directly to its benchmark strengths, and the million-token context window significantly reduces the engineering burden of chunking and retrieval.
• Proceed with careful validation: high-precision 3D reconstruction, fine-grained spatial reasoning, and any scenario with zero tolerance for visual detail errors. A 3.5-point gap may be invisible in a demo yet amplified in production.
• Always run canary testing: any scenario involving long-chain autonomous decisions should include human fallback and rollback mechanisms. Benchmark scores represent average capability — not performance on your business distribution.

One final caution: the numbers in benchmark tables are measured by the vendor under specific conditions. Prompt templates, toolchain wrappers, and sampling parameters all affect results. Treat benchmark scores as a qualification threshold, and treat regression testing on your own business data as the hiring bar. This latest super-large Chinese MoE model has genuinely tipped the capability-versus-price balance one notch further in developers’ favor — but whether it works for you, and whether it’s worth it, still comes down to your own test suite.