.png)
IBM released Granite 4.2, a first family of dense, decoder-only reasoning LLMs in 3B, 8B, and 30B sizes. The release matters because it combines explicit reasoning modes, native tool calling, long-context pretraining, and agentic post-training into one Apache 2.0 package.
Granite 4.2 keeps the same architectural design across 3B, 8B, and 30B and trains each model from scratch on roughly 15T tokens with a five-phase pretraining strategy that extends context to 512K tokens. The family is positioned as a reasoning-first successor to earlier Granite instruction models: it still follows instructions well, but now every model can produce a chain of thought before answering.
The practical distinction is not just size. Granite 4.2 exposes a thinking / non-thinking switch, plus a low-effort thinking mode that spends a short reasoning budget on easy questions. That gives you three operating points: fast direct responses, short deliberation for routine tasks, and full reasoning for harder prompts. For production routing, that is useful because you can map request classes to compute budgets instead of treating all prompts as equal.
IBM says the models go through pretraining from scratch, supervised fine-tuning on chain-of-thought, reasoning, and agentic-trajectory data, then a multi-stage reinforcement learning pipeline. The important detail is that reasoning is not left to prompt-time alone; it is built into post-training.
The strongest signal here is the separation between generic reasoning and agent behavior. All three models learn to reason, but the 8B and 30B variants get an additional agentic RL block that teaches them to act inside real sandboxed environments: calling tools, editing and running code, driving a terminal, and searching the web. That is a materially different training target from ordinary instruction tuning, because the optimization pressure includes action selection and environment feedback, not just text quality.
IBM also ships native tool calling for every model. In an OpenAI-compatible serving setup, including vLLM, the models emit tool calls in the OpenAI function-calling format, so they can drop into existing agent harnesses without a custom adapter layer. That makes integration straightforward for teams already standardizing on OpenAI-shaped tool schemas.
The release is most interesting for teams building multi-step agents rather than single-turn chat. Granite 4.2 gives you a model family where reasoning depth and tool use are explicit capabilities, not side effects of prompting. In practice, that means you can separate tasks by control policy: non-thinking for low-latency classification or extraction, low-effort thinking for routine support or lookup, and full thinking for planning or code-heavy workflows.
The 8B and 30B models are the ones to evaluate if your product depends on tool selection quality, sandbox interaction, or terminal-style workflows. The 3B model still matters if you want a smaller footprint with reasoning and tool calling, but IBM is clear that the agentic RL gains land on the larger two. If your stack already uses OpenAI-compatible endpoints, the serving path is simple; the real work is in evaluating whether the model’s reasoning mode and tool policy improve task success enough to justify the extra latency and token spend.
All Granite 4.2 models are released under Apache 2.0, which removes the usual licensing friction for enterprise deployment and downstream customization. For teams comparing against other reasoning-focused families, the main thing to test is not raw chat quality but end-to-end behavior under tool use, long context, and environment feedback.
