Intern-S2-Mobius: The 35B Model That Separates Knowledge From Reasoning

Shanghai AI Laboratory's InternLM team has quietly published Intern-S2-Mobius, a 35B open-weight foundation model that does something almost no other released model does: it stops storing knowledge inside its layers. Instead of the standard Transformer arrangement — where every layer carries its own feed-forward block full of memorized facts — Mobius pulls all of that knowledge out into a single globally shared Memory and lets a small number of Reasoners query it repeatedly. The claimed payoff is not a higher benchmark score. It is speed: the same answers in roughly a third to a fifth of the reasoning tokens, and up to 4.6x the request throughput. This guide explains what Mobius actually is, what its configuration file reveals that the model card does not, what the published benchmarks show line by line — including the two rows where it loses — where the "4x faster" claim holds and where it evaporates, and who should realistically care.

Accuracy note: every number below comes from InternLM's own model card, its published performance and efficiency figures, its deployment guide, and the model's configuration files on Hugging Face. There is no independent third-party evaluation of Intern-S2-Mobius as of this writing — it is not listed on any independent leaderboard, it is not deployed by any inference provider, and its download counter is still at zero. Treat all comparative figures as vendor-reported until someone reproduces them. Specs and code for a model this new change fast; verify before you build.

TL;DR. Intern-S2-Mobius is a 35B-parameter, Apache 2.0, multimodal foundation model continually pre-trained from Qwen3.5-35B and then post-trained with SFT and reinforcement learning. Its novelty is architectural: the Mobius-v0 design replaces layer-bound feed-forward knowledge storage with one globally shared Memory of 2,560 experts, queried by four stacked Reasoner blocks that can reach knowledge outside their own depth (a Backward Residual Connection) and refine hidden states through recurrent latent iteration before decoding (Dynamic Latent Reasoning). On InternLM's own evaluation it beats the Qwen3.5-35B baseline it was built from on seven of nine general benchmarks (average 67.88 vs 65.05) and demolishes it on scientific tasks (52.14 vs 18.20), while producing reasoning traces about 1.5x shorter on average — 4.6x shorter on MMLU Pro, 5.0x shorter on GPQA Diamond. That trace compression is where the throughput gain comes from: 2.9x at batch 16, rising to 4.6x at batch 256. The catches are real: it loses on the two hardest reasoning benchmarks (HLE and UGD hard), the throughput win largely disappears on competition math, and nobody outside the lab has verified any of it.

Key takeaways

• Architecture-first release: Mobius-v0 decouples knowledge vectors from reasoning operators — one shared Memory of 2,560 experts serving four Reasoner blocks, instead of 40 layers each hoarding their own FFN knowledge.

• Efficiency, not intelligence, is the pitch: average output length drops about 1.5x, and request throughput rises 2.9x at batch 16 to 4.6x at batch 256 against the Transformer baseline.

• It genuinely beats its own base model: 67.88 vs 65.05 average on general tasks, winning MMLU Pro (89.05 vs 85.31), AIME 2026 (95.31 vs 92.08) and HMMT 2026 (85.51 vs 78.50).

• But it loses where deliberation matters most: HLE 19.11 vs 22.40 and UGD hard 73.02 vs 78.02 — the two hardest evaluations in the set, both won by the plain Transformer.

• The science jump is the largest single result: Biology-Instructions 51.40 vs 3.77, Mol-Instructions 45.73 vs 21.70, MolecularIQ 59.29 vs 29.13.

• Open but not available: Apache 2.0 weights on Hugging Face, no inference provider hosting it, ~73 GB of bfloat16 weights — self-hosting is currently the only way to run it.

What Intern-S2-Mobius actually is

Intern-S2-Mobius is a 35B foundation model published by internlm, the Hugging Face organization behind Shanghai AI Laboratory's Intern series. The weights landed on Hugging Face on July 29, 2026, and the accompanying GitHub repository — README, deployment guide, and a full technical report PDF — went public on August 5, 2026. It is released under Apache 2.0, which is about as permissive as open weights get: commercial use, modification, and redistribution are all allowed.

It is not a fine-tune. It is a continual pre-train with architecture surgery. InternLM took Qwen3.5-35B — Alibaba's open-weight 35B mixture-of-experts model, released March 4, 2026 — restructured how the model stores and accesses knowledge, and continued pre-training the result, then applied supervised fine-tuning and reinforcement learning on top. That lineage matters for interpreting the benchmarks: every comparison InternLM publishes is Mobius against the exact model it was grown from, which is the cleanest possible ablation of the architecture change and also, conveniently, the comparison most likely to flatter it.

