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.<\/p>\n
IBM Granite 4.2<\/a> 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.<\/p>\n 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.<\/p>\n The thinking switch is exposed through the model\u2019s chat template. When enable_thinking<\/strong> is true, the model generates an explicit chain of thought before its final answer. When low_effort<\/strong> 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<\/strong>, a design choice that prevents the model from relying on latent reasoning left over from earlier turns.<\/p>\n 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.<\/p>\n 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.<\/p>\n 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.<\/p>\n 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\u2019s experience beyond what naturally occurring repositories can provide.<\/p>\n 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<\/a> 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.<\/p>\n 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\u2019s 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.<\/p>\nHow does the Granite 4.2 thinking switch work?<\/h3>\n
Architecture: dense transformers, long context, and 15 trillion pre-training tokens<\/h2>\n
A post-training pipeline built from staged reinforcement learning<\/h2>\n