Granite 4.2 3B is out: IBM's laptop-sized reasoning model claims 78.33 on AIME 2025

You can run Granite 4.2 3B on a laptop tonight. That is the practical fact under the headline number: IBM released Granite 4.2 3B on August 25, 2026 under an Apache-2.0 license, as the smallest of the three dense reasoning models in the new Granite 4.2 family — Granite 4.2 3B, Granite 4.2 8B, and Granite 4.2 30B — and its model card claims 78.33 on AIME 2025, a math-reasoning score that a few years ago belonged only to models a hundred times its size. The weights run to roughly 3 billion parameters: six to eight gigabytes in bfloat16, under two gigabytes at a practical quantization. That is the whole point of this release — a reasoning model that used to be a datacenter purchase now fits in a bag.

The honest framing has to sit next to that. Every number on the card is IBM's own, printed the day the weights went up, and no independent lab has reproduced any of them. There is no hosted API yet — the card lists no inference provider — so the only way to meet this model today is to run it yourself or wait for a hosted tier to appear. This is a what-we-know-now readout of the smallest member of the family, which means being precise about which claims the repository actually supports.

What shipped, and how quietly

Granite 4.2 is IBM's reasoning generation — the first Granite family built around explicit chain-of-thought, and the first to add agentic training at scale on its larger members. All three sizes are dense, decoder-only Transformers under Apache 2.0, pre-trained on roughly 15 trillion tokens across five phases, and all run at 128K native context with a long-context extension to 512K. The announcement was not a press rollout: the primary source is the Hugging Face technical blog, "Granite 4.2 LLMs: How They're Built," published alongside the model cards on August 25. Chinese tech press picked the family up within hours, and Ollama already lists a granite4.2:3b build.

What makes the 3B the edge member

The 3B is post-trained from Granite-4.1-3B-Base, and what distinguishes it from its siblings is what it does not have. The Granite 4.2 8B and Granite 4.2 30B both received IBM's agentic reinforcement learning — training that teaches a model to operate a terminal, run code, and search the web inside sandboxed environments, which is why those two carry SWE-Bench and Terminal-Bench scores. The 3B skips that block entirely; its card reports no SWE-Bench or Terminal-Bench results because the agentic-RL harness was never trained into it.

What the 3B keeps is the reasoning core and the interface:

• Parameters — 3B (about 4B total with embeddings per the safetensors metadata), dense decoder-only Transformer built on Granite-4.1-3B-Base.

• Architecture — grouped-query attention (40 heads, 8 KV heads), RoPE at θ=10,000,000, SwiGLU MLP (hidden size 8,192), RMSNorm, bfloat16.

• Context — 131,072 tokens natively; a fifth pre-training phase extends the window to 512K.

• Reasoning modes — full thinking by default (<think>...</think>), non-thinking via enable_thinking=False, and a low-effort mode that spends a short reasoning budget on easy questions.

• Tool calling — OpenAI-compatible function calling, the same schema the larger siblings use, served through a vLLM endpoint; OpenHands, OpenCode, and Pi integrations are documented.

• Languages — 12 tested: English, German, Spanish, French, Japanese, Portuguese, Arabic, Czech, Italian, Korean, Dutch, Chinese.

• Serving — Hugging Face Transformers, vLLM (v0.20+ with a dedicated thinking parser), SGLang, GGUF builds for llama.cpp, FP8/NVFP4/MXFP4 quantizations, and Ollama.

The vendor-reported numbers

The card lists strong reasoning scores, and every one of them is IBM's own. On math and reasoning evals the 3B lists 78.33 on AIME 2025, 66.67 on HMMT February 2025, 54.80 on GPQA, and 69.71 on LiveCodeBench v6. On instruction following: 67.84 on MMLU-Pro and 74.33 on IFBench. On long context, RULER scores are 67.52 at 64K and 55.30 at 128K. On the agentic-general evals the 3B does carry — basic tool use, without the agentic-RL block — it lists 52.41 on BFCL v4.

None of this has been independently reproduced. The model shipped on August 25; Artificial Analysis has no entry for it yet, and no third-party evaluation has published. The 78.33 AIME figure is the one to watch: for a 3B-class dense model it sits far above the range small open models have historically reached, and an on-paper number like that is exactly what a reproduction run either confirms or quietly walks back. Treat every figure in this section as IBM's claim.

What is confirmed, and what is not

Confirmed by the artifacts: the weights are downloadable; the license is Apache 2.0; the architecture, context lengths, reasoning modes, and tool-calling interface match the card; and the training recipe is documented in unusual detail, down to data proportions and the NVIDIA GB200 NVL72 cluster (hosted by CoreWeave) used to train the family. Confirmed by release-day integration work: Ollama already lists granite4.2:3b, and the card documents vLLM, SGLang, Transformers, and GGUF serving paths.

Not yet confirmed: independent benchmark results; whether a hosted API — IBM's own watsonx or any third party — will appear and at what price; how the 512K extension behaves on real long-document workloads rather than RULER needle tests; and how the 3B's basic tool calling holds up in production agent loops where it has no agentic-RL training to lean on.

Where the 3B competes, and how to test it

The 3B's bet is that small and local is a feature, not a compromise. Below it the family stops — the 3B is the floor of the Granite 4.2 line — and around it the budget-reasoning field is thick on the hosted side, with DeepSeek V4 Flash and Gemini 3.5 Flash-Lite anchoring the cheap hosted reasoning tiers and small open-weight reasoning models arriving all year. The 3B is different from all of them in one specific way: it is dense, Apache-2.0, and small enough that the marginal cost of a request is the electricity of one modest GPU — and it is also new, unproven, and without a single third-party evaluation.

That combination is exactly where a routing layer earns its keep. OrcaRouter does not route Granite 4.2 3B — the honest availability line is self-hosting via vLLM, SGLang, or Ollama, or IBM's own channels as they appear — but the hosted models it competes with are on OrcaRouter at the provider's list price, passed through with 0% markup, behind one API key. If you are building the comparison harness that decides whether the 3B's local reasoning beats renting a hosted budget model, one key points at the hosted field, you A/B it against a self-hosted Granite through a single endpoint, and automatic failover absorbs the hours your own GPU pool is saturated. A price cut on those hosted alternatives shows up in the passed-through price the same day it happens.

What to watch

Three things will decide how this release is remembered. First, an independent reproduction of the AIME and GPQA numbers — the gap between 78.33 on a card and 78.33 on a third-party run is where small-model claims live or die. Second, whether watsonx or another host picks the 3B up and at what per-token price; a sub-2-gigabyte quantized reasoning model could make a strikingly cheap hosted tier. Third, whether the low-effort reasoning mode keeps quality on easy questions, because that mode is what makes a laptop-sized reasoning model usable in real product traffic. Granite 4.2 3B is a genuinely open, well-documented reasoning model that shipped quietly and can be running on your hardware by tomorrow; the open questions all have answers coming within weeks.