IBM has released Granite 4.2, a family of open reasoning language models in 3B, 8B, and 30B parameter sizes. Unlike earlier Granite releases, which were built as instruction-following assistants, Granite 4.2 places explicit reasoning at the center: every model can emit a chain of thought before answering, and every model exposes a runtime switch for thinking, low-effort, or non-thinking behavior. All three language models ship under Apache 2.0, and IBM paired them with two Granite Speech 5.0 Turbo CTC models designed for high-throughput speech transcription.
What is IBM Granite 4.2?
IBM Granite 4.2 is an open-weights family of dense, decoder-only language models trained from scratch and optimized for reasoning, tool use, and agentic workflows. The 8B and 30B models go further than the 3B: they include an agentic reinforcement learning stage in which the models learn to edit code, drive a terminal, and run web searches inside real sandboxed environments. The entire collection is available under Apache 2.0, which permits download, fine-tuning, and commercial deployment without a licensing gate.
The reason Granite 4.2 matters is not just the benchmark scores. IBM has packaged what was previously scattered across research papers and internal tooling into a single, reusable family: native chain-of-thought reasoning, a controllable thinking budget, and agentic capabilities trained through a multi-stage reinforcement learning chain rather than through prompt engineering alone.
How does the Granite 4.2 thinking switch work?
The thinking switch is exposed through the model’s chat template. When enable_thinking is true, the model generates an explicit chain of thought before its final answer. When low_effort is true, it spends a shorter, capped reasoning budget, which makes it useful for straightforward questions that do not require deep deliberation. When both are disabled, the model answers directly without a visible reasoning trace. In multi-turn conversations, prior turns are stripped by default through truncate_history_thinking=True, a design choice that prevents the model from relying on latent reasoning left over from earlier turns.
This flexibility is rare in a single open model family. Teams can route easy queries to non-thinking mode for low latency, send complex coding or math problems to full thinking mode, and reserve low-effort mode for intermediate cases where speed still matters but a little reasoning helps.
Architecture: dense transformers, long context, and 15 trillion pre-training tokens
Granite 4.2 is not a mixture-of-experts or hybrid design. It is a decoder-only dense transformer with Grouped Query Attention using 8 KV heads, rotary position embeddings with a high base value of 10,000,000, SwiGLU MLPs, RMSNorm with epsilon 1e-5, untied input and output embeddings, and bfloat16 precision. The dense architecture keeps the models straightforward to deploy and fine-tune on conventional training and inference stacks.
Each size has a distinct structural profile. The 3B model uses 40 layers with an embedding size of 2,560. The 8B model also uses 40 layers but increases the embedding size to 4,096. The 30B model scales to 64 layers with an MLP hidden size of 32,768. The published architecture table lists a 131,072-token sequence length, equivalent to 128K context, while the five-phase pre-training run includes a long-context phase extending to 512K tokens. Pre-training consumed roughly 15 trillion tokens from scratch, which gives Granite 4.2 a broad foundation before any instruction tuning or reinforcement learning begins.
IBM also layered in two supporting technologies: 1 trillion tokens of synthetic code produced by the CodeAlchemy pipeline, and a speculative decoding layer designed to accelerate serving. The synthetic code component is particularly important for coding and agentic behavior, because it expands the model’s experience beyond what naturally occurring repositories can provide.
A post-training pipeline built from staged reinforcement learning
The training pipeline is the real technical centerpiece of Granite 4.2. Before reinforcement learning, IBM constructed a supervised fine-tuning mixture of approximately 7.2 million samples, roughly 100 billion tokens with about 65 billion trainable. The mixture is 31.6% agentic and 68.4% non-agentic, and software engineering accounts for 69% of the agentic slice. Trajectories were generated across a wide range of harnesses, including OpenHands, SWE-agent, Terminus-2, MiniSWE, Codex, and Goose. Quality control used GPT-OSS-120B and Gemma 4 as judges, plus SHA-256 deduplication over the tools and messages fields to remove near-duplicate trajectories.
Post-training is not a single RLHF pass. It is a multi-stage, multi-environment reinforcement learning chain in which each stage is a separate asynchronous GRPO run that warm-starts from the previous checkpoint. The design uses a leave-one-out baseline instead of a value network and truncated importance sampling to bound off-policy drift. IBM’s order is RLVR, skill boosters, SWE, Terminal, Search, and then RLHF. Each stage targets a different capability: verifiable reward tasks first to establish core reasoning, then focused skill boosters, then software engineering tasks, then terminal-driven agent work, then web-search question answering, and finally safety alignment with a reasoning-length penalty to curb verbose chain-of-thought outputs.
The agentic RL block is what separates the 8B and 30B from the 3B. SWE tasks run in per-repository sandboxes, terminal tasks run in live shell environments, and search tasks are answered inside a web-search browsing loop. The models are trained not only to produce correct final answers but to operate through a multi-turn agent loop: read a repository, edit a file, run a command, observe the output, and adjust. That is a different skill profile from standard instruction following, and it explains why the larger Granite 4.2 models post competitive scores on agentic coding benchmarks.
Why did IBM limit agentic RL to the 8B and 30B?
IBM restricted the SWE, Terminal, and Search agentic blocks to the two larger models because that kind of multi-turn, tool-based training is expensive and requires enough model capacity to generalize from sandboxed trajectories. The 3B still receives foundational RL and alignment, which keeps its reasoning strong but leaves it without the specialized agentic behavior. This design decision is visible in the benchmark tables: the 3B scores well on reasoning tasks but has no listed scores on SWE-Bench or Terminal-Bench, while the 8B and 30B carry the agentic workloads.
The training itself ran on NeMo-RL and NeMo-Gym over an NVIDIA GB200 NVL72 cluster hosted by CoreWeave. The infrastructure choice matters because staged RL with real sandboxed environments is data-intensive and requires tightly coupled scheduling across many GPUs. By publishing the recipe, IBM gives the broader open-model community a concrete template for turning a base model into an agentic model, not just a chatbot.
Granite 4.2 benchmarks: coding agents, tool use, reasoning, and long-context recall
IBM’s reported results paint a consistent picture. The 30B is the flagship across almost every category, the 8B is close on several reasoning tasks, and the 3B is a compact reasoning specialist that cannot match the larger models on agentic coding.
IBM’s reported benchmark results by size:
- Agentic coding: SWE-Bench Verified — 8B 47.67, 30B 57.00; SWE-Bench Multilingual — 8B 30.78, 30B 41.89; SWE-Bench Pro — 8B 19.11, 30B 33.29; Terminal-Bench 2.1 — 8B 20.56, 30B 29.24. No 3B score was listed for these agentic coding environments.
- Agentic and tool use: tau3-bench — 3B 50.99, 8B 66.34, 30B 68.05; BFCL (v4) — 3B 52.41, 8B 50.29, 30B 61.39; ProfBench — 3B 32.10, 8B 41.20, 30B 42.90; BirdBench — no 3B score listed, 8B 41.07, 30B 41.85.
- Reasoning and STEM: AIME25 — 3B 78.33, 8B 86.67, 30B 89.17; HMMT Feb25 — 3B 66.67, 8B 78.33, 30B 89.17; GPQA — 3B 54.80, 8B 64.14, 30B 66.41; LiveCodeBench v6 — 3B 69.71, 8B 73.24, 30B 75.77; SciCode — 3B 24.11, 8B 36.09, 30B 38.76; MMLU-Pro — 3B 67.84, 8B 74.04, 30B 77.60; Arena-Hard-V2 — 3B 34.96, 8B 65.19, 30B 67.93.
- Long-context recall: RULER 64K — 3B 67.52, 8B 80.99, 30B 89.96; RULER 128K — 3B 55.30, 8B 71.41, 30B 81.38.
The 30B model’s SWE-Bench Verified score of 57.00 is particularly notable for an open-weights model because that benchmark measures real software engineering behavior rather than single-token code completion. The 8B model also holds up well, especially on tau3-bench and LiveCodeBench, which suggests that agentic RL can lift tool use substantially at the 8B scale.
Deployment choices: from a developer laptop to an enterprise GPU cluster
Because every Granite 4.2 language model ships under Apache 2.0, deployment is flexible across hardware and licensing environments. The 3B model fits solo developers and startups running on a laptop through Ollama or LM Studio, particularly with the released GGUF quants down to Q4_K_M. The 8B model suits mid-market teams on a single modern GPU. The 30B model targets enterprises with A100 or H100-class capacity, or FP8 and NVFP4 serving through vLLM. Regulated organizations get the added benefit of running the weights on-premises without sending data to an external API.
The application range is broad. Software engineering agents, terminal and DevOps automation, deep-research and search agents, long-document RAG, structured tool calling, and high-volume transcription all fit within the Granite 4.2 family. Because the models emit OpenAI-format function calls over an OpenAI-compatible endpoint, they can be dropped into existing agent harnesses without custom adapters.
For engineering teams, the practical route is clear: start with the 3B for local development and lightweight reasoning tasks, move to the 8B for tool use and coding assistance on a single GPU, and reserve the 30B for the most demanding agentic workloads where autonomous behavior and long-context accuracy justify the infrastructure cost.
Granite Speech 5.0 Turbo CTC pairs low latency with high throughput
IBM also released two Granite Speech 5.0 Turbo CTC models alongside the LLMs. These models come in at 470 million parameters and drop the LLM backbone entirely, using connectionist temporal classification to map audio directly to text. IBM reports an RTFx throughput close to 12,600 on a single H200, compared with roughly 6,000 for current speed leaders on the Open ASR leaderboard. A WebGPU demo is live, which means the speech capability can be evaluated directly in a browser.
The speech release is aimed at latency-sensitive and cost-sensitive workloads: contact-center transcription, real-time voice agents, and high-volume audio processing. The lack of an LLM backbone keeps the model small and fast, while the CTC architecture provides stable, streaming-friendly transcription performance.
What Granite 4.2 signals for open reasoning models
Granite 4.2 is more than a new checkpoint family. It is a packaging of a training methodology: controlled reasoning, staged reinforcement learning, and agentic behavior are now available in an open-weights format that enterprises can deploy. IBM’s decision to put agentic RL only on the 8B and 30B is both a cost constraint and a product segmentation strategy; the 3B remains a strong reasoning model for local use, while the larger models carry the autonomous software engineering and terminal automation workloads.
The next meaningful test for Granite 4.2 will be whether those agentic skills transfer from benchmark sandboxes to real production codebases, virtual machines, and live tool environments. If the 8B and 30B maintain their behavior outside the harnesses where they were trained, IBM will have delivered something rarer than a new leaderboard entry: an open line of models that are not just reasoning engines but trained, tool-using agents ready for enterprise work.
