IBM shipped Granite 4.2 on August 25, 2026, a family of open, Apache 2.0 licensed agentic coding models in 3B, 8B, and 30B sizes that you can download and self-host today. The 30B model posts 57.00% on SWE-Bench Verified with a 512K token context window, and the 8B and 30B were trained with agentic reinforcement learning so they call tools, edit code, and run terminal commands in real sandboxes. For creators and builders who want a coding agent that runs on their own hardware without a per-token bill, this is a serious open alternative.
What Happened
IBM published the Granite 4.2 language models on Hugging Face on August 25, 2026, under the permissive Apache 2.0 license. The full collection is available to download on Hugging Face now, with source and recipes in the Granite 4.2 GitHub repository.
The release spans three sizes: 3B, 8B, and 30B parameters. Every model ships with a thinking and non-thinking switch, so you can toggle extended chain-of-thought reasoning on for hard problems or off for fast, cheap responses. The headline change from prior Granite releases is agentic reinforcement learning: the 8B and 30B models were trained to act, not just answer.
On the 30B model, IBM reports 57.00% on SWE-Bench Verified, 33.29% on SWE-Bench Pro, 89.17% on AIME25, and 66.41% on GPQA. Those are strong numbers for an open-weights model you can run locally, and they cover both real-world software engineering (SWE-Bench) and hard math and science reasoning (AIME25, GPQA).
How the Three Granite 4.2 Models Compare
The three sizes are not just the same model scaled up and down. The 3B skips the agentic reinforcement learning phase entirely, which makes it a fast general assistant rather than a hands-on coding agent. The 8B and 30B are the ones built to drive tools, edit files, and run commands.
| Attribute | Granite 4.2 3B | Granite 4.2 8B | Granite 4.2 30B |
|---|---|---|---|
| Parameters | 3B | 8B | 30B |
| Agentic RL (tools, code edits, terminal, web search) | No | Yes | Yes |
| Thinking switch | Yes | Yes | Yes |
| SWE-Bench Verified | Not published | Not published | 57.00% |
| Context window | 512K tokens | 512K tokens | 512K tokens |
| Best fit | Fast local assistant, edge and low-memory deployments | Balanced agentic coding on a single mid-range GPU | Highest-quality local coding agent, complex multi-step tasks |
IBM published the 57.00% SWE-Bench Verified figure for the 30B model specifically. The 3B and 8B SWE-Bench numbers were not published in the announcement, so treat their coding strength qualitatively: the 8B is the practical middle ground, and the 3B is for speed and footprint rather than autonomous coding.
Why It Matters for Creators and Builders
Most of the strongest coding agents live behind an API and a metered bill. Granite 4.2 puts a capable agentic coder under an Apache 2.0 license, which means you can run it on your own machines, fine-tune it, embed it in a product, and ship commercial work without asking anyone's permission. That combination of open weights and a permissive license is rare at this benchmark level.
The agentic reinforcement learning matters because it changes what the model is good at. Instead of only predicting the next line of code, the 8B and 30B were trained in sandboxes where they actually run terminal commands, edit files, and search the web, then get rewarded for outcomes. That is closer to how a real coding assistant works inside your editor or CI pipeline.
The 512K token context window is the other quiet win. You can load an entire small-to-mid codebase, a long design document, or a full test suite into a single prompt, which reduces the retrieval plumbing you would otherwise need to bolt on. For a self-hosted agent, that means fewer moving parts. IBM's broader model program is documented at the IBM Granite home.
Workflow: Run Granite 4.2 30B as a Local Coding Agent
Here is a concrete path from download to a working local coding agent. This assumes a machine with enough GPU memory to host the 30B (see the FAQ for hardware notes) or a smaller model if you are memory-constrained.
- Pull the model from Hugging Face. Grab the 30B weights from the Granite 4.2 collection on Hugging Face, for example with
huggingface-cli download ibm-granite/granite-4.2-30b. The Apache 2.0 license means no gated access or approval step. - Serve it with vLLM. Start an OpenAI-compatible server using vLLM:
vllm serve ibm-granite/granite-4.2-30b --served-model-name granite-4.2-30b. vLLM exposes a standard/v1/chat/completionsendpoint, so no custom adapters are required. - Point your agent framework at the endpoint. Configure OpenCode or OpenHands to use your local server as the model provider. Set the base URL to your vLLM host (for example
http://localhost:8000/v1), use any placeholder API key, and set the model name togranite-4.2-30b. - Enable tools and pick a thinking mode. Turn on tool calling in the framework so the model can edit files, run terminal commands, and search the web. Toggle the thinking switch on for complex refactors that need multi-step reasoning, and off for quick edits where latency matters more.
- Give it an agentic coding task. Hand it a real job, such as "add pagination to the results API and update the tests," and let it plan, edit, run the test suite, read the failures, and iterate. Because the 8B and 30B were trained with agentic RL in sandboxes, this run-observe-fix loop is what they are tuned for.
Once this loop works, you can swap the 30B for the 8B on a smaller GPU, or drop to the 3B for a fast non-agentic assistant, all through the same OpenAI-compatible endpoint.
How Granite 4.2 Stacks Up Against Other Open Coding Models
The open coding model field is crowded in 2026, with releases like GLM-5.3 and DeepSeek V4 pushing on quality and price. Granite 4.2 does not try to win a single benchmark race; it competes on a bundle of practical properties that matter when you actually deploy.
The first differentiator is the size ladder. Offering 3B, 8B, and 30B lets you match the model to your hardware and latency budget without changing frameworks, which many single-size releases do not give you. The 3B in particular targets edge and low-memory setups that larger flagship open models cannot serve.
The second is licensing and integration. Apache 2.0 is friendlier for commercial use than some open-weight licenses that add restrictions, and the OpenAI-compatible vLLM path plus native support in OpenCode, Pi, and OpenHands means you are wiring into standard agent tooling rather than a bespoke stack. Combined with the 512K context window and agentic RL on the 8B and 30B, Granite 4.2 is positioned as the pragmatic, self-hostable option rather than a leaderboard trophy. We are not quoting GLM-5.3 or DeepSeek V4 benchmark figures here because a like-for-like comparison depends on your own eval harness, but on openness and deployment flexibility Granite 4.2 is clearly in the top tier.
Frequently asked questions
Is IBM Granite 4.2 free to use commercially?
Yes. All three Granite 4.2 models are released under the Apache 2.0 license, which permits commercial use, modification, and redistribution. You can embed them in a product and ship paid work without a separate commercial agreement.
What hardware do I need to run the 30B?
The 30B is the largest of the three and needs the most GPU memory, so it is best suited to a high-memory GPU or a multi-GPU host. If you are memory-constrained, the 8B runs comfortably on a single mid-range GPU and the 3B fits on modest hardware, all served through the same vLLM endpoint.
Does Granite 4.2 support tool calling and web search?
Yes, on the 8B and 30B. Those two models went through agentic reinforcement learning in real sandboxed environments where they call tools, edit code, run terminal commands, and do web search. The 3B skips that agentic training phase and is better used as a fast general assistant.
How does the thinking switch work?
Every Granite 4.2 model includes a thinking and non-thinking switch that toggles extended chain-of-thought reasoning. Turn it on for hard, multi-step problems where deeper reasoning improves accuracy, and turn it off for simple, latency-sensitive requests to save time and compute.
Which agent frameworks work with Granite 4.2?
Granite 4.2 is compatible with the OpenCode, Pi, and OpenHands agentic coding frameworks. Because it serves through vLLM with OpenAI-compatible API endpoints, any framework that speaks the OpenAI chat API can point at it with no custom adapter.
What is the context window on Granite 4.2?
All three models support a 512K token context window. That is large enough to load an entire small-to-mid codebase, long specifications, or a full test suite into one prompt, reducing the need for external retrieval plumbing.
