IBM has released Granite 4.2, a family of three open-source reasoning LLMs at 3B, 8B, and 30B parameters, detailed in a technical blog post published by the Granite Team on Hugging Face on August 25, 2026. The models are the first Granite generation built specifically for reasoning, adding a chain-of-thought "thinking" mode, native tool calling, and a 512K-token context window on top of the instruction-following strengths of earlier Granite releases.
All three sizes share the same dense, decoder-only architecture and go through the same core pipeline, pre-training from scratch on roughly 15 trillion tokens, supervised fine-tuning on reasoning and tool-use data, and a multi-stage reinforcement learning process. The 8B and 30B models go further, adding an agentic RL stage that trains them to operate as coding, terminal, and web-search agents inside real sandboxed environments. All Granite 4.2 models are released under the Apache 2.0 license, and IBM has also published FP8, NVFP4, MXFP4, and GGUF quantized variants for deployment with vLLM and llama.cpp.
This piece walks through what's actually documented in IBM's post: the architecture, the training data mix, how the reinforcement learning curriculum is structured, and where the published benchmark numbers land across the three model sizes.
What Is Granite 4.2?
Granite 4.2 is IBM's reasoning-focused follow-up to the Granite 4.1 instruction-following models. Earlier Granite releases were built as strong assistants; Granite 4.2 adds an explicit reasoning step. Every model can generate a chain of thought before answering and can be run in thinking, non-thinking, or a low-effort thinking mode that spends a shorter reasoning budget on easy questions. The three sizes, 3B, 8B, and 30B, all use the same dense decoder-only architecture and the same overall training recipe, just at different scales.
The clearest capability split shows up after supervised fine-tuning: the 8B and 30B models additionally go through an agentic reinforcement learning block that teaches them to call tools, edit and run code, drive a terminal, and search the web inside real, sandboxed environments. The 3B model completes foundational RL and alignment but skips that agentic block.
What's the Model Architecture?
All three sizes are dense, decoder-only transformers using Grouped Query Attention (40 attention heads, 8 KV heads), Rotary Position Embeddings, SwiGLU-activated MLP layers, and RMSNorm. Input and output embeddings are kept separate rather than tied, and the models train and run in bfloat16.
How Was Granite 4.2 Pre-Trained?
Each model is trained from scratch on approximately 15 trillion tokens using a five-phase strategy. Phases 1 and 2 handle foundational pre-training, phases 3 and 4 run mid-training with progressively higher-quality data annealing, and phase 5 extends the context window to 512K tokens. IBM notes the pre-training recipe closely follows the Granite 4.1 generation, with the data blend and long-context extension covered in more depth in that earlier post.
How Was It Fine-Tuned for Reasoning and Tool Use?
Supervised fine-tuning combined roughly 7.2 million samples (about 100 billion tokens, of which ~65 billion are trainable), split between an agentic corpus (31.6% of the mix) and a non-agentic corpus (68.4%). The agentic data leans heavily on software engineering trajectories (69% of that corpus), with the rest split across tool calling, terminal use, math, search, and general action tasks, generated using scaffolds including OpenHands, OpenCode, Terminus-2, and SWE-agent. The non-agentic corpus covers instruction following, coding, math, multilingual data, science, general reasoning, and safety.
Before training, IBM applied several quality-control passes: normalizing data into a consistent chat format, using GPT-OSS-120B and Gemma 4 as LLM judges to filter low-quality or hallucinated samples, removing invalid tool calls, and deduplicating the corpus with SHA-256 hashing. The 30B model gets an additional second SFT phase focused specifically on agentic coding data.
How Does the Reinforcement Learning Pipeline Work?
Rather than one RL pass, Granite 4.2 runs a chain of separate, focused RL stages, each warm-starting from the previous stage's checkpoint:
SFT → RLVR → Skill boosters → SWE agent → Terminal → Search → RLHF
Every stage trains with asynchronous GRPO (Group Relative Policy Optimization), where generation and training run on separate GPU pools so the generation fleet never sits idle waiting on an optimizer step. The foundational stages (RLVR and skill boosters) run for all three sizes; the agentic block, SWE agent, terminal agent, and search agent, runs only for the 8B and 30B models. Every model finishes with an RLHF stage for human preference and safety alignment.
The three agentic environments each pair a real harness with sparse, outcome-based rewards: the SWE agent uses the OpenHands harness against real repositories with hidden test suites, the terminal agent uses the Terminus-2 harness in a live shell with up to 64 turns per rollout, and the search agent answers multi-hop questions via live web search, graded by an LLM judge. The training stack runs on two open components: NeMo-RL for the GRPO training loop (Megatron-Core backend, vLLM for rollout generation) and NeMo-Gym, which exposes each environment's tools, sandboxes, and reward checks as a uniform interface.
How Did Granite 4.2 Perform on Benchmarks?
IBM published results across agentic coding, general agentic/tool use, reasoning, chat, and long-context tasks, with scores generally rising with model size:
The 3B model, which skips the agentic RL block, has no reported scores on the agentic-coding benchmarks (SWE-Bench, Terminal-Bench). It still competes on reasoning and chat tasks, and its RULER long-context scores, while lower than the larger models, show the 512K context extension carries down to the smallest size.
What About Deployment and Licensing?
All Granite 4.2 models are released under the Apache 2.0 license, and IBM shipped quantized variants alongside the full-precision weights: FP8, NVFP4, and MXFP4 (via LLM Compressor and GPTQ calibration), plus multiple GGUF formats for llama.cpp-based deployment. That kind of post-training compression work sits in the same territory as other recent quantization research aimed at shrinking models without giving up accuracy. Training itself ran on an NVIDIA GB200 NVL72 cluster hosted by CoreWeave, using a 72-GPU NVLink domain per rack and a non-blocking InfiniBand fabric between racks.
Granite 4.2 exposes tool calls in the OpenAI function-calling format through an OpenAI-compatible endpoint, and IBM documents direct integration with agent harnesses including OpenCode, Pi, and OpenHands. That positions it as infrastructure for the same kind of agentic deployments that are drawing scrutiny elsewhere in the industry, where enterprise adoption of AI agents is currently outpacing the governance and readiness needed to support them, and where even well-funded agent products are still being tested on trust and reliability rather than raw capability.
Key Takeaways
- Granite 4.2 is IBM's first reasoning-focused Granite generation, released in 3B, 8B, and 30B sizes under Apache 2.0.
- Every model gets a thinking / non-thinking / low-effort reasoning switch and native tool calling; only the 8B and 30B models go through agentic RL for coding, terminal, and search tasks.
- Pre-training used roughly 15 trillion tokens across a five-phase pipeline that extends context to 512K tokens.
- IBM shipped FP8, NVFP4, MXFP4, and GGUF quantized variants alongside the full models, plus documented integrations with OpenCode, Pi, and OpenHands.
Key Takeaways
- Granite 4.2 is IBM's first reasoning-focused LLM family, released in 3B, 8B, and 30B sizes under the Apache 2.0 license.
- All three sizes share a dense decoder-only architecture; only the 8B and 30B models complete the agentic RL stages for coding, terminal, and search tasks.
- Pre-training used approximately 15 trillion tokens across a five-phase pipeline that extends the context window to 512K tokens.
- IBM released FP8, NVFP4, MXFP4, and GGUF quantized variants alongside full-precision weights, with documented support for vLLM, SGLang, and agent harnesses like OpenCode and OpenHands.
FAQ
What sizes does Granite 4.2 come in?
Granite 4.2 ships in three dense model sizes: 3B, 8B, and 30B parameters. All three share the same architecture and training pipeline, but only the 8B and 30B models go through the agentic reinforcement learning stages for coding, terminal, and search tasks.
Is Granite 4.2 open source?
Yes. IBM releases all Granite 4.2 models, including the quantized FP8, NVFP4, MXFP4, and GGUF variants, under the Apache 2.0 license, which permits commercial and academic use.
What's new in Granite 4.2 compared to earlier Granite models?
Granite 4.2 is IBM's first reasoning-focused Granite release. It adds an explicit chain-of-thought "thinking" mode (with a low-effort variant for easy questions), a multi-stage reinforcement learning pipeline including agentic RL for the 8B and 30B models, and a context window extended to 512K tokens during pre-training.
What hardware and software were used to train Granite 4.2?
IBM trained Granite 4.2 on an NVIDIA GB200 NVL72 cluster hosted by CoreWeave, using a 72-GPU NVLink domain per rack and a non-blocking Fat-Tree InfiniBand fabric between racks. The reinforcement learning stages ran on two open-source components, NeMo-RL for training and NeMo-Gym for environment orchestration.