The model is multimodal. Hugging Face classifies it as image-text-to-text, and the configuration confirms a full vision encoder plus video token handling. It is also, judging by what ships alongside the weights, aimed squarely at science — more on that below.

The Mobius architecture, in plain English

A conventional Transformer interleaves two jobs in every layer. Attention moves information between tokens; the feed-forward network (or, in a mixture-of-experts model, a bank of expert FFNs) stores knowledge. Because the FFN sits inside the layer, the knowledge it holds is only reachable at that depth. A fact learned into layer 30 cannot be consulted by the reasoning happening at layer 5. Information flows forward, layer by layer, and that is the only path.

Mobius breaks that binding. InternLM describes three consequences.

Knowledge-reasoning separation. Layer-bound FFN storage is replaced by a globally shared Memory. Rather than 40 layers each owning a slice of the model's knowledge, there is one pool that every reasoning stage can address. InternLM's argument is that this improves knowledge compression — the same facts do not need to be redundantly re-learned at multiple depths — and gives each Reasoner a much broader knowledge space than a single layer's FFN could offer.

Backward Residual Connection. Because Memory is shared, shallow and deep reasoning stages both reach the same repository. Knowledge access is no longer strictly forward-flowing. A shallow stage can pull in something that, in a standard stack, would only have been available thirty layers later. InternLM's claim is that this lets the model compose knowledge across depths more flexibly and, crucially, synthesize useful information in fewer reasoning steps. That last clause is the whole thesis of the release.

Dynamic Latent Reasoning. Instead of externalizing every deliberation step as visible chain-of-thought tokens, Mobius refines its continuous hidden states through recurrent latent iteration before it decodes anything. Some of the "thinking" happens in the model's internal representation space rather than in generated text, and the amount of that internal computation is allocated dynamically per token. The practical effect is that the model needs to write fewer words to reach the same conclusion — and since generation is autoregressive and serialized, writing fewer words is the single most direct way to make a reasoning model faster.

Put together, the pitch is a reasoning model that thinks more and types less.

What the configuration file reveals

The model card describes the architecture in prose. The code>config.json/code> makes it concrete, and it contains several numbers worth knowing.

• Four Reasoners over 40 layers. The text config declares 40 hidden layers but only four blocks. The 40 layers are organized into four Reasoner stages that iterate against the shared Memory, rather than forty independent knowledge-plus-attention units.

• 2,560 experts. This is the shared Memory made literal. Mobius carries 2,560 experts with 8 activated per token and a tiny per-expert intermediate size of 512, plus one shared expert. For scale, its sibling Intern-S2-Preview uses 256 experts. A ten-times-larger pool of much smaller experts is exactly what "one global knowledge store instead of per-layer FFNs" looks like when you write it down as a config.

• 35B on the box, ~36B on disk, ~3B active. The model card says 35B; Hugging Face's safetensors reader reports 36B parameters; the weight index totals 72.96 GB in bfloat16, which works out to roughly 36.5B. The deployment guide is the most precise: it calls the release a 30B-A3B model — around 3B parameters active per token. As with any sparse MoE, you pay for the full weight set in memory and get small-model compute per token.

• Hybrid attention, 3:1. The layer list alternates three linear-attention layers to one full-attention layer, all the way down — ten full-attention layers out of 40. Linear attention keeps long-context memory and compute from exploding; the periodic full-attention layers preserve the exact recall that pure linear attention gives up. The linear layers use a convolution kernel of width 4 and an SSM state in float32, the now-standard gated-delta-style recipe.

• 256K context. Maximum position embeddings are 262,144. Note the gap between what the architecture supports and how it was evaluated: InternLM ran its text benchmarks at 128K, and at 64K on MMLU Pro, SimpleQA, and HLE. A 256K ceiling is not the same as 256K of validated quality.

• A built-in multi-token-prediction head. There is a one-layer MTP module with its own 256 experts. This is not decoration — the deployment guide recommends running with MTP speculative decoding and four draft tokens, so part of the real-world speed story is speculative decoding, not architecture alone.

• A real vision tower. A 27-layer, 1152-hidden vision encoder with patch size 16, 2x2 spatial merging, and temporal patching for video, projecting into the 2048-dimensional text stream with interleaved multimodal RoPE. Images and video in, text out.

