IBM just released Granite 4.2, and I think we’re looking at a significant shift in what open-source reasoning models can do. Three sizes (3B, 8B, 30B), all trained from scratch on 15 trillion tokens, all Apache 2.0 licensed. But the real story isn’t the numbers - it’s the architecture they built around reasoning and agency.
Let me be direct: we’ve been waiting for dense, open-source models that can actually think through problems and act on their own. Granite 4.2 delivers both, and it’s trained on a scale that matters.
The Architecture Underneath
Granite 4.2 is a decoder-only transformer, nothing exotic there. What caught my attention is the five-phase pre-training strategy that extends the context window to 512K tokens. That’s the kind of window that lets you work with entire codebases or documents without fragmentation.
But here’s where it gets interesting: IBM didn’t just train bigger. They trained smarter. The pre-training is followed by supervised fine-tuning on chain-of-thought reasoning and agentic trajectory data. Then comes the orchestrated part: a multi-stage reinforcement learning pipeline that teaches the models to actually use tools inside sandboxed environments.
The 8B and 30B models get special treatment here. They go through agentic RL stages where they learn to call tools, edit code, operate terminals, and search the web in real environments. Not simulated. Real. That’s a meaningful difference.
Why the Staged RL Approach Matters
I’ve watched a lot of teams train RL pipelines for language models, and they typically converge on a single monolithic RL pass or a loose sequence of stages. Granite 4.2 takes something different: a carefully choreographed curriculum.
They run independent RL stages targeting specific capabilities - math, code, science, instruction following, tool use, structured output, then software engineering, terminal, and web search. Each stage is its own GRPO run that warm-starts from the previous checkpoint. The KL penalty schedule shifts based on reward type: zero KL on verifiable rewards (math, code) where you can actually check answers, higher KL (0.05) on preference-based tasks where drift matters.
This feels like the right way to build reasoning models, and I suspect we’ll see more teams adopting this approach. You’re essentially saying: “Get good at verified reasoning first, then expand into open-ended tasks, then learn to act in the world.”
What This Means for Builders
If you’re building applications that need reasoning or agency, this changes what’s available to you on the open-source side. The 8B model is particularly interesting for deployment - it’s large enough to handle complex reasoning but small enough to run on modest infrastructure. The 30B model is where you’d go if you have the capacity and need maximum performance.
Native tool calling that works with OpenAI-compatible endpoints is table stakes at this point, and Granite 4.2 has it. But the fact that the 8B and 30B models have been trained specifically to act as agents - to call tools, observe results, and iterate - suggests they’ll be more reliable at agency tasks than models simply fine-tuned to emit function calls.
For teams working on AI agents, this is significant. You’re not working with a model that was taught to output tool calls in training data. You’re working with a model that learned to actually solve tasks by using tools in real environments during RL training.
The Thinking Mode is Underrated
Every Granite 4.2 model ships with a thinking/non-thinking switch and a low-effort thinking mode. This is subtle but powerful. You can run the model in full-reasoning mode for hard problems, non-thinking mode for simple classification tasks, or the low-effort mode in between.
This flexibility matters for latency-sensitive applications. Not every task needs extended reasoning, and being able to budget reasoning effort per-query is practical.
Why Open Source Matters Here
Granite 4.2 is Apache 2.0 licensed. That’s not a footnote. It means you can run this locally, fine-tune it for your use case, and deploy it without licensing friction. In an AI landscape increasingly dominated by closed APIs, that matters.
The supervised fine-tuning data mixture gives you a hint at what IBM considered important: 31.6% agentic data (software engineering, tool calling, terminal use), 68.4% standard instruction-following data. If you need to understand how to build training pipelines for reasoning models, Granite 4.2’s approach is educational.
What’s notable is that we’re now at a point where the differentiator between models isn’t just scale - it’s training strategy. How you build the pipeline, how you choreograph the stages, what you optimize for at each step. That’s a more interesting competition than raw parameter count.