Intern-Decision-4B vs Qwen 3.8: A 44-Millisecond Forward Pass Against 2.4 Trillion Parameters

InternLM published Intern-Decision-4B on Hugging Face on the morning of September 26, 2026 — no launch post, no blog entry, a GitHub link on its own model card that returns 404 and a demo Space that returns 401. The weights are real and downloadable; the announcement is not there. And the model underneath them is a fine-tune of Qwen3.5-4B, which is what makes the comparison against the hosted flagship worth more than a spec sheet. These two are not rivals. They are the two ends of one pipeline, and the whole question is where the line between them falls. The underlying core is the 2.4-trillion-parameter model the vendor published in August and now serves as Qwen3.8-Max, billed at $2.00 and $6.00 per million tokens; Intern-Decision-4B is a 4.54-billion-parameter rebuild of that seven-month-old base model, which emits no tokens at all, answers up to sixteen typed questions in a single forward pass, and costs nothing per call because there is no output to bill for.

The one-line answer: if your task is a decision with a closed set of answers, Intern-Decision-4B is roughly fifty times faster per decision and structurally cheaper, and no frontier model will beat it on that narrow axis. If your task is anything else — reasoning, long context, tool use, anything where the answer is not already enumerated in your prompt — Qwen 3.8 is not merely better, it is the only one of the two that can do the job at all. Everything below is about finding that line precisely.

What is actually confirmed, and what is not

Start with the evidence, because the framing matters. There is no vendor announcement for Intern-Decision-4B. No press release, no paper, no repository description to read. What exists today is a Hugging Face repository published this morning under the internlm organization — Intern Large Models, the Shanghai AI Laboratory group — carrying the Apache 2.0 licence with the upstream Qwen licence preserved beside it as LICENSE-QWEN. Two sibling checkpoints appeared within forty seconds of each other: Intern-Decision-0.8B at 853 million parameters and Intern-Decision-2B at 2.21 billion. All three carry the same tags — decision-making, multimodal, structured-prediction — and all three sit under one model collection that does not yet resolve publicly.

What is not confirmed: whether this is the finished release or an early push. The repository was created at 05:36 UTC and modified again before 08:00 UTC the same day, and further public activity on the sibling checkpoints continued past 09:00. InternLM has not said what the intended deployment story is, has not published the repository it links to, and has not said whether a hosted endpoint is coming. Treat every benchmark figure in this article as vendor-reported and unreproduced — because as of this writing literally nothing else has been written about this model anywhere. Three separate search paths return nothing on the name.

The architectural bet: a scorer, not a generator

The most important sentence in Intern-Decision-4B's own documentation is a negative: the inference path "does not call generate() or sample free-form text." That is not an implementation detail, it is the entire design, and it is what separates this from calling Qwen3.8-Max with a JSON schema and hoping the brace closes.

Here is the mechanism, as the card describes it. You hand the model a shared state, a schema of named questions, and optionally up to eight images. Each question is one of three types: choice (pick one of an ordered set of options), score (rate on an ordinal scale, returned as a probability-weighted expected value), or noul (a binary no/yes). The system prompt, state, schema and a complete assistant JSON skeleton are rendered with one placeholder per field. Then — and this is the trick — the model runs one causal forward pass, and the logits are read at the position immediately before each placeholder. A softmax is taken over only that field's permitted candidate symbols, the checkpoint's calibration is applied, and the symbols are mapped back to your original option values.

The consequences are concrete. Because each field's answer space is assembled per request rather than baked into a vocabulary head, a schema you invent this afternoon needs no retraining — add a question, the options become candidate symbols for that field. Because there is no decoding loop, there is no output token, no brace to forget, and no retry logic around malformed JSON. And because all questions are scored off the same read of the state, sixteen questions cost one forward pass, not sixteen.

The limits are equally concrete, and the card states them without hedging. One to sixteen questions, up to 62 options per question, up to eight images. A default maximum of 8,192 tokens — and inputs that exceed it are rejected without truncation. That last clause is a design decision worth dwelling on: silent truncation is how a classifier quietly starts answering a different question than the one you asked, and InternLM has chosen to fail loudly instead. It is the right call, and it is also an operational trap, because a long ticket thread plus a schema plus images will blow past 8,192 sooner than you expect and there is no graceful path — you get an error.

Where Intern-Decision-4B wins, and it is not close

Two axes, and both are structural rather than incremental.

