Meituan open-sources LongCat-2.5, a 1.6T-parameter agent model trained without Nvidia
Meituan, the Chinese food delivery giant, has released the weights of its agent model LongCat-2.5 under the MIT license. The 1.6-trillion-parameter model was trained entirely on Chinese chips. That same fact means most developers can't realistically run it themselves for now.
What's going on
Meituan, China's largest food delivery service, has released the weights of its AI model LongCat-2.5 for download. The company unveiled the model in early November. Startup Fortune gives the date as November 1, while a post on dev.to says November 2. The sources also disagree on when the weights followed. The trade site CASRAI, citing VentureBeat, says they landed on Hugging Face on November 9. The dev.to post, which draws on a November 15 report from The Decoder, puts the release on that day. What's certain is that the model is now openly available under the MIT license. That's a very permissive open-source license: you can use, modify and redistribute the model, commercially too, as long as you keep the copyright notice.
LongCat-2.5 is built for agentic tasks. These are long workflows with many steps, where the AI runs commands, reads errors and keeps going on its own, mostly while writing code. The most notable thing about it, though, is where it came from. The model was trained entirely on Chinese hardware, without a single Nvidia GPU.
How the model is built
LongCat-2.5 is a mixture-of-experts model (MoE). Think of it as a big office full of specialists: each request only goes to the right experts, and everyone else stays idle. Of its roughly 1.6 trillion parameters, only about 48 billion are active per token, or word fragment. So the compute cost per response is closer to that of a 48-billion-parameter model, even though the total memory footprint stays enormous.
The foundation comes from its predecessor, LongCat-2.0, which Meituan released over the summer. MarkTechPost covered its architecture in detail:
- Zero-computation experts: Simple tokens such as punctuation get routed to an "expert" that does no computation at all. As a result, the actual number of active parameters varies dynamically between 33 and 56 billion.
- LongCat Sparse Attention: Attention is the mechanism a model uses to decide which parts of a text belong together. With standard attention, cost grows quadratically as texts get longer. Meituan's variant picks only the most relevant tokens, which is supposed to enable a native context window of one million tokens. Meituan describes it as an evolution of DeepSeek's sparse attention.
- N-gram embedding with 135 billion parameters. It captures local word relationships and is meant to reduce memory traffic during generation.
- A post-training method called MOPD, which merges three "teacher" models for agentic, reasoning and dialogue skills into one model.
According to Startup Fortune and the Model Card, the main new feature in version 2.5 is native multimodality. Images are converted into the same token system as text instead of going through a bolted-on vision module. CASRAI reports that the published configuration has image and video sections enabled. Meituan says this lets the model do "visual coding": it can build a working interface from a screenshot or sketch, generate 3D objects, or analyze a web page's layout straight from the rendered image. Responses can run up to 128,000 tokens. That matters for a model meant to work on entire codebases rather than single functions.
Benchmarks: big jumps, but self-reported
| Benchmark | LongCat-2.5 | LongCat-2.0 | What it measures |
|---|---|---|---|
| Terminal-Bench 2.1 | 88.4 | 70.8 | Multi-step command-line tasks |
| DeepSWE v1.1 | 64.6 | 9.7 | Demanding agentic coding tasks |
| Vision2Web | 78.6 | – | Turning a design mockup into working code |
| 3DCodeBench (text-to-3D) | 55.4 | – | 3D objects from text descriptions |
| SWE-bench Pro | – | 59.5 | Real-world software engineering tasks |
The Decoder says a score of 88.4 on Terminal-Bench would put LongCat-2.5 just behind Claude Opus 5. The DeepSWE jump from 9.7 to 64.6 in under three months is strikingly large. All of these numbers come from Meituan itself, though. According to CASRAI, the Model Card itself notes that unmarked scores are internal measurements that are "indicative only" and that the model hasn't been thoroughly tested for every use case. Startup Fortune also points out that Meituan published no head-to-head comparisons with obvious rivals such as Qwen3.6, Qwen4 Coder or the current DeepSeek models.
Trained without Nvidia, and no Nvidia instructions either
According to MarkTechPost, LongCat-2.0 was already trained and served on a cluster of more than 50,000 Chinese AI chips. Pretraining covered more than 35 trillion tokens, and Meituan says it ran without crashes or unrecoverable training issues. LongCat-2.5 never touched an Nvidia GPU either. That sends a political and strategic message: you can apparently train a near-frontier model without the hardware that US export controls have made hard to get in China.
The downside, according to dev.to, is that Meituan provides no instructions at all for running the model on Nvidia GPUs. The documented example deployment uses the SGLang-FluentLLM framework on 194 Huawei Ascend Atlas A2 accelerators. Two handle vision processing, 64 handle input processing (prefill) and 128 handle generating the response (decoding). It runs in W4A4, meaning weights and activations are both shrunk to 4 bits. CASRAI stresses that this number is an example, not a hard minimum. Still, it shows the scale involved: you need a data center cluster, not a workstation.
API pricing and access
For almost everyone interested, Meituan's API is the realistic way in. Startup Fortune reports a launch promo price of $0.30 per million input tokens, $0.006 for cached input and $1.20 per million output tokens. dev.to puts that at roughly €0.27 and €1.07. For comparison, MarkTechPost listed regular prices of $0.75 and $2.95 for LongCat-2.0. Nobody knows yet what LongCat-2.5 will cost once the promo ends. MarkTechPost says the LongCat platform offers OpenAI- and Anthropic-compatible APIs. The predecessor could also be used through OpenRouter and coding tools such as Claude Code, OpenCode and Codex.
What you need to try it
To be clear: you can't run LongCat-2.5 locally at home. Quantization shrinks a model by storing its numbers at lower precision. Even at 4 bits, 1.6 trillion parameters still come to roughly 800 GB to 1 TB of data that has to sit in accelerator memory. That's many times more than any home PC, any Mac or Google Colab can handle. On top of that, the only official guide covers Huawei Ascend hardware. Porting it to Nvidia servers would be up to the community. There are no GGUF files for tools like llama.cpp or Ollama yet. If you want to try the model, use the API.
The bigger picture
LongCat-2.5 tells two stories at once. First, an agent model with top Terminal-Bench scores is now available under a truly free license. If the numbers hold up, that significantly narrows the gap between open and closed agent models. It also makes Meituan a serious player in China's open-weight scene, alongside DeepSeek, Alibaba's Qwen and others. Second, it shows that frontier AI can be trained without Nvidia.
In practice, though, "open" comes with a big asterisk here. Legally, anyone can use the model. Technically, only labs, cloud providers and teams with access to Ascend clusters can run it for now. Everyone else is left with the cheap API, and that price is only a promo. Over the coming weeks, two things will matter: whether independent tests confirm the 88.4 score, and whether someone gets the model running efficiently on rentable Nvidia hardware. The exact date of the weight release also remains unclear, since the sources disagree.
Sources
- dev.to #llm dev.to
- casrai.org casrai.org
- marktechpost.com marktechpost.com
- startupfortune.com startupfortune.com
Try it yourself: LongCat-2.5
Explained step by step, no prior knowledge needed – on your own computer or free in your browser.
What can I do with it?
LongCat-2.5 is a huge agent model built mainly for long, multi-step coding tasks: reading entire codebases, running commands on the command line, analyzing errors and trying again. It also understands images, and Meituan says it can build working user interfaces from screenshots or sketches or generate 3D objects. The context window holds up to one million tokens, and responses can be up to 128,000 tokens long. Meituan says it scores 88.4 on Terminal-Bench 2.1, just behind Claude Opus 5, but that hasn't been independently confirmed. It isn't optimized for casual chat. The big catch is that it won't run locally on normal hardware. The official example setup uses 194 Huawei Ascend accelerators.
Who is it worth it for?
The model is interesting for research institutions, cloud providers and companies with access to large accelerator clusters (especially Huawei Ascend) that want to self-host an agent model they can use commercially. For individuals and small teams, self-hosting is unrealistic. You're better off testing the model through Meituan's cheap API.
Ideas: What you can do with it
Hand the model a mid-sized repository in one go and describe the bug. It traces the cause across multiple files and proposes a coherent fix instead of patching just one spot.
Upload a photo of a paper sketch or a screenshot of an existing page. The model turns it into HTML, CSS and JavaScript that you can open right in your browser and keep tweaking.
In an agent tool with shell access, have the model set up a development environment, install packages and fix error messages on its own. You end up with a working setup and a log of every step.
Port an old script, say in PHP, to Python or TypeScript. Meituan says the model takes care to preserve the original behavior and can generate matching tests too.
Universities with access to large clusters can archive and study the weights and configuration and rerun benchmarks independently, for example to check Meituan's claims.
What your computer needs
According to the sources, there's only the full model with 1.6 trillion parameters (48 billion active). The documented example deployment uses a W4A4 variant (4-bit weights and activations) on 194 Atlas A2 accelerators. There are no smaller variants or GGUF files for home PCs. For individuals, the API is the only sensible option.
- Even with 4-bit quantization, you need roughly 800 GB to 1 TB of accelerator memory. That's far beyond home PCs, Macs or Google Colab.
- The official example (SGLang-FluentLLM, W4A4) runs on 194 Huawei Ascend Atlas A2: 2 for image encoding, 64 for prefill, 128 for decoding.
- Meituan provides no instructions for Nvidia GPUs. A port would have to come from the community.
- Long contexts (up to 1 million tokens) push memory requirements even higher.
- According to the model documentation, the 194 accelerators are an example, not a fixed minimum. Other setups are possible but not yet documented.
Groß (1779,8 B parameters, MoE): running entirely on the GPU takes a lot of VRAM (video memory). With MoE offloading, a regular graphics card plus plenty of RAM is enough (see table). Colab Free isn't enough.
How do I find out what my computer has?
- Windows: Press Ctrl + Shift + Esc → Task Manager → Performance tab → click GPU on the left. At the bottom you'll see Dedicated GPU memory (that's your VRAM). You'll find system memory under Memory.
- Mac: Apple menu at the top left → About This Mac. You'll see your chip (e.g. M2) and memory (e.g. 16 GB). On Apple chips, graphics and processor share this memory.
- Linux: Type
nvidia-smiin the terminal (shows your graphics card and its memory) andfree -hfor system memory.
Guide
This model runs with its developers' own program (meituan-longcat/SGLang-FluentLLM on GitHub). The commands below come from the Model Card and the developers' instructions.
Windows 10 / 11
Windows 10 / 11: not supported. LongCat-2.5 has 1.6 trillion parameters, and the weights are about 3.5 TB. No Windows PC can load that, and the inference software has only been tested on NVIDIA data center cards (H800/H20) under Linux. You can try the model through Meituan's online LongCat service (longcat.ai) or a rented GPU cluster in the cloud.
macOS
macOS: not supported. The inference software SGLang-FluentLLM requires NVIDIA graphics cards with CUDA (NVIDIA's computing platform for its GPUs). A Mac doesn't have such a card, and the roughly 3.5 TB of weights won't fit in any Mac's memory. Use Meituan's online service (longcat.ai) or a rented GPU cluster instead.
Linux
Linux: supported. According to Meituan, it's only been tested on NVIDIA H800/H20. You need a cluster of several servers with 8 of these cards each. A normal PC comes nowhere close. The multimodal features (image understanding) have been removed from SGLang-FluentLLM. The engine only provides the text part, and the exact launch commands are in the Quick_Start.md file in the repo.
- Check the prerequisites. You need a Linux compute cluster with many NVIDIA H800 or H20 cards. Together they need more than 4 TB of VRAM (video memory), which means several servers with 8 cards each and a fast network between them. Every server needs the NVIDIA driver, CUDA, Python 3 and Git installed. Use nvidia-smi to check that all cards are detected. Also plan for at least 4 TB of free, fast storage.
nvidia-smi python3 --version git --version - Download the software. Grab Meituan's inference engine, SGLang-FluentLLM. An inference engine is the program that loads the model and answers requests. Then switch into the new folder.
git clone https://github.com/meituan-longcat/SGLang-FluentLLM.git cd SGLang-FluentLLM - Create a virtual environment. A virtual environment (venv) is an isolated folder for Python packages, so nothing clashes with your system. Once it's activated, you'll see (.venv) at the start of your prompt. You need to do this on every server in the cluster.
python3 -m venv .venv source .venv/bin/activate - Read the quick start guide. Meituan explains how to install and launch the engine in the Quick_Start.md file. Follow the commands there exactly, especially for the customized components FlashMLA, DeepGEMM and FlashInfer. Press q to exit the viewer.
less Quick_Start.md - Download the model. This command downloads all 208 weight files from Hugging Face, about 3.5 TB in total. Depending on your connection, that can take days. If the command finishes without errors, the files are in the LongCat-2.5 folder. If the hf command is missing, install it first with pip install -U huggingface_hub.
pip install -U huggingface_hub hf download meituan-longcat/LongCat-2.5 --local-dir LongCat-2.5 - Verify the download. Count whether all 208 parts are actually there. If you see 208, the download is complete. If the number is lower, just run the same hf download command again. It picks up where it left off.
ls LongCat-2.5/*.safetensors | wc -l - Start the server and send a first request. Start the engine with the launch command from Quick_Start.md and point the model path to the LongCat-2.5 folder. Once the server is running, send it a short text question, such as "Explain in one sentence what an MoE model is." If you get an answer back, everything worked. Remember that this engine only handles text, not images.
- Result. When you're done, a server running LongCat-2.5 sits on your GPU cluster and answers text requests.
What to do after your first result
- According to the README, the engine supports speculative decoding via Eagle, MTP and PLD. That speeds up responses, and you'll find the options in Quick_Start.md.
- For image understanding, Meituan uses a separate setup internally. SGLang-FluentLLM itself only ships the text part (the LLM backbone).
- To distribute requests across multiple servers, Meituan recommends NVIDIA's Dynamo. It schedules requests based on which caches (KV cache) already exist.
- If you don't have your own cluster, the easiest way to try the model is the online service at longcat.ai.
Try it
Explain in plain language what the function in this Python file does, and suggest three improvements.Here's a screenshot of a login page. Rebuild it in HTML and CSS so it also looks good on a phone.Refactor utils.py to remove the duplicated file input/output logic, and write matching tests.You have access to a shell. Set up a new Node.js project, install Express, start a server on port 3000 and fix any errors that come up on your own.I'm giving you the entire repository. Figure out why the CSV export breaks on accented characters like ä, é and ñ, trace the bug through every file involved and propose a coordinated fix.Tips for better results
- For testing, use LongCat's OpenAI-compatible API. Existing code for OpenAI clients usually works once you change the base URL and model name.
- Use the model in an agent tool with shell access, since that's exactly what it was trained for. In plain chat, its strengths barely show.
- For coding tasks, feel free to provide lots of context (whole files or repositories). The large context window is one of its core strengths.
- According to the source, cached input is extremely cheap ($0.006 per million tokens). Keep recurring system prompts and codebases unchanged to save money.
If something goes wrong
Running it locally with Ollama or LM Studio won't work: there are no GGUF files, and the model is far too big for home hardware.
There's no official Nvidia support. If you want to host it on Nvidia servers, you'll have to wait for community ports.
The benchmark scores are self-reported by Meituan. Run your own tests on your own tasks before using it in production.
The API prices ($0.30 / $1.20 per million tokens) are promo prices and may go up. Don't base your cost planning on them.
The MIT license requires you to keep the copyright and license notice when redistributing.
“out of memory,” a crash, or your computer freezes
The model is too big for your VRAM (video memory). Pick a smaller variant from the table above and close other programs, especially games and browsers with lots of tabs.
It runs, but extremely slowly
Your CPU is probably doing the work instead of your graphics card. In Ollama, the PROCESSOR column of ollama ps shows how much runs on the GPU. If it says "100% CPU", update your graphics driver or pick a smaller variant that fits entirely into VRAM (video memory).
“ollama” or “python” is not found
Close the terminal window and open it again so it recognizes the newly installed program. For Python on Windows: reinstall it and check Add python.exe to PATH.
Windows: "Running scripts is disabled on this system"
Run the script with exactly the command above: powershell -ExecutionPolicy Bypass -File try_windows.ps1. This allows execution for this one time only.
Error message when loading the model (version, "trust_remote_code", unknown architecture)
Brand-new models often need the latest software version. With Ollama: update Ollama. With Python: pip install -U transformers in the activated environment. The Model Card usually lists the exact version.
Tokenstrom generates the scripts and notebook automatically. Please take a quick look before running them – they're plain, readable text. Mind the model's license: mit.
Ask the AI assistant
Questions about this article, installation or background? Our assistant knows this page and runs on our own machine, not in someone else's cloud.
The Assistant is an AI (Gemma 4) and can make mistakes – please check important details against the source. Questions are used only to generate an answer and are deleted after one hour. Please don't enter any personal data.
Comments
What do you think? Already tried it? Write it here, no sign-up needed.
Comments are public. Links aren't allowed, and we delete abusive posts. You can delete your own comment at any time in this browser. Learn more in the Privacy Policy.