IBM Granite 4.2: Open Reasoning Models With an

Okay, I want to talk about the thinking switch. Because IBM just shipped a language model with a literal dial for how hard it thinks, and that is genuinely one of the more interesting design choices I've seen in an AI release this year — and somehow the launch coverage is treating it like a footnote.

Granite 4.2 dropped this week. According to MarkTechPost, it's a family of open reasoning language models available in three sizes — 3B, 8B, and 30B parameters — confirmed by IBM's own technical writeup on the Hugging Face blog, under the Apache 2.0 license. All three are open. All three are locally deployable. And the 8B and 30B variants ship with something called an agentic RL block that lets the model use tools and take actions in the world, not just generate text about them.

Let's take those pieces one at a time.

The "Thinking Switch" Is Not a Gimmick

The basic idea: large reasoning models (the o1-class stuff, DeepSeek-R1, that whole lineage) learned that you can get dramatically better answers by making a model "think out loud" before responding — generating a chain of internal reasoning steps before committing to an output. The tradeoff is that this burns tokens, time, and compute. A lot of both. It's brilliant for hard problems; it's absurd overkill for "what's the capital of France."

IBM's approach in Granite 4.2, per MarkTechPost, is to make this toggleable. The model has a built-in switch for varying levels of cognitive engagement — so you can tell it to think hard when you need it to, and stop wasting cycles when you don't. That's not just a UX nicety. In an enterprise context where you're running thousands of queries a day, the difference between always-on heavy reasoning and adaptive reasoning is real money and real latency. The model is smart enough to be lazy when laziness is appropriate, and that's... actually a flex?

For the developers in the room who've been wishing you could get DeepSeek-R1-style reasoning without R1-style compute bills on your simple retrieval tasks — Granite 4.2 is at least trying to solve for that.

The Agentic Part Is Where It Gets Interesting (and Complicated)

Here's where I'd ask you to actually pay attention, because this is the part that matters most and gets explained worst in most coverage.

The 8B and 30B Granite 4.2 models include what IBM calls an "agentic RL block" — reinforcement learning components specifically trained to help the model use external tools and take actions in controlled environments. MarkTechPost points to code editing and web search as concrete examples of what this enables.

What does that mean in practice? Normal LLMs generate text. Agentic models do things. They can call an API, run a code interpreter, search the web, read a file, and then decide what to do with the output — all in a loop, without a human in the middle for every step. Reinforcement learning is how you train a model to get good at this: you let it try stuff, reward it when it works, and the model learns which sequences of actions actually accomplish goals. It's how you teach a model that "I should search for the error message, read the result, and then edit the code" is better than just guessing.

The framing of "controlled environments" is doing some real work in that sentence, though. The honest version: agentic models are powerful and genuinely useful, but they're also the thing where "the AI went off-script and did something weird" starts to become a real sentence rather than a thought experiment. The more autonomy you grant a model, the more consequential its mistakes get. IBM knows this — the enterprise customers they're building for know this — which is probably why "controlled" appears in almost every description of what the agentic RL block does.

Watson Became a Punchline. That's Why IBM Is Playing This Differently.

I can't write about IBM AI without addressing the elephant in the room, and I'm not going to smooth over it this time.

Watson. IBM spent years positioning Watson as the future of AI — a brand-level bet on AI supremacy that ended up synonymous with overpromising. Watson became a punchline fast, and not without reason: the gap between the "AI that beat Ken Jennings" narrative and what Watson could actually do in messy real-world deployments was wide enough to park a mainframe in.

That history isn't just trivia. It's a lens for reading everything IBM does in AI now. The Granite strategy — smaller models, open source, focused on enterprise use cases, explicit about what the model is trained on and how — reads like a direct overcorrection from the Watson era. Where Watson was opaque, marketed as magical, and positioned as a replacement for human expertise, Granite is technically documented, open to inspection, and presented as a tool you control, not an oracle you defer to.

Is that a cynical rebranding? Maybe. Is it also genuinely better product strategy? Also maybe. The Hugging Face blog post on how Granite 4.2 is built exists specifically so people can read it. That's not nothing.

The Local LLM Angle Is Actually the Point

Ars Technica frames Granite 4.2 as IBM riding the wave of interest in local LLMs, and that framing is correct but undersells the why.

The enthusiasm for running models locally — on your own hardware, in your own environment, without your data touching someone else's cloud — isn't just a hobbyist thing. It's a compliance thing. Healthcare organizations can't send patient data to an OpenAI endpoint. Government contractors can't route sensitive queries through a third-party API. Financial institutions have data residency requirements that make "just use the cloud API" genuinely not an option.

Apache 2.0 licensing means Granite 4.2 isn't just open to look at — it's open to use commercially, modify, and deploy however you want, including air-gapped. That's a deliberate targeting of the part of the enterprise market that can't use frontier models even if they wanted to. IBM isn't trying to beat OpenAI at their own game. IBM is playing in the rooms where OpenAI isn't allowed.

Whether Granite 4.2 is good enough for those rooms is a genuinely open question. The sources I have don't include independent benchmark comparisons against Llama 3, Mistral, or Qwen at equivalent parameter counts, and I'm not going to pretend otherwise. "Available and licensable" gets you in the door; "performs well enough that your legal team doesn't have to apologize for the outputs" is what gets you renewed.

The Part Nobody's Talking About

An 8B model with agentic RL that you can run locally — that's not just an enterprise story. That's also a story about what happens when autonomous AI agents become something a company's internal IT team can deploy without going through a hyperscaler.

Right now, most agentic AI deployments require either significant cloud spend or serious ML engineering overhead. A well-documented, Apache-licensed, locally-runnable agentic model at 8B parameters that a mid-sized company can actually run on their own infrastructure... that moves the capability further down the stack. Not to every laptop, but closer than it was last year.

The question isn't whether IBM should be building this — they should, it's useful, and someone was going to. The question is whether "controlled environments" stays a meaningful constraint as these models get easier to deploy and customize. The history of software is that "designed for controlled environments" has a way of becoming "deployed everywhere" faster than anyone planned for.

IBM has thought about this more than most, given their enterprise DNA. But Granite 4.2 being easy to run locally is both the product's biggest selling point and the thing that makes enterprise governance conversations a little more urgent. Those two things are just true simultaneously.

An agentic model that lives on your servers and can edit code and browse the web without phoning home is exactly what a lot of security-conscious organizations need. It's also exactly what makes "who's watching the agent?" a question worth taking seriously before the deployment, not after.

— Yuki Okonkwo, AI & Machine Learning Correspondent, Buzzrag