On July 5, 2026, a poster on the r/LocalLLaMA community shared what open source AI builders had been waiting for: the downloadable model weights for LongCat-2.0 are finally live. Meituan, the Chinese delivery and local-services company, had announced the model on June 30 with big claims but held back the actual files, listing them as "coming soon" on Hugging Face and GitHub. Now the weights are here, released under the MIT license, which means you can download them, use them in a commercial product, modify them, and redistribute them with almost no strings attached.
The headline number is staggering: 1.6 trillion total parameters. But the number that actually determines what it costs to run the model is much smaller, about 48 billion active parameters per token. Understanding the gap between those two numbers is the key to understanding why LongCat-2.0 matters and whether it matters for you.
What is a Mixture-of-Experts model, in plain terms?
A "parameter" in an AI model is a number the model learned during training. Think of parameters as the model's knowledge stored in a giant spreadsheet of weights. More parameters generally means the model can represent more complex patterns, but it also means more memory and more compute every time the model generates a word.
A Mixture-of-Experts model, or MoE, changes that last part. Instead of one giant network that lights up entirely for every word, an MoE splits the network into many smaller sub-networks called "experts." A router inside the model looks at each word being processed and picks only the few experts best suited for that word. The rest sit idle.
LongCat-2.0 takes this further with what Meituan calls "Zero-Compute Experts." When the model encounters an easy word, like a common English word in boilerplate code, it routes through a near-empty sub-network that barely uses any compute. When it hits something hard, like a tricky logic problem, it assigns more experts. That is why the active parameter count swings between 33 billion and 56 billion per token instead of staying fixed.
The total parameter count of 1.6 trillion matters because it represents the full knowledge the model can draw from. The active parameter count matters because it determines the actual computing cost every time you use the model. If you want a deeper look at how sparse models stack up against dense ones, our guide to open source AI model types breaks down the vocabulary.
Why does only 48 billion out of 1.6 trillion matter for cost?
Here is the practical difference. A traditional "dense" model with 1.6 trillion parameters would need enough memory to hold all 1.6 trillion numbers and enough compute to run calculations across every single one of them for every word it generates. That would be absurdly expensive and slow.
LongCat-2.0, because it is sparse, only needs compute for the 48 billion or so parameters that activate on any given word. The total memory requirement is still large, because all 1.6 trillion parameters must sit in memory waiting to be called. But the processing cost per word is closer to what you would expect from a 48 billion parameter model, not a 1.6 trillion one.
The chart above shows the gap on a logarithmic scale, which is necessary because 1,600 billion and 48 billion live in completely different visual neighborhoods. The total parameter count towers over the active count, and that tower is what keeps the model's knowledge broad while its running costs stay narrow.
That gap is also why the API pricing is aggressive. Meituan's promotional pricing starts at $0.30 per million input tokens and $1.20 per million output tokens, with context-cache hits billed as free. Standard LongCat-2.0 pricing, once the promotion ends, runs about $0.75 input and $2.95 output per million tokens. For comparison, GPT-5.5 from OpenAI costs roughly $5.00 per million input tokens and $30.00 per million output tokens.
A "token" is the unit of text the model processes, roughly three-quarters of a word in English. When you send a prompt to the model, it counts your input tokens and the model's output tokens separately for billing. The free cache hits matter because if you send the same large context repeatedly, like a codebase you keep asking questions about, you only pay for it once.
The chart above lays out the pricing gap. At promotional rates, LongCat-2.0's input cost is about one-seventeenth of GPT-5.5's, and its output cost is about one-twenty-fifth. Even at standard pricing, the gap stays wide enough to matter for anyone running heavy agent workloads.
What can you actually do with a 1 million token context window?
The "context window" is how much text the model can hold in its working memory at one time. A bigger context window means you can paste in more code, more documents, or more conversation history before the model starts forgetting what came first.
Most models today handle around 128,000 tokens, which is roughly 300 pages of text. LongCat-2.0 supports a native 1 million token context window, close to 2,500 pages. For a beginner building with AI, that means you could paste an entire small-to-medium codebase into the prompt and ask the model to understand it as a whole, rather than feeding it one file at a time.
The reason this does not cost a fortune is a technique called LongCat Sparse Attention. Standard attention, the mechanism that lets a model decide which earlier words matter for the current word, compares every token to every other token. That means the cost grows quadratically: double the context length and you roughly quadruple the computation. LongCat Sparse Attention selects only the most relevant tokens to compare, which drops the scaling closer to linear. Double the context length and the cost roughly doubles, not quadruples.
For coding specifically, this means the model can pull a specific function out of a giant repository without re-reading every other function each time it generates a word. The model's Hugging Face model card describes three optimizations that make this work: streaming-aware indexing that turns scattered memory reads into predictable sequential ones, cross-layer indexing that shares one indexing pass across multiple neural network layers, and a two-stage coarse-to-fine scoring scheme that shrinks the candidate pool before doing detailed work.
Can you run LongCat-2.0 on your own computer?
No. Or at least, not on any computer a normal person owns. The model has 1.6 trillion parameters, and even with sparse activation, you need enough memory to hold all of them at once. At standard precision, that would require roughly 3.2 terabytes of GPU memory. For reference, a single high-end GPU like the Nvidia H100 has 80 gigabytes. You would need dozens of them just to load the model.
SiliconANGLE's coverage makes the point bluntly: at 1.6 trillion parameters, this model will not show up on consumer hardware and will not run on-premises for most enterprise workloads. It lives in data centers and cloud environments, distributed across high-density inference clusters.
The open weights are still valuable. Researchers can study the architecture. Companies with the right infrastructure can host it internally. The open source community can build on it. But for a beginner coding at home, the practical path is the API.
You can try LongCat-2.0 through OpenRouter, where it spent two months at the top of the developer usage charts under the codename "Owl Alpha" before Meituan revealed its identity. You can also use it through Meituan's own LongCat platform. Both routes give you API access without needing to own any hardware.
What does the MIT license let you do with the model?
The MIT license is one of the most permissive open source licenses in existence. Under MIT, you can:
- Use the model commercially without paying royalties
- Modify the model or fine-tune it on your own data
- Redistribute the model or your modified version
- Include it in a closed-source product
The only real requirement is that you include the original copyright notice and license text somewhere in your distribution. There are no usage restrictions, no regional limits, no "non-commercial" clauses that you find in some other open weight releases.
This matters because not all "open" AI models are equally open. Some release weights under licenses that forbid commercial use or require you to share your own improvements. LongCat-2.0's MIT license puts almost no conditions on you. If you wanted to build a paid coding assistant on top of it tomorrow, the license says go ahead. byteiota's analysis confirms: commercial use, fine-tuning, and redistribution are all explicitly permitted with no special agreements or regional restrictions.
Do the benchmark numbers hold up, or should you be skeptical?
Meituan reports that LongCat-2.0 scores 59.5 on SWE-bench Pro, edging out GPT-5.5 at 58.6, and 70.8 on Terminal-Bench 2.1. SWE-bench Pro is a benchmark that tests whether a model can fix real bugs in real open source software repositories. Terminal-Bench tests whether a model can execute multi-step tasks in a terminal environment.
Those are impressive numbers, but they come with a big asterisk. The benchmarks are self-reported by Meituan and were run under the company's own testing harness. A one-point win on SWE-bench Pro is a photo finish, not a landslide. Independent evaluations have not yet confirmed the results.
The felloai breakdown of the launch puts it well: the benchmarks are self-reported, the GPT-5.5 win is a one-test photo finish, and the open weights were not actually downloadable at launch. Now that the weights are available, third-party testing becomes possible, but it takes time.
The honest advice: run LongCat-2.0 on your own code before you trust it. Benchmarks test general capability, but they do not tell you how a model performs on your specific codebase, your specific language, or your specific coding style. The promotional pricing makes experimentation cheap, so there is little downside to testing it against your current model on real tasks.
The bottom line
LongCat-2.0 is a genuine engineering achievement: a trillion-parameter model that runs at the cost of a much smaller one, with a context window big enough to swallow a codebase, under a license that asks nothing of you. But it is also a data-center-scale model that most individuals will only touch through an API, with benchmarks that still need independent verification. If you are building coding tools and you care about cost, try it on OpenRouter this week while the promotional pricing lasts. If you are a hobbyist hoping to run it locally, your computer is not the right home for it, and that is fine. The open weights are a gift to the research community, not a download-and-run project for a laptop.
Sources
- Reddit r/LocalLLaMA: LongCat-2.0 weights are now open
- VentureBeat: Meituan open sources LongCat-2.0
- HuggingFace: LongCat-2.0 model card and README
- felloai.com: LongCat-2.0, China's 1.6T open-source coding model
- SiliconANGLE: China's Meituan open-sources massive LongCat-2.0 AI model
- byteiota.com: LongCat-2.0, the open-source coding model hiding in plain sight
