IBM released Granite 4.2 on Tuesday, August twenty fifth, 2026, a family of dense decoder only reasoning models at three billion, eight billion and thirty billion parameters, with the weights published under Apache 2.0. The novelty is not the sizes, it is the switch: every model can run in full thinking mode, non thinking mode, or a low effort mode that spends a short reasoning budget on easy questions. The eight and thirty billion versions also went through reinforcement learning inside real sandboxed environments, a software repository, a live shell, and live web search, rather than on static traces. That combination is unusual at these sizes.
The short answer
IBM published Granite 4.2 on August 25, 2026. Three dense models, each with a thinking, non thinking and low effort switch, a 128,000 token native context extending to 512,000, and native tool calling. Pre training ran on roughly 15 trillion tokens, supervised fine tuning on about 7.2 million samples, and the 8B and 30B went through agentic reinforcement learning in three live environments: a real repository through OpenHands, a shell through Terminus-2, and live web search. Weights are on Hugging Face, Ollama, LM Studio, OpenRouter and watsonx.
There is a size of model that matters more than the leaderboard suggests: the one you can actually run on hardware you own, inside a network you control, without asking anyone for permission. Granite 4.2 is aimed squarely at that slot, and the interesting engineering is in how the reasoning was trained rather than in the parameter counts.
Three modes, one deployment
Every Granite 4.2 model ships with a switch. Full thinking is the default, and the model emits a chain of thought inside think tags before answering. Non thinking skips it. Low effort allocates a short reasoning budget, on the reasonable theory that most questions do not need three hundred tokens of deliberation.
This sounds like a small feature and it is not, because reasoning tokens are the dominant cost line on any workload that talks a lot. Being able to set the mode per request means one served endpoint covers both the extraction job that runs ten thousand times an hour and the debugging session where you want the model to think properly. Previously that meant two models, two deployments, and two sets of prompts to maintain.
Native tool calling comes with it, which is the other half of running agents against a local model rather than a hosted one.
What agentic RL bought them
The training detail worth reading twice is where the reinforcement learning happened.
IBM pre trained each model from scratch on roughly 15 trillion tokens across five phases, the last of which stretched the context window. Supervised fine tuning followed on about 7.2 million samples, roughly 100 billion tokens of chain of thought, reasoning and agentic trajectory data. So far, standard.
Then the 8B and 30B went through agentic RL in three live environments. A software engineering agent worked on a real repository inside its own sandbox using the OpenHands harness. A terminal agent handled multi step tasks in a live shell through Terminus-2. A search agent answered hard multi hop questions using real web search tool calls.
The distinction between this and trajectory imitation is not academic. A model trained on recorded transcripts has mostly seen tasks going well, because that is what people record. A model trained in an environment has hit the failure modes: the command that returned nothing, the test that broke for an unrelated reason, the search that came back empty. Recovery behaviour is learned, not inferred, and recovery behaviour is most of what separates an agent that finishes from one that loops.
The numbers
IBM published scores that behave the way you would hope across the three sizes.
On AIME25, the 3B reaches 78.33 percent, the 8B 86.67 percent, and the 30B 89.17 percent. On MMLU-Pro, the run is 67.84, 74.04 and 77.60 percent. On SWE-bench Verified, only the two larger models are reported: 47.67 percent for the 8B and 57.00 percent for the 30B.
That last one deserves attention. A 30 billion parameter model with open weights resolving 57 percent of SWE-bench Verified is a model you can run locally that closes real issues in real repositories more than half the time. Eighteen months ago that was a hosted frontier capability with a per token price attached.
The 8B is arguably the more useful data point for most people, because 47.67 percent on SWE-bench Verified from a model that fits comfortably on a single consumer GPU changes what is reasonable to attempt on a laptop.
Architecture, context and the fine print
The models are dense decoder only transformers, not mixture of experts. The 8B uses grouped query attention with 32 attention heads and 8 key value heads, rotary position embeddings, SwiGLU activations with a hidden size of 12,800, and RMSNorm, in bfloat16.
Context is quoted as 128,000 tokens natively with a long context extension to 512,000. Treat those as two different confidence levels. The native figure is what the models were trained and evaluated against. The extension is real but is the kind of number that behaves worse in production than on a needle in a haystack test.
Twelve languages are listed: English, German, Spanish, French, Japanese, Portuguese, Arabic, Czech, Italian, Korean, Dutch and Chinese.
IBM also released Granite Speech 5.0 Turbo CTC variants at 470 million parameters, aimed at running on laptops and phones.
Why the licence is the headline for some readers
Apache 2.0 means you can download the weights, fine tune them on your own data, deploy the result commercially, and ship it inside a product, with no usage caps and no negotiation. That is a materially different proposition from the source available licences that dominate the open weight conversation.
For anyone operating under data residency rules, that is often the whole decision. The model never has to be as good as the best hosted option, it has to be good enough while running on infrastructure the compliance team already signed off on. The steady growth of open weight deployment, visible in things like Gemma passing a billion downloads, is mostly this dynamic rather than a preference for openness in the abstract.
It also sits oddly against the rest of IBM's week, which included putting Arm instructions inside a mainframe core. The same company is arguing both that you should run models on hardware you own and that its most proprietary hardware line has a future. Both can be true.
What we would actually do with it
Pull the 8B first. It is the size where the agentic RL work is present and the hardware requirement is still modest, and it is the one that will tell you quickly whether the tool calling behaviour holds up on your own stack.
Test the low effort mode specifically. That is the mode with the least published evidence behind it and the most operational upside, since it is the one that decides whether a high volume workload is affordable.
And check the licence against your legal constraints before you benchmark anything, because on this family the licence is the differentiator and the benchmarks are merely competitive.
Sources and further reading
- Granite 4.2 brings native reasoning to enterprise agents, IBM Research, August 25, 2026
- Granite 4.2 LLMs: How They're Built, IBM Granite on Hugging Face, August 25, 2026
- ibm-granite/granite-4.2-8b model card, Hugging Face
- IBM Releases Granite 4.2: Bringing Native Reasoning and Agentic RL to Open Enterprise Models, MarkTechPost, August 25, 2026
- IBM's Granite 4.2 Models Learn to Think and Act Inside Environments, Unite.ai
Frequently asked questions
What does the thinking switch actually change at runtime?
It changes whether the model emits a chain of thought inside think tags before its answer, and how long that chain is allowed to run. Three modes ship: full thinking as the default, non thinking for when you want the answer with no preamble and no extra tokens, and low effort, which allocates a short reasoning budget for easy questions. The practical value is cost control. Reasoning tokens are billed like any other tokens and they dominate the bill on a chatty workload, so being able to turn the reasoning off per request rather than swapping to a different model endpoint is a real operational convenience. It means one deployment can serve both a classification job and a debugging session.
What is agentic RL and why does it matter here?
Most instruction tuned models learn tool use from recorded trajectories: someone else did the task, the transcript became training data. Agentic RL puts the model in the environment and rewards it on outcomes. IBM ran three of them for the 8B and 30B. A software engineering agent worked on a real repository in its own sandbox through the OpenHands harness. A terminal agent handled multi step tasks in a live shell using Terminus-2. A search agent answered hard multi hop questions with live web search tool calls. The difference shows up when a tool call fails or returns something unexpected, because a model trained on clean transcripts has rarely seen recovery and a model trained in an environment has.
What context window do these models actually have?
The model cards state 128,000 tokens natively, with a long context extension to 512,000 tokens. Those are two different claims and worth keeping apart. The 128,000 figure is what the models were trained and evaluated to handle reliably. The 512,000 extension comes from the fifth phase of pre training, which stretched the window, and it is the number to treat with more caution in production. In practice, if you are feeding a 3B model half a million tokens you have an architecture problem rather than a context problem. Retrieval remains cheaper and more predictable than very long prompts at every model size.
How do the benchmark numbers look?
IBM published scores that scale sensibly with size. On AIME25, the 3B scores 78.33 percent, the 8B 86.67 percent, and the 30B 89.17 percent. On MMLU-Pro the run is 67.84, 74.04 and 77.60 percent respectively. On SWE-bench Verified, which is the one that matters if you care about agents doing real repository work, the 8B lands at 47.67 percent and the 30B at 57.00 percent. That 30B figure is the interesting one, because a model you can run on a single well specified workstation resolving over half of SWE-bench Verified would have been a frontier result not long ago.
Where can I get them and what does Apache 2.0 permit?
Hugging Face, Ollama, GitHub, LM Studio, OpenRouter, Replicate, DeepInfra, AnythingLLM and IBM watsonx, among others. Apache 2.0 is a genuine open source licence rather than a source available one with usage restrictions attached, which means you can download the weights, fine tune them, redeploy the result commercially and ship it inside a product without negotiating anything. That distinction is the reason Granite keeps appearing in regulated environments. For a bank or a hospital, the licence question is often decided before the benchmark question is even asked.