Native Agentic LLMs from China: Architecture, Training, and Deployment Considerations
This article examines the publicly disclosed architecture, training pipeline, reasoning modes, evaluation claims, and deployment considerations of a flagship native agentic model released by a Chinese vendor in July 2025. It explains how mixture-of-experts design and configurable thinking modes affect model selection, highlights the limits of vendor-reported benchmarks and pricing data, and provides practical guidance for choosing between full and lightweight variants in production. All figures and claims are based on public vendor materials and should be verified against the latest official technical report and model card.
1. Why Native Agentic LLMs Matter
Over the past two years, large language models have evolved through roughly three stages. Early systems focused primarily on conversational question answering. They were followed by initial attempts at tool calling. More recently, the focus has shifted toward completing an end-to-end loop within a single task: planning, reasoning, coding, tool use, and result verification.
A common approach is to train a conversational model first and then add agent capabilities through external modules. This can lead to fragmented behavior. For example, a model may perform well in conversation but call tools inconsistently, or it may reason effectively but respond too slowly.
To address this problem, some Chinese vendors have proposed the concept of a “native agentic” model. Under this approach, reasoning, coding, and agent capabilities are optimized together during training rather than being assembled after the base model has been trained.
This article uses a flagship model publicly released by one vendor in July 2025 as an example. It reviews the architecture, training process, and deployment information disclosed in public materials. The figures cited here come from vendor publications and have not been independently verified. Before production use, consult the latest official technical report and model card.
2. Separate Data Sources Before Drawing Conclusions
Before evaluating any model, it is important to distinguish between two types of information.
The first type consists of configuration details that can be directly verified, such as model specifications, total parameter counts, and open-source licensing terms. These details should be checked against the official model card or product release page.
The second type includes evaluation and commercial data, such as leaderboard rankings, composite scores, cost ratios, and market share. These figures usually depend on a specific benchmark, sample size, and pricing methodology. If a claim only states that a model “ranked first” without identifying the benchmark, version, and reproduction conditions, it is difficult to use that claim for model selection.
A practical approach is to record the source, publication date, and statistical methodology for each data point. Before making an important decision, validate the result with samples from your own business.
3. Core Architecture: Mixture of Experts and Dual-Mode Reasoning
3.1 Mixture-of-Experts Architecture
The vendor has publicly disclosed two model specifications:
- The full version has approximately 355 billion total parameters and targets complex reasoning and high-accuracy tasks.
- The lightweight version has approximately 106 billion total parameters and targets low-latency, high-throughput services.
The basic idea behind a mixture-of-experts (MoE) architecture is to provide a large total parameter capacity while activating only a subset of the parameters for each inference request. The model contains multiple expert subnetworks, and only some of them are selected during each forward pass. This preserves substantial model capacity while reducing the computation required for an individual request.
Total parameter count does not equal the amount of computation performed during every inference request. When selecting a model, teams should also consider the number of active parameters, context length, deployment hardware requirements, actual throughput, and time to first token. These metrics were not provided in the original materials and should be obtained from the official documentation.
The original materials mention an inference speed of more than 100 tokens per second. However, this figure depends on hardware, concurrency, input and output length, and server configuration. It should not be treated as a universal performance metric.
Likewise, the stated input price of RMB 0.8 per million tokens reflects pricing at a specific point in time. Pricing may change, so current rates should be checked on the official website.
3.2 Thinking and Non-Thinking Modes
The model supports two operating modes, allowing developers to choose based on task complexity:
- Thinking mode: The model performs multi-step internal reasoning before generating an answer. This mode is suitable for complex code generation, multi-tool orchestration, and long-horizon planning.
- Non-thinking mode: The model skips explicit reasoning and generates a response directly. This mode is suitable for everyday conversation, simple retrieval, and text rewriting.
The central trade-off is between reasoning quality and latency or cost. Thinking mode generally takes longer and consumes more tokens. Non-thinking mode responds faster but is more likely to miss steps in multi-stage tasks.
The following is illustrative code. Field names and invocation methods should be verified against the official documentation for the SDK being used. A production implementation should also add authentication, timeout handling, and error classification.
import timedef call_agent(client, messages, thinking_enabled, retries=2, timeout_s=60):mode = {"type": "enabled"} if thinking_enabled else {"type": "disabled"}for attempt in range(retries + 1):try:return client.chat(model="agentic-llm", # Use the model name specified in the official documentationmessages=messages,thinking=mode,timeout=timeout_s,)except TimeoutError:if attempt == retries:raisetime.sleep(2 ** attempt) # Retry with exponential backoff
4. Training Pipeline: Three Stages and Reinforcement Learning
According to the vendor’s public materials, the model was trained on approximately 23 trillion tokens through three stages. The table below summarizes the goal of each stage and the information that still requires verification.
| Stage | Primary objective | Data type | Items requiring verification |
|---|---|---|---|
| Pretraining | Establish language understanding and general-knowledge foundations | Large-scale general corpora, with a higher proportion of code | Data sources, compliance disclosures, and the ratio of different data categories |
| Mid-training | Adapt the model to agentic task patterns | Long-context data, challenging reasoning tasks, and tool-use data | Maximum context length and data-construction methods |
| Post-training | Align instruction following, tool-call formats, and safety requirements | Supervised fine-tuning data and reinforcement-learning signals | Reward design, evaluation standards, and safety policies |
For reinforcement learning, the vendor states that it uses an internally developed framework. The framework supports large-scale parallel rollout sampling, configurable reward functions, and coordination between the training and inference engines.
This direction is consistent with a common industry approach to improving performance on multi-step tasks. However, assessing whether the model remains stable over long task sequences requires details such as the specific reward functions, rollout scale, and the coordination mechanism between training and inference. The public materials provide limited information on these points, so this article does not speculate about them.
5. Capability Claims: How to Interpret Evaluation Results
Evaluation results are often used as a basis for model selection, but each claim should be checked individually.
- Coding capability: The vendor states that the model ranks among the leading systems in the coding category of a third-party model arena. The name of the leaderboard, evaluation version, and statistical date should be verified.
- Tool use: The vendor states that, in an evaluation conducted in September 2025, the model outperformed an international flagship model in tool-use capability and provided a cost comparison. The original materials do not specify the benchmark, sample size, or cost-calculation method, so this article does not use the reported ratio.
- Hallucination control: The vendor states that the model performed well in a hallucination evaluation for retrieval-augmented generation. The leaderboard name, evaluation date, and sample size should be verified.
For enterprise applications, a more reliable approach is to build a test set from the organization’s own knowledge base. Teams can then measure the proportion of answers that conflict with their sources and report results separately by question type.
In terms of ecosystem support, the model weights have been released in open-source form and integrated into several AI coding tools. The specific license terms should be checked against the official release. Before commercial use, confirm whether modification, redistribution, and commercial deployment are permitted.
6. Model Selection: Full Version, Lightweight Version, and Operating Modes
The table below provides scenario-based recommendations. Latency and cost are relative ratings; actual values must be measured in the target environment.
| Scenario | Recommended combination | Latency | Cost | Failure fallback |
|---|---|---|---|---|
| Complex multi-step agent tasks, such as long-horizon planning and multi-tool orchestration | Full version + thinking mode | High | High | Set a maximum step count; return intermediate results or escalate to a human after a timeout |
| Complex code generation and debugging | Full version + thinking mode | High | High | Run unit tests; return error messages to the model and retry once if necessary |
| High-volume online services, such as customer support, classification, and summarization | Lightweight version + non-thinking mode | Low | Low | Fall back to rules or cached results, and record low-confidence samples |
| Simple retrieval and text rewriting | Lightweight version + non-thinking mode | Low | Low | Validate the output format and use a fixed template if validation fails |
| Medium-complexity tasks where cost must be controlled | Lightweight version + thinking mode | Medium | Medium | Conduct spot checks on critical steps |
A practical selection process is to begin with the lightweight version and non-thinking mode for simple, high-volume workloads. Use the full version or thinking mode only when task complexity, reasoning depth, or reliability requirements justify the additional latency and cost. All final decisions should be based on tests conducted with representative business data and the latest official model information.
