SearchBook a call

BULLETIN / IBM

IBM Granite 4.2: review

IBM's Granite 4.2 gives small Apache-2.0 models with switchable reasoning for local use, but has no Indic support and little independent testing.

A sensible, well-licensed small model for local agents and tools, with thin independent evidence so far.

Maker
IBM
Released
25 Aug 2026
Licence
Apache-2.0
Access
Open weights (Hugging Face, Ollama, LM Studio), watsonx, OpenRouter, Replicate and other hosts
Context
128K tokens native, extendable to 512K (8B model card)

Good at

  • Small sizes that run locally
  • Switchable reasoning (full, low, off)
  • Tool calling for enterprise agents
  • Long context for its size

Bad at

  • No Indian languages in the supported list
  • Little independent evaluation
  • Card warns of inaccurate or biased output
  • No independent coding results

Use it for

  • Local classification, routing and extraction
  • Enterprise agents on private infrastructure
  • Teams that want a US vendor with a clean licence

Avoid it for

  • Indic language products
  • Coding and reasoning tasks you have not tested yourself
  • Image input

Yes, for small local jobs where licence and control matter. IBM Granite 4.2 comes in 3B, 8B and 30B sizes under Apache 2.0, with reasoning you can switch on, down or off per request. We could not find a reliable independent evaluation of it yet, and its supported languages exclude every Indian language, so test it on your own task first.

First principles

  • Parameters set the memory bill. A model’s weights must sit in memory to run. At 16-bit precision each parameter takes two bytes, so the 8B model needs about 16GB for its weights and the 3B about 6GB. Builds quantised to 4 bits, a common choice for GGUF files, need roughly a quarter of that, which is what brings these sizes within reach of a laptop.
  • Thinking costs time. Reasoning tokens are generated before the answer, so every request pays for them in delay and compute, whether the question needed them or not. A simple label needs none and a hard case may need many, which is the case for a per-request switch.
  • A model is dependable only in the languages it was built for. The supported language list is the vendor’s own boundary. Outside it, quality is unknown, which is why we do not recommend Granite for Indian languages.
  • Vendor numbers are the vendor’s best case. The vendor chooses the tests, the settings and when to measure. Until someone else repeats them, treat IBM’s scores as claims to check, not results to rely on.

What it is

Granite 4.2 is IBM’s small open model family, released on 25 August 2026. There are three dense text models at 3B, 8B and 30B parameters. IBM released a speech recognition model, Granite Speech 5.0 Turbo CTC, at the same time.

The 8B model card gives a native context of 128K tokens, extendable to 512K. Reasoning has three modes: full thinking (the default), a low-effort mode, and non-thinking for direct answers. IBM trained the reasoning with reinforcement learning phases aimed at agent work.

The card lists 12 languages: English, German, Spanish, French, Japanese, Portuguese, Arabic, Czech, Italian, Korean, Dutch and Chinese. Its intended uses include reasoning, code generation, tool calling, agent workflows and multilingual dialogue.

Where it is good

Size and distribution. IBM publishes the weights on Hugging Face, including GGUF builds for llama.cpp-style tools, and lists Ollama, LM Studio, watsonx, OpenRouter, Replicate and others. On our reading, a 3B or 8B model is small enough for an ordinary laptop, which suits the small decision and routing models many teams now build.

Switchable reasoning. Being able to turn thinking off per request is useful for small models. You can use direct answers for simple labelling and full reasoning for the rare hard case, without switching models.

Vendor-reported scores are good for the size. For the 8B, IBM reports:

  • 86.67 on AIME25 (maths)
  • 74.04 on MMLU-Pro (knowledge)
  • 64.14 on GPQA (science)
  • 47.67 on SWE Bench Verified (coding, built from real GitHub issues)

All of these are vendor-reported. They suggest a strong 8B model, but no independent source we read confirms them.

Licence. Apache 2.0, with no user thresholds. For an organisation that must justify its supplier, an enterprise vendor based in the United States (US) with a plain licence is easy to approve.

Speech. IBM reports that in its own testing Granite Speech 5.0 Turbo CTC reached an inverse real-time factor (RTFx), the seconds of audio transcribed per second of compute, of about 12,600. It compares this with about 6,000 for the current speed leaders on the Hugging Face Open ASR Leaderboard, which ranks automatic speech recognition (ASR) models. That is IBM’s report, not our own reading of the board.

Where it is bad

Little independent evidence. We did not find a Granite 4.2 score on Artificial Analysis, so we report none. Granite did not appear in the Vals Index or the Arena rankings we read. Until that changes, the only numbers are IBM’s own.

No Indian languages. None of the 12 supported languages is Indian. For Hindi, Tamil, Bengali or other Indic work, Sarvam’s models or Gemma 4 are better starting points.

Reliability. The model card warns that the model may sometimes give inaccurate, biased or unsafe answers. As with most small models, treat outputs as drafts in anything high-stakes.

Coding is untested by anyone else. The only coding score we have is the vendor-reported 47.67 on SWE Bench Verified for the 8B, and no independent source confirms it.

No image input. The 8B card describes a text-only model. Gemma 4 and Qwen3.8-27B read images at similar sizes.

Price and access

The weights are free to download. IBM’s announcement did not give a hosted application programming interface (API) price we could confirm, so we give none. Self-hosting cost depends on your hardware; on our reading, the 3B and 8B sizes are small enough for a single consumer graphics processing unit (GPU) or a laptop.

Size Type Context Licence
Granite 4.2 3B Dense text Not checked Apache 2.0
Granite 4.2 8B Dense text 128K native, up to 512K Apache 2.0
Granite 4.2 30B Dense text Not checked Apache 2.0

Who should use it

On this evidence Granite 4.2 is a good candidate for small, private tasks in its supported languages: routing requests, extracting fields, tagging documents and driving simple tool-using agents. It is a poor fit for Indic languages or images, and we have no independent evidence for hard coding. Run your own evaluation before committing, because independent results are not yet available.

Sources