• Other specifics for the curious: 16 attention heads with head dimension 256, 2 key-value heads (aggressive grouped-query attention), gated attention outputs, a partial rotary factor of 0.25, RoPE theta of 10 million, and a 251,392-token vocabulary.

The benchmarks, line by line

InternLM evaluated with OpenCompass and published a single comparison: Intern-S2-Mobius-35B against Qwen3.5-35B, the model it was continually pre-trained from. Nine general benchmarks, three scientific ones.

On general tasks, Mobius wins seven of nine. MMLU Pro — broad multi-domain knowledge with harder distractors than original MMLU — goes 89.05 to 85.31, a 3.7-point gain and the clearest knowledge result in the set. GPQA Diamond, graduate-level science questions written to be Google-proof, is essentially a tie at 80.81 versus 80.24. IMO Bench, olympiad-level mathematics, goes 81.25 to 77.50. AIME 2026, the American Invitational Mathematics Examination, goes 95.31 to 92.08. HMMT 2026, the Harvard-MIT Mathematics Tournament, is the biggest math swing at 85.51 versus 78.50. AMO goes 58.00 to 50.00. And SimpleQA — short-form factual recall, the benchmark that most directly measures whether a model actually knows things — jumps from 21.39 to 28.90, a 35% relative improvement that is the single best evidence for InternLM's "shared Memory compresses knowledge better" argument.

Then the two losses, and they are the interesting rows. UGD hard goes the other way: 73.02 for Mobius against 78.02 for the baseline, a five-point deficit. And HLE — Humanity's Last Exam, the hardest general evaluation in wide use, where frontier models still score in the teens and twenties — is 19.11 versus 22.40. The plain Transformer wins by 3.3 points on the benchmark specifically designed to require the most reasoning.

That pattern is not noise, and it is not hidden: InternLM published it. The most plausible reading is that latent reasoning is a compression, and compression is lossy at the tail. Internalizing deliberation into continuous hidden states works beautifully when the deliberation is retrieval-heavy or follows a familiar shape — which describes MMLU Pro, SimpleQA, and most competition math. On problems that genuinely require long, exploratory, error-correcting chains of thought, the explicit token-by-token trace still appears to be worth its cost. The overall average — 67.88 against 65.05 — is a real win, but it is an average that conceals a trade, not a uniform improvement.

The scientific results are a different scale of difference. Biology-Instructions goes from 3.77 to 51.40. Mol-Instructions, covering molecular understanding and generation, goes from 21.70 to 45.73. MolecularIQ goes from 29.13 to 59.29. The average is 52.14 against 18.20. Numbers like 3.77 rising to 51.40 are not architecture wins; they are the signature of targeted domain training on tasks the baseline was simply never taught to do. Qwen3.5-35B scoring under 4% on Biology-Instructions means it does not understand the task format, not that it is bad at biology. Read those three rows as "InternLM added a scientific specialization," which is genuinely valuable and is the entire point of the Intern-S line — just do not attribute it to the Mobius architecture.

Where "4x faster" is real, and where it isn't

The efficiency claim is the reason this model exists, so it deserves a careful reading. InternLM's headline is "nearly 4x end-to-end inference speedup." The published throughput figure is more informative than the headline, and more honest.

Measured as request throughput against batch size, averaged across benchmarks, Mobius beats the Transformer baseline by 2.9x at batch 16 and 4.6x at batch 256. The gap widens with batch size, which is what you would expect when the win comes from generating fewer tokens per request: the more requests you pack together, the more the saved decode steps compound. The "nearly 4x" headline is a midpoint of a range, not a constant.

Break it down per benchmark and the picture gets sharper. On MMLU Pro and GPQA Diamond, Mobius is dramatically faster at every batch size — the throughput curves separate immediately and keep diverging. On IMO Bench, it leads consistently but modestly. On AIME 2026 and HMMT 2026, the baseline Transformer is actually faster at intermediate batch sizes, with Mobius only pulling ahead at batch 256. On the hardest competition math, the throughput advantage is a wash or worse across much of the useful operating range.

Why? Because throughput tracks trace compression almost perfectly. The average output length across benchmarks drops about 1.5x, from roughly 20,400 tokens to roughly 13,200. But that average spans an enormous range: 4.6x shorter on MMLU Pro (about 1,100 tokens versus 5,150) and 5.0x shorter on GPQA Diamond (about 2,600 versus 12,900), against only 1.4x on IMO Bench, 1.5x on AIME 2026, and 1.2x on HMMT 2026. Where the model can compress its thinking, it flies. Where the problem demands 24,000 tokens of derivation no matter what, it cannot, and the architecture's overheads show up instead.

