IBM just dropped its most consequential open-weight model release of the year, and if you are building agents, you should pay attention. On August 25, 2026, IBM Research published Granite 4.2, a family of dense, decoder-only reasoning LLMs in three sizes: 3B, 8B, and 30B parameters, all under the Apache 2.0 license. The headline feature is native reasoning, a switchable chain-of-thought "thinking" mode, and for the 8B and 30B models, a multi-stage agentic reinforcement learning pipeline that trains them to call tools, run code, drive a terminal, and search the web inside real sandboxed environments. This is the first Granite release built from the ground up for agents, and it lands at a moment when the open-weight ecosystem badly needs a credible alternative to proprietary reasoning models.
The bet: reasoning is a feature, not a separate model family.
Earlier Granite releases were strong instruction-following assistants. Granite 4.2 adds explicit reasoning on top. Every model in the family can produce a chain of thought before its answer, run in a full thinking or non-thinking mode, or settle into a low-effort thinking mode that spends a short reasoning budget on easy questions. That three-way switch is the architectural decision that matters most for builders: you can run the same model in fast mode for simple queries and switch on reasoning when a task needs deliberation, without swapping weights.
The Hugging Face collection and the GitHub repository are already live with model weights, instruct checkpoints, and quantized variants for each size.
What actually shipped on August 25?
Granite 4.2 is three models, one architecture, and one training pipeline applied at different scales. All three are dense decoder-only transformers with Grouped Query Attention, RoPE position embeddings with theta set to 10,000,000, SwiGLU MLPs, RMSNorm, and bfloat16 precision. The 3B model has 40 layers and a 2,560 embedding size. The 8B has 40 layers and a 4,096 embedding size. The 30B has 64 layers and a 4,096 embedding size. All three share a 131,072-token base sequence length, extended to 512K tokens during the fifth phase of pre-training.
The architecture table from the release tells the story:
| Component | 3B Dense | 8B Dense | 30B Dense |
|---|---|---|---|
| Layers | 40 | 40 | 64 |
| Attention heads | 40 | 32 | 32 |
| KV heads | 8 | 8 | 8 |
| MLP hidden size | 8,192 | 12,800 | 32,768 |
| Sequence length | 131,072 | 131,072 | 131,072 |
| Parameters | 3B | 8B | 30B |
Pre-training is from scratch on approximately 15 trillion tokens across five phases. The first two phases handle foundational pre-training. Phases three and four perform mid-training with progressively higher-quality data annealing. Phase five introduces long-context training, extending the context window to 512K tokens. The data mixture and learning-rate schedule shift at each phase, moving from broad web-scale data toward more curated, high-quality sources.
The models also ship with a speculative decoding layer that speeds up inference and helps enterprises serve more users at lower cost, according to IBM Research.
How does the reasoning actually work?
The reasoning capability is baked into the SFT and RL pipeline, not bolted on after the fact. Supervised fine-tuning turns the base model into a reliable instruction-following, reasoning, and tool-using assistant using a mixture of agentic and non-agentic data totaling approximately 7.2 million samples, or roughly 100B tokens, of which about 65B are trainable.
The SFT data mixture combines 31.6% agentic and 68.4% non-agentic data. The agentic corpus covers software engineering at 69%, tool calling at 12.1%, terminal use at 8.0%, math at 3.5%, search at 0.8%, and action at 0.2%. These samples are generated using a diverse set of agent scaffolds and harnesses, including OpenHands, OpenCode, Terminus-2, SWE-agent, OpenResearcher, MiniSWE, OpenSeeker, EnvScaler, Gemini CLI, Hermes, Codex, and Goose.
The non-agentic corpus consists of instruction following at 18.8%, coding at 18.8%, math at 14.6%, multilingual at 7.0%, science at 5.4%, reasoning at 3.0%, and safety at 0.8%.
Quality control is aggressive. Data from different sources is normalized into a consistent OpenAI Chat format. IBM uses GPT-OSS-120B and Gemma 4 as LLM-based judges to assess sample quality, removing low-scoring samples, hallucinated information, invalid tool interactions, and tool calls to undefined functions. Deduplication is based on SHA-256 hashes computed over the combination of the tools and messages fields.
For the 30B model, IBM adds a second SFT phase focused specifically on agentic coding, upsampling SWE and coding data while retaining about 16% replay data from the original corpus, fine-tuned for roughly one additional epoch at a learning rate of 3.0e-6.
The thinking mode itself is a training-time feature. The model learns to produce a chain of thought before its answer during SFT, then refines that behavior during RL. The low-effort thinking mode gives builders a knob: spend a short reasoning budget on easy questions, go full thinking on hard ones, or skip reasoning entirely when latency matters.
What is the agentic RL pipeline and why should you care?
This is the part that should make builders sit up. After SFT, IBM applies a multi-stage, multi-environment reinforcement learning pipeline. Rather than a single RL pass, the pipeline runs a chain of focused stages, each targeting one capability and warm-starting from the previous checkpoint.
Every stage trains with asynchronous GRPO (Group Relative Policy Optimization). A pool of generation workers samples responses and drops finished trajectories into a shared buffer. The trainer pulls a full batch, takes an optimizer step, and streams updated parameters back without pausing the generators. The system allows a single trajectory to be stitched from two adjacent policy versions, reusing KV cache rather than rebuilding it after each refresh, with a guardrail that keeps workers from drifting more than a single update behind the trainer. Truncated importance sampling clamps the train-versus-generation log-probability ratio to handle any residual mismatch.
Advantages are group-relative with a leave-one-out baseline: each response is judged against the mean reward of the other samples drawn for the same prompt, removing the need for a separate value network. In the RLVR stage, each step pairs 256 prompts with 16 sampled responses apiece for a 4,096-example batch.
The pipeline has two blocks:
Foundational RL runs for all three model sizes. It starts with RLVR (reinforcement learning with verifiable rewards), covering math with boxed-answer checking and formal proving in Lean, competitive coding with hidden-test sandboxing, graduate-level science MCQA, instruction following, single-step tool calling, and reasoning puzzles with abstention. Skill boosters follow, each a separate GRPO run targeting code, science, or instruction following.
Agentic RL runs only for the 8B and 30B models. The agentic block has three stages in order: SWE (software engineering), Terminal, and Search. In these stages the model learns to act inside real, not simulated, environments: calling tools, observing results, editing and running code, driving a terminal, and searching the web. Rewards are sparse outcome signals, often a single bit at the end of a long tool-use trajectory indicating whether the task was actually solved.
Every model finishes with RLHF for human preference and safety, optimizing against a generative reward model (GenRM) plus a safety reward covering jailbreak resistance and appropriate refusals. This stage uses the highest KL penalty in the pipeline and applies a reasoning-length penalty to discourage verbose reasoning acquired during earlier stages.
The 3B model takes a shortened path: foundational RL and alignment, without the agentic block. That is the key capability split across sizes.
How does this compare to what else is on the shelf?
The open-weight landscape for reasoning models is thin. Meta has not shipped a reasoning-first dense model at these scales with native tool calling and agentic RL under a permissive license. DeepSeek's reasoning models are strong but have different licensing and deployment stories. Qwen covers a lot of ground but its agentic training is less explicitly documented.
Granite 4.2 differentiates on four axes:
- Native reasoning with a three-way thinking switch: full thinking, low-effort thinking, and non-thinking mode on the same weights. This is rare in open-weight models and gives builders a latency-versus-accuracy knob at inference time.
- Agentic RL on real environments: the 8B and 30B models are trained to call tools, run code, and drive terminals inside real sandboxes, not simulated approximations. The reward is whether the task was solved, not whether the output looks right.
- OpenAI-compatible tool calling out of the box: served through vLLM, the models emit tool calls in OpenAI function-calling format and plug into agentic harnesses without extra glue. SGLang is also supported with a ready-to-serve recipe.
- Apache 2.0 on everything: weights, instruct checkpoints, and quantized variants are all free for commercial use.
If you have been waiting for an open-weight model that you can self-host, that has reasoning baked in, and that was explicitly trained for agent loops, this is the most complete option available right now.
What should you do with Granite 4.2 today?
If you are building or running agents, here is the practical read.
- Download and benchmark the 8B first. It is the sweet spot. It goes through the full agentic RL pipeline, fits on a single GPU with quantization, and supports native tool calling. If you are evaluating whether to move an agent workload off a proprietary API, the 8B is where to start.
- Use the 30B for complex multi-step agent tasks. The 30B gets the second SFT phase focused on agentic coding and the full RL ladder. If your workload involves multi-file code editing, terminal-driven workflows, or multi-hop search, the 30B is the model to test.
- Use the 3B for edge or high-throughput reasoning. The 3B skips the agentic block but still has foundational RL and reasoning. It is the model for constrained environments where you want chain-of-thought but cannot afford the larger sizes.
- Test the thinking switch in production. The low-effort thinking mode is the feature most likely to change your cost profile. Run the same workload in non-thinking, low-effort, and full thinking modes and measure the latency-to-accuracy tradeoff. You may find that most of your traffic does not need full reasoning.
- Wire it into your existing harness. The OpenAI-compatible function-calling format means you can swap Granite 4.2 into an existing agent scaffold with minimal changes. If you are using OpenHands, SWE-agent, or a custom harness, the tool-calling interface should work without a translation layer.
For a deeper look at how agents perform on hard business workflows, see our earlier reporting on SOP-Bench results for AI agents, where the best systems still hit only 25% on the hardest standard operating procedures.
What are the open questions?
The release is strong on architecture and training detail, but several questions remain for builders.
The SFT data mix is 31.6% agentic, but the agentic corpus is heavily skewed toward software engineering at 69%. If your agent use case is not coding, the agentic RL may not transfer as cleanly. IBM trained on real environments for SWE, terminal, and search, but other domains like data analysis, customer support, or financial workflows are not explicitly represented in the agentic block.
The reasoning-length penalty in the final RLHF stage is a design choice that trades verbosity for cost efficiency. Builders should test whether the penalty hurts performance on tasks that genuinely need long deliberation, like complex math or multi-hop research.
The 3B model skips the agentic RL block entirely. If you were planning to use the 3B for agent workloads, you are getting a reasoning model but not an agent-trained model. The capability split is not just about parameter count, it is about what the model was trained to do.
Benchmark numbers from IBM's own evaluations are not yet independently verified. The training pipeline is well documented, but the proof is in the benchmarks. Builders should run their own evals on their own workloads before committing.
The bottom line
Granite 4.2 is the most detailed open-weight reasoning and agent release from a major lab this year. The architecture is standard, the pre-training is large-scale, and the agentic RL pipeline is the differentiator. IBM has shown its work on the training recipe, the data mix, and the RL curriculum, and the Apache 2.0 license removes the biggest adoption barrier. The question now is whether the agentic training transfers to workloads that are not software engineering. If it does, the open-weight agent gap just narrowed.
