Meituan’s LongCat-2.5 weight release, reported on November 15, 2026, gives developers a downloadable, MIT-licensed model built for long-running agent tasks and coding. Meituan describes it as a mixture-of-experts model with roughly 1.6 trillion total parameters, about 48 billion active per token, and training conducted entirely on Chinese-made hardware. The weights are available through the official Hugging Face repository, with the specifications and hardware claims detailed in The Decoder’s November 15 coverage.
The practical distinction here is between access and deployability. Developers can obtain the checkpoint and modify it under permissive terms. Running it still involves terabytes of model files, a distributed serving system and some unresolved differences between the headline specifications and the downloadable configuration.
My view is that those deployment details are more useful than the trillion-parameter headline. They show where this release creates a real option for developers, and where an API remains the more practical route.
What Developers Can Download
The LongCat-2.5 repository provides the model weights and accompanying configuration and tokenizer materials under the MIT license. Data Phoenix reports that the main checkpoint occupies approximately 3.56 TB, distributed across 208 numbered Safetensors shards.
MIT licensing permits commercial use, modification and redistribution, subject to its notice requirements. That gives infrastructure providers and model developers substantial freedom to adapt the release. It does not, by itself, supply the training data or everything needed to reproduce Meituan’s training process.
The November 15 date needs one qualification. It is the date of The Decoder’s weight-release report, following the model’s earlier unveiling. Data Phoenix had already described public weights on November 13 and recorded weight-upload commits from November 4 and 5. Upload history alone cannot establish when files first became publicly accessible, so the exact first-public date remains unsettled. This is coverage of the downloadable-weights release, not a new architecture announcement.
Meituan also offers hosted access. According to The Decoder, its API supports OpenAI- and Anthropic-style formats and integration with agent harnesses including Claude Code, Codex and Hermes. That offers a route to evaluation without first assembling a large accelerator cluster.
The Published Specifications Need Two Readings
LongCat-2.5’s model-card specifications describe the product’s intended capabilities. The downloadable configuration and checkpoint metadata describe a more specific deployment artifact. Developers should keep both in view.
A November 16 examination by Sillectus reports two consequential differences:
| Detail | Headline or Hosted Specification | Downloadable Artifact |
|---|---|---|
| Total parameters | Approximately 1.6 trillion in the model card | Approximately 1.78 trillion in Safetensors metadata |
| Active parameters | Approximately 48 billion per token | Active count does not describe total storage requirements |
| Context length | Up to 1 million tokens through the API | Configuration lists 524,288 maximum positions |
| Maximum output | Up to 128,000 tokens through the API | The hosted limit should not be assumed for a local deployment |
| Input and output | Text, images and video in; text out | Configuration includes visual and video components |
The parameter discrepancy is unexplained in the available model-card account. The roughly 1.78-trillion figure comes from checkpoint metadata, not a revised official headline specification. It would be premature to assign the difference to a particular component without a documented breakdown.
For capacity planning, however, the actual files matter more than the rounded model name. An unexplained counting difference is a reason to inspect the checkpoint before reserving hardware.
The context distinction is equally practical. The Decoder reports a one-million-token API window, while Sillectus identifies 524,288 positions in the downloadable configuration. A hosted service can use a deployment setup that differs from a published checkpoint. Developers should therefore treat the configured value as the documented starting point for self-hosting, unless Meituan supplies instructions supporting a larger window.
Neither figure guarantees useful recall across every token. Context capacity describes how much material a system can accept; evaluating whether an agent reliably uses that material is a separate task.
Agent and Multimodal Support Extend Beyond Chat
Meituan positions LongCat-2.5 for multi-step coding work, complex codebases, project construction, visual design and 3D-related tasks. It accepts text, images and video, while generating text. Those are Meituan’s stated capabilities, reported by The Decoder, rather than independently established performance across those workflows.
The public repository contains useful integration details. Its chat template handles image and video references, tool calls, tool results and separate reasoning content. It also defines an enable_thinking option that defaults to false in the template.
Those details matter when connecting the model to an agent framework. A serving stack needs to preserve the expected message structure, including tool-call identifiers and returned tool results. Passing everything through as undifferentiated text risks losing information the template explicitly represents.
Tool support also needs an execution layer. The model can produce a request to call a function, but the surrounding application must provide that function, validate its arguments, execute it and return the result. Image and video markers similarly do not replace the necessary media-processing path.
I would evaluate that integration before judging the model on a long coding assignment. Correct message handling, restricted tool permissions and a working sandbox are prerequisites for a meaningful agent comparison. The security stakes are concrete, as Zeniteq’s related coverage of AI agents turning patches into exploits illustrates.
Chinese Hardware Is Central to the Deployment Story
Meituan says LongCat-2.5 was trained entirely on Chinese-made hardware. Its published deployment example uses 194 Huawei Ascend accelerators from the Atlas A2 series, according to The Decoder’s account of the self-hosting guide.
The example divides the cluster into three groups:
- Two accelerators handle image processing.
- 64 accelerators handle prompt ingestion, commonly called prefill.
- 128 accelerators handle response generation, or decoding.
That separation reflects different inference workloads. Prefill processes the supplied context; decoding repeatedly generates the next token. Assigning hardware separately lets an operator provision those stages independently.
The 194-chip configuration is a published example, not an established minimum requirement. It also does not reveal the training cluster’s size or the cost of serving a particular workload.
The reported public guide provides no Nvidia deployment instructions. That leaves Nvidia-based developers without a documented path in these materials; it does not prove that a port is impossible.
The training-hardware statement remains Meituan’s claim. The deployment guide adds specificity to the Chinese-accelerator story, but it is not an independent audit of training. Its competitive significance is nevertheless clear: Meituan is publishing a model and a serving approach aligned with an alternative accelerator ecosystem.
Why 48 Billion Active Parameters Still Means Terabyte Storage
A mixture-of-experts model routes each token through only part of its network. LongCat-2.5’s advertised 48 billion active parameters are about .
Frequently Asked Questions
3 questions
1Can LongCat-2.5 Be Used Commercially?
Yes. The weights use the MIT license, which permits commercial use, modification and redistribution, subject to its notice requirements.