The practical translation: if your workload looks like knowledge retrieval, multiple choice, technical Q&A, or classification, the speedup is large and immediate. If your workload is hard mathematical or scientific derivation, budget for roughly parity and be pleasantly surprised. Anyone quoting "4x faster" as a blanket property of the model is quoting an average of two very different behaviors.

The science stack hiding in the file list

One of the most revealing things about this release is not in the model card at all — it is in the repository's file listing. Alongside the usual tokenizer files, Intern-S2-Mobius ships three additional domain tokenizers: code>tokenizer_PROT.model/code> for protein sequences, code>tokenizer_SMILES.model/code> for molecular structures in SMILES notation, and code>tokenizer_XNA.model/code> for nucleic acid sequences. There is also a stray NumPy array of seismic data sitting in the repo.

Dedicated tokenizers for proteins, molecules, and DNA/RNA are not something you add casually. They mean the model was trained to read those sequence types as first-class inputs rather than as ordinary text that happens to contain letters. That is what turns a 3.77 into a 51.40 on Biology-Instructions, and it puts Mobius in the same family as its sibling Intern-S2-Preview, which added time-series and vision modalities and, per InternLM, was the first open-source model with material crystal structure generation capability.

If you are a general-purpose developer, this is trivia. If you work in computational biology, cheminformatics, or materials science, it may be the most important line in this article: this is a small, Apache-2.0, self-hostable model that speaks SMILES and protein sequence natively.

Where it sits in the Intern family

The Intern-S line is Shanghai AI Laboratory's scientific multimodal series. Intern-S1 established the format. Intern-S1-Pro scaled it to the trillion-parameter class. Intern-S2-Preview, released shortly before Mobius, is the efficiency play: a 36B-total, 3B-active model with 256 experts and a 262K context that InternLM claims matches the trillion-scale S1-Pro on core professional scientific tasks — a roughly 30x parameter reduction for comparable scientific capability.

Intern-S2-Mobius is a third thing: an architecture release wearing the Intern-S2 name. The "v0" in Mobius-v0 is doing real work in that label — this is the first public iteration of a design, not a mature product line. It connects to ArchSpace, InternLM's open platform for validating LLM architecture innovations, whose stated goal is "turning LLM architecture exploration into reusable knowledge for the community," with peer review and published results including negative ones. Mobius is what that program looks like when a proposal graduates from a 1B-scale probe to a 35B model you can actually download. A full technical report ships with the GitHub repository for anyone who wants the derivations.

Read in that light, the two benchmark losses are a feature of the release, not an embarrassment. This is a lab publishing an architecture experiment honestly, including where it regressed.

How to run it

Intern-S2-Mobius is supported by three inference stacks, and the deployment guide gives working invocations for each.

LMDeploy is the recommended path and the only one the guide shows on a single GPU: serve with the PyTorch backend, code>--trust-remote-code/code>, tensor parallelism of 1, and MTP speculative decoding enabled via the qwen3_5_mtp speculative algorithm with four draft tokens. vLLM is shown with tensor parallelism of 2, the qwen3 reasoning parser, the qwen3_coder tool-call parser, automatic tool choice, and MTP speculative decoding with four speculative tokens. Transformers works for basic inference through code>AutoModelForImageTextToText/code> with code>trust_remote_code=True/code> and bfloat16 — note that the model ships custom modeling code, so remote code execution is mandatory, and the config targets Transformers 5.2.

InternLM's recommended sampling parameters are temperature 0.8, top-p 0.95, top-k 50, and min-p 0.0 — warmer than the near-greedy settings most reasoning models want, which is worth respecting rather than overriding out of habit.

On hardware: roughly 73 GB of bfloat16 weights plus KV cache and activations means a single 80 GB accelerator is tight and a single 141 GB card is comfortable, which is presumably why the vLLM example uses two GPUs while the LMDeploy example assumes one large one. Long-context work will push that higher. Enable MTP — the guide recommends it explicitly, and a meaningful slice of the advertised speedup lives there rather than in the base architecture.

The most important practical caveat: no inference provider currently hosts this model. Hugging Face's provider panel says so plainly, and the download counter was still at zero when this was written. There is no API endpoint, no price per million tokens, and no managed way to try it. Self-hosting is the only option today.

Who should actually care