• Latency per decision — 44.16 ms mean, 44.03 ms median, 44.60 ms at p95, measured on a single RTX 4090 through the local Hugging Face path. Against Qwen3.8-Max, whose live seven-day window on our own playground shows a p50 of 2,474 ms and a p95 of 9,789 ms at 55.4 output tokens per second. That is roughly 56× at the median, and the comparison is not unfair so much as it is between two different operations: one model classifies, the other reasons and then writes. The gap is real and so is the reason for it.

• Cost per decision — and this one is arithmetic, not opinion. Take a realistic support-triage call: 800 input tokens of state and schema, and 150 output tokens of structured JSON. On Qwen3.8-Max that is 800 × $2.00/M plus 150 × $6.00/M, or about $0.0025 per decision, before a single reasoning token — and Qwen3.8-Max is a reasoning model, so the output side is optimistically small. A million decisions costs roughly $2,500. The same million decisions on Intern-Decision-4B cost zero in tokens and about 12.3 hours of RTX 4090 time. Intern-Decision-4B has no output price because it has no output.

The trade is honest and obvious: the 4B needs a GPU you own or rent, it occupies that GPU, and it can only ever do one thing. But if the one thing is what your product does millions of times a day, the arithmetic above is the entire business case, and no amount of frontier-model capability changes it.

The number Qwen 3.8 does not publish: calibration

This is the quiet differentiator, and it is the one most comparisons will miss because it does not look like a benchmark.

Intern-Decision-4B returns a distribution over your option values, not just a label — plus a confidence, and for noul questions the calibrated probability of yes. InternLM reports a Brier score of 0.347 and an expected calibration error of 0.065 across its own suite, and ships the fitted temperature in the checkpoint: 1.99241824, fitted separately for this size by negative log-likelihood minimisation on 1,728 designated calibration cases with 1,693 held-out validation cases. Test-suite labels were not used to select it. There is a second, independent 96-case diagnostic in the card using exact reference distributions rather than sampled labels, and it shows overall Brier/ECE moving from 0.628 / 0.213 before calibration to 0.550 / 0.089 after — the calibration step cutting expected error by well over half.

Now look for the same figure on the Qwen 3.8 side. It is not there. Alibaba publishes Artificial Analysis Index scores, GPQA Diamond, terminal-bench, SciCode, tau-banking and long-context recall — all capability measures. It publishes no calibration metric for any Qwen 3.8 family member, because a generative model's confidence is not a quantity the vendor ships. If your system needs a probability it can threshold on or route on rather than an answer it must trust, that difference is not a matter of degree. One model gives you a number with a documented error rate; the other gives you text, and you build your own confidence estimate around it.

Where Qwen 3.8 wins, and it is not close either

Set the two side by side on what they can be asked to do and the boundaries stop being subtle.

• Context — Qwen3.8-Max carries a 1,000,000-token window. Intern-Decision-4B rejects anything past 8,192. That is a factor of 122, and there is no workaround, because the input cap is enforced rather than truncated.

• Input modality — Qwen3.8-Max takes text, image and video. Intern-Decision-4B takes text and images, up to eight, and the image tokens count against the same 8,192 budget.

• Reasoning and tools — Qwen3.8-Max carries tool use, JSON mode and reasoning among its declared capabilities, and posts an Artificial Analysis Intelligence Index of 45.4, fifteenth of 145 models indexed, with an AA Coding score of 76.2 at ninth of 138. Those are independent figures published by Artificial Analysis, not vendor claims. Intern-Decision-4B has no Artificial Analysis entry, no independent score of any kind, and no capability to reason, plan, or call anything.

• Open-ended output — Qwen3.8-Max writes. Intern-Decision-4B cannot produce a paragraph, a rationale, or a plan. It can only score the options you already thought to list.

Worth noting on the open-weights side too: if you want the Qwen 3.8 core itself and not the hosted route, Qwen3.8-27B is the dense sibling — 27.8 billion parameters, Apache 2.0, a 262,144-token context, and roughly $0.33 / $2.40 per million tokens where it is served. It scores 33.7 on the AA Intelligence Index. It is still an order of magnitude larger than Intern-Decision-4B, still generative, and still the wrong tool for a closed-set decision at volume — but it is the honest middle option, and the only one of the three that is genuinely cheap and genuinely capable at once.

Reading InternLM's own benchmark table honestly

Intern-Decision-4B's card carries a comparison table, and what is absent from it is more informative than what is in it. The rows are Jev, Laya, SemIf, Kev, JevK5, and InternLM's own 0.8B and 2B. Every one of those is another System One or decision-model entry — Jev from TypeSafe AI, Laya from Convai Innovations, and three others. Every figure is vendor-reported on InternLM's own harnesses. There is no frontier model in the table at all.

