IBM just shipped something developers actually asked for: open-source reasoning models you can run on your own hardware, without a license fee, without an API call, and without sending your code to someone else’s server. IBM Granite 4.2 — three models at 3B, 8B, and 30B parameters — landed August 25 under Apache 2.0. The benchmarks are solid. But the real story is what IBM actually did under the hood to train these things.
One Model, Three Thinking Modes #
The headline feature is a switchable reasoning system built into a single checkpoint. You don’t download separate “thinking” and “non-thinking” model variants. You toggle the mode at inference time:
Full thinking— the model reasons step-by-step inside<think>...</think>
tags before answering. Best for debugging, complex code generation, and multi-step reasoning.Non-thinking— direct answer, no reasoning overhead. Better for autocomplete and latency-sensitive applications.** Low-effort**— a brief reasoning pass for moderate-complexity tasks. A useful middle ground.
The <think>
content is parseable — your application can inspect it, log it, or discard it. That’s useful for agent systems where you need to understand why the model made a particular tool call.
In Python with Hugging Face Transformers, the switch is a single parameter:
text = tokenizer.apply_chat_template(
messages,
tokenize=False,
add_generation_prompt=True,
enable_thinking=True # False for direct answers
)
With Ollama, you’re one command away from running the 8B locally:
ollama run granite4.2:8b
Hardware requirements are reasonable: 8 GB RAM for the 3B, 16 GB for the 8B, and 32 GB (or a 24 GB GPU) for the 30B.
The Agentic RL Training Is the Part That Actually Matters #
Most open-source “agentic” models were fine-tuned on recorded agent trajectories — the model studied examples of agents, then learned to imitate them. Granite 4.2’s 8B and 30B went further: they trained inside real environments through reinforcement learning.
IBM ran three sequential RL stages after supervised fine-tuning:
SWE Agent— actual repository sandboxes viaOpenHands. The model read real code, made edits, ran test suites, and was rewarded only when hidden tests passed. Up to 128 rollout turns per episode.Terminal Agent— a live shell. Multi-step commands, error recovery, real output. Sparse binary reward on task completion.** Search Agent**— live web-search tool calls with multi-hop evidence gathering, judged by an LLM evaluator.
This distinction matters for production deployments. A model that practiced in real environments tends to be more reliable than one that only observed them. It’s the difference between a surgeon trained on cadavers and one who read anatomy textbooks.
Benchmarks — With Honest Context #
The 8B model posts numbers worth citing:
- SWE-Bench Verified: 47.67— strong for a local 8B model - AIME25: 86.67%— competitive math reasoning - LiveCodeBench v6: 73.24 - MMLU-Pro: 74.04
The 30B hits 57.00 on SWE-Bench Verified, which starts to approach proprietary model territory for software engineering tasks. Full benchmark tables are available on the Hugging Face model card.
The honest caveat: Qwen3.8-27B still leads Granite on most coding benchmarks at a comparable parameter count. IBM’s comparison tables lean heavily on prior Granite versions rather than current competitors — a pattern the community has flagged before. Treat these numbers as evidence that Granite 4.2 got substantially better than Granite 4.1. That’s true and useful. Don’t treat them as proof Granite beats Qwen, because the tables don’t show that.
Apache 2.0 Is Not a Small Detail #
Every Granite 4.2 model ships under Apache 2.0. Unrestricted commercial use. No usage caps. No “you can’t build a product with this” clauses. No special attribution requirements beyond license headers.
DeepSeek models carry commercial use restrictions. Meta’s Llama licensing has evolved but still has conditions. Apache 2.0 has none of that. If you’re building something you plan to ship — or deploy internally at a regulated company — that difference is real money and real legal exposure avoided.
One Real Limitation #
Granite 4.2 is text-only. No vision inputs. Competitors at the 30B range — Qwen3.8-27B, Gemma 4 31B, Meta’s Muse Glimmer 30B — are multimodal. If your workflow touches screenshots, diagrams, or document images, you’ll need to pair Granite with a separate vision model. IBM hasn’t closed that gap yet.
The Verdict #
IBM has a reputation for releasing AI tools that perform well in demos but disappoint in production. Granite 4.2 pushes back on that — not because it tops every leaderboard, but because the training architecture is genuinely thoughtful and IBM published it in full: stage by stage, hyperparameter by hyperparameter. That kind of transparency is rare in the LLM industry and worth something on its own.
If you need local deployment, Apache 2.0 rights, and real agentic capability in a manageable model size, Granite 4.2 8B is now the model to beat. Not the best local model on every benchmark. But possibly the best local model you can use commercially without legal exposure — and that’s a category worth winning.
Full technical details and GGUF quantization files are on the official Hugging Face blog. Source code and model weights live on GitHub under the Apache 2.0 license.