Meituan LongCat-2.5 Open Source: From Seeing, to Arriving

Author: Meituan Tech Team

Meituan officially open-sourced LongCat-2.5 under the MIT license, supporting commercial inference deployment and retraining without additional authorization.

Model open source: https://huggingface.co/meituan-longcat/LongCat-2.5

LongCat-2.5 is a native multimodal model for long-horizon agent tasks. Its end-to-end delivery capability has improved notably in complex codebase development, full project construction, visual coding, and professional office scenarios. The model has 1.6 trillion total parameters, activates approximately 48 billion parameters per token, and supports a one-million-token context. Targeting domestic AI accelerator chips with limited memory and bandwidth, we have also carried out deep collaborative optimization in model architecture, chip adaptation, and deployment strategy.

For complete scores and evaluation conditions, see the technical blog

01 Code and Long-Range Agents

LongCat-2.5's long-range capability improvements come from extending the entire training chain, not a single point change. These designs do not change the definition of model capabilities, but they allow capabilities to perform stably across long tasks.

First, training data closer to real long-range tasks. More long-range trajectories are added, and failure trajectories from real agents are converted into reproducible and verifiable training tasks.

Second, reinforcement learning better adapted to long-task pacing. Partial rollout asynchronous training is adopted, so unfinished long tasks can be saved and continued later; the oversampling rate is dynamically adjusted based on pass rate, and groups of all-correct or all-wrong samples are filtered out; gradient correction is applied to stale trajectories across checkpoints to reduce staleness bias.

Third, training constraints that more effectively reduce "gaming the system." The task environment is disconnected from the network, git history and file caches are cleared, and an LLM judge supervises trajectories; constraints are applied to repeated thinking, repeated tool calls, and excessive thinking, so the model focuses on completing tasks.

Check developers' end-to-end evaluation examples to observe the model's performance in real usage flows.

02 Visual Coding and 3D

LongCat-2.5 performs well in visual coding, supporting creative design, 3D, and other tasks. These capabilities come from a revamp of the visual representation layer: the model represents visual signals as multi-level discrete tokens, processed uniformly by the backbone model like text, rather than as an external visual module. Specifically, the model performs residual vector quantization on native-resolution visual features, adding detail level by level; visual tokens can be precomputed and cached offline, reducing online computation and balancing distributed training loads; the visual codebook and backbone are trained jointly, with visual and text sharing the same backbone parameters, jointly completing visual understanding and code generation in the same semantic space.

Check developers' end-to-end evaluation examples to observe the model's performance in real usage flows.

03 Professional Office and Business Analysis

Professional office scenarios do not require point-by-point Q&A but rather completing several things at once: reading multiple materials, capturing key information, forming professional judgment, and converting that judgment into standardized, usable deliverables. LongCat-2.5's improvements in this scenario also revolve around this chain: more robust material processing, professional judgment closer to an analyst's, end-to-end delivery of reports, presentations, and office tools, and more reliable multi-turn execution. The goal is not to model each scenario separately, but to enable the mainline model to complete professional office tasks end-to-end.

Supporting these improvements is a set of mutually coordinated technical designs. Multi-expert online teaching integrates domain capabilities into the mainline model: the student answers independently first, then the expert corrects its probability distribution via full-vocabulary KL divergence; teacher responses are split into fixed-length chunks to control distribution shift; prefill and KV cache are shared during sampling; Tree Attention is used during training to process samples in the same group via a single forward and backward pass. Large-scale agent reinforcement learning improves long-range execution and tool-calling capabilities; mixed training across tasks and scaffolds enhances generalization; native visual understanding supports visual content generation in PPTs and reports; long-context rollout optimization supports efficient operation of long-range reinforcement learning.

Click to view LongCat-2.5 real end-to-end generated demos.

04 Efficient Inference

Inference efficiency is the key to whether a model can truly land. LongCat-2.5 uses a W4A4 efficient inference scheme, quantizing both expert weights and activations to 4 bits, and performing computation through native INT4 matrix multiplication units.

In terms of precision, we optimize MoE quantization accuracy based on FlatQuant's learnable equivalent transformations; evaluated downstream task performance remains comparable to before quantization. For operators and data paths, expert-shared input transformations complete quantization before token replication and distribution, so the same INT4 representation runs through expert communication and computation; transformation, scale calculation, quantization, and packing are fused into dedicated operators, combined with weight layout and transpose access optimization to reduce data movement and conversion overhead. At the system level, for Prefill's batch-heavy computation and Decode's per-token advancement and communication, we separately optimize the overlap of computation and communication pipelines to reduce waiting. W4A4 allows LongCat-2.5 to lower inference cost while maintaining downstream task performance, providing a usable efficiency foundation for open-source deployment of a 1.6-trillion-scale MoE model.

05 Domestic Computing Power

LongCat-2.5 uses long-sequence training in both training and supervised fine-tuning stages. In domestic computing-power environments, single-card memory is below 80GB, a realistic constraint that long-sequence training and fine-tuning must face.

We use sharding to spread memory pressure across multiple cards in a supernode, topology-aware parallel strategies to reduce cross-node communication overhead, and keep communication and computation overlapping as much as possible. Specifically, FSDP dual sharding and flattened buffers reduce resident and peak memory; hybrid vocabulary parallelism further compresses memory occupancy; parameter AllGather, expert token AllToAll, and KV AllGather are performed as much as possible within the high-bandwidth interconnect domain of the supernode; MoonEP dynamic expert replication is only enabled when load imbalance reaches a threshold, avoiding communication overhead that exceeds its benefits; zero-copy communication, parameter prefetching, and ScMoE enable communication and computation to overlap.

The engineering value of this approach: long-sequence training and fine-tuning are achieved on domestic AI accelerators with less than 80GB per-card memory; when scaling to multiple cards, mechanisms handle communication overhead and load imbalance. This FSDP configuration improves single-card throughput in long-sequence SFT tasks by 86% compared to the DDP baseline, showing that long-sequence training is not only feasible but efficient on domestic computing power, providing a reference infrastructure path for community reproduction and secondary development.

06 Open Source and Openness

LongCat-2.5 is open-sourced under the MIT license, supporting commercial inference deployment and retraining without additional authorization. We chose this license because we want the model to be freely used, modified, and redistributed, and to make it easier for the community to keep working on top of it.

Domestic computing power is a direction we invest in long-term and a site for continuous innovation. The boundaries of memory and bandwidth actually exist; what we can change is architecture, operators, and parallel strategies. Changes are in the details, progress is in the concrete. Carrying a trillion-parameter MoE on less than 80GB of single-card memory requires repeated trade-offs among architecture, quantization, parallelism, and communication. These trade-offs were made together with industry partners, giving us a more concrete judgment about this path.

Ecosystem maturity rarely comes from a single breakthrough. It requires continuous testing under real loads, chips, frameworks, and applications being polished in the same place, and someone willing to put the hardest tasks on it first. We will continue to open-source models and engineering experience, working with peers to widen this path.

• Model open source: https://huggingface.co/meituan-longcat/LongCat-2.5
• Technical blog: https://longcat.ai/blog/longcat-2.5/
• API platform: https://longcat.chat/platform/product

| Follow the "Meituan Tech Team" WeChat account (meituantech) or visit: https://tech.meituan.com/ for more technical articles! |

| This article is produced by the Meituan Tech Team, and the copyright belongs to Meituan. For non-commercial purposes such as sharing and communication, you may repost or use the content, but please credit "Content reprinted from Meituan Tech Team". Without permission, commercial reposting or use is not allowed. For any commercial use, please email [email protected] to request authorization. |