On August 25, 2026, IBM released Granite 4.2, a family of open-weight reasoning language models in three sizes (3B, 8B, and 30B parameters) under the Apache 2.0 license. The models are purpose-built for enterprise agentic workflows, introducing native thinking capabilities and a multi-stage reinforcement learning training pipeline conducted inside real software engineering, terminal, and web-search environments.
For enterprise teams building AI agents, this release matters for three reasons: the Apache 2.0 license removes cost uncertainty at scale, the environment-grounded training is the most rigorous IBM has applied to an open-weight family, and the 30B model is explicitly sized for a single multi-GPU serving node rather than a large cluster.
What IBM Actually Built and Why It Is Different
Granite 4.2 is not a fine-tune of an external model. IBM trained the family from a Granite 4.1 base, extending context to 512K tokens over a five-phase pre-training schedule on approximately 15 trillion tokens. Supervised fine-tuning followed on roughly 7.2 million samples covering chain-of-thought, reasoning, and agentic trajectory data.
The core engineering work sits in the reinforcement learning pipeline. IBM describes a multi-stage RL regimen where each stage is a separate training run that warm-starts from the previous stage’s checkpoint. All three sizes run “foundational RL” targeting mathematics, science, coding, and tool-calling, using verifiable rewards (math answers checked by rule, code graded by hidden test suites, instruction formatting checked automatically) alongside reward-model evaluation.
The 8B and 30B models then continue into a three-stage “agentic RL” block that no prior Granite generation received:
- Software engineering (via the OpenHands harness): the model edits real code repositories and passes only if the hidden test suite passes.
- Terminal-based coding: the model works inside a live shell with up to 64 environment turns per rollout.
- Web search: the model answers multi-hop questions through live search calls, scored by an LLM judge.
This is environment-grounded training, not simulated environments. The practical consequence is that the 30B model learned to complete software engineering tasks by actually running them, not by predicting what completions look like.
The 3B model, which received foundational RL but not the agentic block, is positioned for high-throughput routing tasks and edge deployments where reasoning depth matters less than throughput and cost.
Benchmarks: What IBM Reports
IBM evaluated the family on agentic coding, general tool use, reasoning, chat, and long context using the NeMo Evaluator SDK framework. The company published these figures alongside the weights:
| Benchmark | Granite 4.2 3B | Granite 4.2 8B | Granite 4.2 30B |
|---|---|---|---|
| SWE-Bench Verified | N/A | 47.67 | 57.00 |
| Terminal-Bench 2.1 | N/A | 20.56 | 29.24 |
| AIME25 (math) | 78.33 | 86.67 | 89.17 |
| GPQA Diamond (science) | 54.80 | 64.14 | 66.41 |
| RULER 128K (long context) | 55.30 | 71.41 | 81.38 |
The pattern is consistent with the training design. The benchmarks that require the agentic RL block (SWE-Bench, Terminal-Bench) show the widest performance gap between the 3B and the larger sizes. The 3B model is not evaluated on SWE-Bench or Terminal-Bench at all, reflecting IBM’s positioning of that size as a routing and light-workload model rather than a deep reasoning agent.
A 57.00 on SWE-Bench Verified for a 30B open-weight model is a meaningful result. For context, IBM’s earlier deal with Together AI was built around running external open-weight models (DeepSeek, Kimi, Nemotron) because IBM did not yet have a competitive open-weight model for complex coding tasks. Granite 4.2 changes that calculus internally.
The Switchable Thinking Mode: What Enterprises Need to Know
Every Granite 4.2 model exposes three operating modes via its chat template:
- Thinking mode (default): produces a full reasoning chain inside dedicated tags, then the final answer. This is the mode to use for ambiguous multi-step tasks where auditability of the reasoning path matters.
- Non-thinking mode: answers directly with no visible chain of thought. Lower latency, useful for high-volume routing or classification steps where reasoning is not needed.
- Low-effort mode: spends a bounded reasoning budget. Positioned between the two for queries of moderate complexity.
In multi-turn conversations, prior turns’ thinking traces are stripped by default. This matters for production deployments: a 512K context window fills quickly if every agent turn retains its full reasoning chain. IBM’s default behavior avoids that cost without requiring application-level context management.
Native tool calling is built into the same chat template, outputting in OpenAI function-calling format. Granite 4.2 integrates directly with vLLM and SGLang without adapter layers, which means enterprises already running open-weight inference infrastructure do not need to add new serving components.
What This Means for Enterprise Agent Builders
The practical implications for teams building production agents are concrete.
Cost floor drops for agent loops. Agentic workloads are token-intensive. Each loop iteration involves reading context, reasoning about next steps, calling tools, processing results, and producing an output. At frontier-model pricing, this adds up quickly. With Apache 2.0 weights and commodity GPU serving via vLLM, the per-token cost is determined by infrastructure economics, not by model provider pricing tiers. For teams running millions of agent steps per day, this matters more than benchmark rankings.
The 3B model is a viable router. Multi-model routing, where a small classifier decides which model handles each incoming request, has become a standard cost-reduction pattern. The Granite 4.2 3B, trained with foundational RL on tool-calling and reasoning, is a plausible router for determining whether a query needs the 30B model, a 8B model, or no LLM at all.
30B fits a single node. IBM explicitly sized the flagship for deployment on a single multi-GPU serving node. This is a production-first design decision. A model that requires multi-node serving introduces coordination overhead, higher infrastructure costs, and more failure points. A 30B model that fits on one well-configured node simplifies the deployment footprint for teams that want frontier-adjacent performance without frontier-scale infrastructure.
RL-trained tool-calling is architecturally different from fine-tuned tool-calling. Models that learned to call tools through supervised fine-tuning on human demonstrations have a different failure mode profile than models trained by actually succeeding or failing at tasks in live environments. The agentic RL block means Granite 4.2 30B has been rewarded specifically for completing software engineering tasks, not for producing plausible-looking tool calls.
Additional Components in the August 25 Release
IBM released two Granite Speech 5.0 Turbo CTC models alongside the language models. At 470 million parameters each, these are among the smallest in the Granite family, built for edge deployment on laptops and smartphones. They use connectionist temporal classification without an LLM backbone, making them efficient at streaming audio transcription. IBM positioned this as a structural leap from Granite Speech 4.1 rather than an incremental update.
IBM is also working with Hirundo to reduce undesirable outputs post-training using machine unlearning techniques. This avoids full retraining when specific output behaviors need to be reduced or removed, which is relevant for enterprises that need to customize model behavior for regulated industries.
Where Granite 4.2 Sits in the Open-Weight Enterprise Landscape
The open-weight enterprise AI market has grown significantly more competitive over the past two months. Alibaba’s Qwen3.8-27B brought comparable math and reasoning performance in a smaller parameter count. Meta’s Muse Glimmer came with Apache 2.0 licensing for local agent use cases. DeepSeek V4 Pro reset expectations on coding at open-source prices.
Granite 4.2 occupies a distinct position: it is the only open-weight family where the flagship was trained through reinforcement learning inside live software engineering environments using the OpenHands harness, not simulated analogs. Whether that distinction translates to meaningfully better production performance on real enterprise codebases is something deployment will answer better than benchmarks.
What is certain is that enterprises now have multiple credible paths to agentic AI that do not require closed-model subscriptions. The agentic enterprise index published by Salesforce in August showed that enterprise agent deployment grew 340% year-over-year in the first half of 2026. The economics of that growth depend heavily on the cost of inference per agent step. Open-weight models like Granite 4.2, deployable on-premises under Apache 2.0 with no licensing overhead, are part of how enterprises are managing that cost.
IBM published the full training recipe, data-mixture proportions, and per-stage hyperparameters alongside the weights. All three sizes are available on Hugging Face. Deployment documentation covers vLLM and SGLang serving, with the 30B model card confirming the flagship was post-trained from the Granite 4.1 30B base.