1. Teams running high-volume, retrieval-shaped reasoning workloads

This is the profile the architecture was built for. If you are serving large batches of technical Q&A, document analysis, structured extraction, or multiple-choice-style classification through a reasoning model, and your bill is dominated by reasoning tokens you never show the user, a model that reaches the same answer in a fifth of the tokens is a direct cost reduction. The MMLU Pro and GPQA numbers — 4.6x and 5.0x shorter traces with equal or better accuracy — are exactly this shape. Benchmark it against your own traffic before believing it, but the mechanism is sound and the incentive is large.

2. Computational science groups

Native protein, SMILES, and nucleic-acid tokenizers, plus large measured gains on biology and molecular benchmarks, in an Apache 2.0 model that fits on one or two GPUs. For a lab that needs data to stay on-premises and cannot send molecular structures to a commercial API, that combination is rare. The Intern-S line has been building toward this, and Mobius is the cheapest entry point into it so far.

3. Researchers and architecture watchers

Knowledge-reasoning decoupling and latent reasoning have been active research threads for a while; very few have been validated at 35B and released openly with the failure cases intact. If you care about where post-Transformer architectures go next, the technical report and the two losing rows are more interesting than the average score. ArchSpace is explicitly built to make this kind of result reusable.

Who should not care, at least yet: anyone looking for a production general-purpose assistant. There is no hosted endpoint, no independent evaluation, no ecosystem tooling, and no track record. That is not a criticism of the model — it is a description of a research release that is one week old.

How it fits a production stack

The honest placement for Intern-S2-Mobius today is evaluation candidate, not default model. It is an unhosted, unverified, one-week-old research artifact with a genuinely interesting architecture and one very specific strength — token-efficient reasoning on retrieval-shaped tasks — plus a real specialization in scientific sequence data.

A sensible pattern is to keep your production traffic on a vendor-neutral endpoint like OrcaRouter, which gives you one OpenAI-compatible API across many models, and stand Mobius up separately on your own GPUs for the narrow slice where it might win. Measure the thing that actually matters for this model: not accuracy alone, but tokens spent per correct answer. That is the axis Mobius is optimized for, and it is the axis most evaluation harnesses ignore. If it holds up on your workload, you have a self-hosted lane that is cheap to run and legally unencumbered. If it does not, you have lost a day of GPU time and your production path never moved.

The same logic applies in reverse if a provider eventually hosts it: a router lets you A/B a new model against your incumbent without rewriting anything, which is exactly the right way to adopt an architecture nobody has independently tested.

Limitations and caveats

Start with the biggest one: there is no independent verification of anything in this article's numbers. Every benchmark, every throughput curve, and every token-length comparison comes from InternLM. The comparison is also structurally favorable — Mobius is measured only against the specific baseline it was continually pre-trained from, not against the current frontier, and the additional SFT and RL post-training means the comparison is not a clean architecture ablation even though it is presented as one. Some of the gain is Mobius; some is simply more training.

The regressions are real and they are on the hardest tasks. Losing HLE by 3.3 points and UGD hard by 5 points, while winning nearly everything easier, is a coherent and slightly worrying signature for a model whose selling point is reasoning efficiency.

Operationally, the friction is significant. Custom modeling code means code>trust_remote_code/code> and a bleeding-edge Transformers version. The frameworks that support it need to be recent enough to know what an code>interns2_mobius/code> is, and InternLM's own guide warns that these are reference configurations under active development. Roughly 73 GB of weights is not a laptop model. There is no hosted API, no pricing, no rate limits, and no SLA — because there is no service.

Finally, note what has not been published: no multimodal benchmark results despite a full vision encoder, no long-context evaluation despite a 256K ceiling, no coding benchmarks at all, no safety or alignment evaluation, and no comparison against any model other than Qwen3.5-35B. For a general-purpose deployment those are large blank spaces. For an architecture paper with weights attached, they are simply out of scope — which is the right way to read this release.

FAQ

What is Intern-S2-Mobius?

A 35B-parameter, Apache 2.0, multimodal foundation model from Shanghai AI Laboratory's InternLM team, built on the Mobius-v0 architecture that separates knowledge storage from reasoning computation. It was continually pre-trained from Qwen3.5-35B and post-trained with SFT and reinforcement learning, and published on Hugging Face on July 29, 2026.

What makes the Mobius architecture different?