That is not an oversight. It is the honest scope of the claim. Intern-Decision-4B's headline average of 90.02 across seven suites — Jevbench-Easy 100.00, Jevbench-Original 98.61, Jevbench-Hard 73.87, Typed Decision 80.55, ToolACE 96.45, AG News 90.82, WildJailBreak 89.86 — is a claim to lead the decision-model category, which it does on this table, beating Jev's 88.74 and Laya's 57.77. It is not a claim to compete with Qwen 3.8, and InternLM does not make that claim anywhere. The model card is scoped to its own category, and reading a category win as a capability win is the mistake this section exists to prevent.

Two more cautions. The latency figures — 44 ms mean on a 4090 — are vendor-measured, workload- and hardware-dependent, and a single-GPU forward pass is not the same measurement as a hosted API call including network round-trip and queueing. And the calibration pilot is 96 cases: a diagnostic, not a benchmark, and the card says so.

The deployment question, which is the real fork

Forget benchmarks for a moment and ask what each one asks of you operationally.

Intern-Decision-4B is roughly 9.1 GB on disk at bf16 — two language shards at 4.26 GB and 4.15 GB, a 612 MB vision tower, and a 54 MB projector. It loads through a 16 KB inference.py shipped in the repository itself, with a DecisionEngine class you instantiate once and reuse. One Python dict in, one response dict out, with a Python 3.12+ requirement. It runs at 44 ms on a 4090, and the 0.8B sibling is small enough to reason about on far less. But the module is the interface — there is no server, no OpenAI-compatible endpoint, and no hosted API. You are building the service around it, and if you need two of them for failover you are building that too.

The generative side of the same pipeline is a different decision entirely, and it is the one a router is actually for. Qwen3.8-Max and Qwen3.8-27B are both callable on OrcaRouter behind the same OpenAI-compatible key, at provider list price with 0% markup passed through — so when Alibaba moves a Qwen price, it is live on our side the same day rather than at the next billing cycle. Intern-Decision-4B is not one of our routes and will not be until InternLM hosts it somewhere; we are not going to pretend otherwise. What we cover is the half of this pipeline that is a network call: one key for 200+ models, automatic failover if Qwen3.8-Max degrades — its live seven-day error rate is 1.78% — and the ability to A/B the two Qwen 3.8 tiers against each other in the same request path before you commit to either.

Which is the pattern worth taking away. Run the scorer locally because it is cheap and fast and does one narrow thing well. Route the reasoning step, because that is where the vendor churn and the price cuts and the outages actually happen.

Which one you should actually pick

Pick Intern-Decision-4B if your decision is closed-set, your answers are enumerable in a prompt, you run the same decision at volume, and you care about the probability as much as the label. Ticket routing, content moderation against a fixed taxonomy, structured extraction into a schema you control, rating rubrics, binary gates — anything where a human could have written the option list in advance. The 4.54 billion parameters are honest about the ceiling: the card itself shows the 4B at 73.87 on Jevbench-Hard versus 100.00 on Easy, so the harder the decision shape, the more the small model gives up.

Pick Qwen 3.8 — meaning Qwen3.8-Max if you want the hosted core, Qwen3.8-27B if you want weights you can hold — if the answer is not enumerable in advance, if the input is longer than 8,192 tokens, if you need a rationale you can show a human, if you need tool calls, or if you need video. Also pick it if you simply do not want to operate a GPU: 12.3 hours of 4090 time per million decisions is cheap only if you already have the 4090 and something else to do with it the other 363 days.

Pick both if your pipeline is the shape most pipelines actually are — a cheap closed-set classifier in front, a frontier model behind it for the cases the classifier is unsure about. That is the configuration Intern-Decision-4B's calibrated confidence was built for, and it is the reason the ECE number above matters more than the headline average.

What to watch

Three open questions, all answerable within days. Does InternLM publish the GitHub repository its own card links to — currently a 404 — and with it a training description? Does an announcement follow the weights, converting a quiet push into a documented release? And does anything independent reproduce the 90.02 average, or the 0.347 Brier, on hardware that is not InternLM's?

There is one small inconsistency to note while you wait, because it is the kind of thing that matters when you are sizing a deployment. The model is named 4B. The parameter count is 4,539,265,536 — 4.54 billion. The 0.8B sibling is 853 million and the 2B sibling is 2.21 billion, both rounding up or down by a hair. Only the 4B rounds down by more than half a billion. It is not a problem. It is a reminder that in an unannounced release, the doc is the only spec you have, and even the doc is still being edited.