Conventional Transformers store knowledge in a feed-forward block inside every layer, so knowledge is only reachable at the depth where it lives. Mobius replaces that with one globally shared Memory — 2,560 experts in the released config — that four Reasoner blocks query repeatedly, allowing cross-depth knowledge access and letting part of the deliberation happen in continuous hidden states instead of generated chain-of-thought tokens.

Is Intern-S2-Mobius really 4x faster?

On average and at large batch sizes, roughly yes: InternLM measures 2.9x higher request throughput at batch 16 rising to 4.6x at batch 256. But it varies enormously by task. On MMLU Pro and GPQA Diamond the gain is large at every batch size; on AIME and HMMT competition math the baseline Transformer is actually faster at intermediate batch sizes. The speedup tracks how much the model can shorten its reasoning trace.

How does it compare to Qwen3.5-35B?

It wins seven of nine general benchmarks for an average of 67.88 against 65.05, including MMLU Pro (89.05 vs 85.31), AIME 2026 (95.31 vs 92.08), HMMT 2026 (85.51 vs 78.50) and SimpleQA (28.90 vs 21.39). It loses UGD hard (73.02 vs 78.02) and HLE (19.11 vs 22.40). On scientific tasks it is far ahead — 52.14 average versus 18.20.

Can I use Intern-S2-Mobius through an API?

Not currently. No inference provider hosts it, there is no published pricing, and Hugging Face lists no deployment. Self-hosting with LMDeploy, vLLM, or Transformers is the only way to run it today.

What hardware do I need to run it?

The weights are about 73 GB in bfloat16, so plan on one 141 GB-class accelerator or two 80 GB GPUs, plus headroom for KV cache. InternLM's LMDeploy example uses tensor parallelism of 1; its vLLM example uses 2. Enabling MTP speculative decoding with four draft tokens is recommended.

What is its context length?

The configuration supports 262,144 tokens (256K). Note that InternLM evaluated at 128K on most text benchmarks and 64K on MMLU Pro, SimpleQA, and HLE, so validated quality at the full 256K has not been demonstrated.

Is it multimodal?

Yes. Hugging Face classifies it as image-text-to-text, and the config includes a 27-layer vision encoder with video token handling. However, InternLM published no multimodal benchmark results with this release, so the vision capability is undocumented in practice.

Why does it ship protein and SMILES tokenizers?

Because the Intern-S line is a scientific model family. Dedicated tokenizers for protein sequences, SMILES molecular notation, and nucleic acids mean the model reads those formats as native input types, which is why it scores 51.40 on Biology-Instructions where the baseline scores 3.77.

Is the license really Apache 2.0?

Yes — Apache 2.0, with the license file in the repository. Commercial use, modification, and redistribution are permitted, which is notably more permissive than many open-weight releases from large labs.

Should I use it in production?

Not yet. It is one week old, unhosted, unverified by any third party, and missing coding, multimodal, long-context, and safety evaluations. Treat it as an evaluation candidate for token-efficient reasoning or scientific sequence work, keep production traffic on established models through a vendor-neutral endpoint, and revisit when independent numbers exist.

Bottom line

Intern-S2-Mobius is one of the more genuinely interesting model releases of the year, and almost none of that has to do with its scores. InternLM took a real architectural idea — stop binding knowledge to layers, put it in one shared Memory, and let the model do part of its thinking in latent space instead of in tokens — scaled it to 35B, trained it properly, and released the weights under Apache 2.0 along with the technical report and the results that did not go its way. The efficiency mechanism is legible and the evidence for it is internally consistent: traces get 1.5x shorter on average and up to 5x shorter on knowledge-heavy tasks, and throughput rises in exactly the proportion you would predict from that.

The caveats are equally clear. Nobody outside Shanghai AI Laboratory has verified a single number. The comparison is against the model's own base and includes extra post-training, so it is not the clean ablation it resembles. The speedup largely vanishes on hard mathematics. The model loses on the two most demanding reasoning benchmarks in its own table. And there is no way to try it without renting GPUs.

So: not a model to deploy this week, but very much one to watch, and a genuinely attractive option for two specific audiences — teams whose reasoning bill is dominated by tokens nobody reads, and scientific groups who need a small, permissively licensed model that natively speaks proteins and molecules. Keep the production stack on proven models through a vendor-neutral endpoint like OrcaRouter, stand Mobius up on your own hardware for the narrow case, and measure tokens per correct answer rather than accuracy alone. If the architecture holds up under independent scrutiny, Mobius-v0 will be remembered less as a 35B model than as the version number before the one that mattered.