--- title: "IBM Granite 4.2: Dense Reasoning Models at 3B, 8B, and 30B" url: https://daily.dev/posts/ibm-granite-4-2-dense-reasoning-models-at-3b-8b-and-30b-0owyr0l0l source_url: https://daily.dev/posts/ibm-granite-4-2-dense-reasoning-models-at-3b-8b-and-30b-0owyr0l0l type: collection source: "Collections" published: 2026-08-25T20:20:38.456Z updated: 2026-08-25T20:22:03.324Z tags: ["open-source", "llm", "reinforcement-learning", "ibm"] reading_time: 2 upvotes: 1 comments: 0 language: en --- > ## Documentation Index > Fetch the complete documentation index at: https://daily.dev/llms.txt > Use this file to discover all available pages before exploring further. # IBM Granite 4.2: Dense Reasoning Models at 3B, 8B, and 30B **[Collections](https://daily.dev/sources/collections)** · 2 min read · 1 upvotes · 0 comments ## Summary IBM has released Granite 4.2, a family of dense, decoder-only open-weight LLMs at 3B, 8B, and 30B parameters under Apache 2.0. Trained on ~15 trillion tokens including a full trillion tokens of synthetic code, the models use a straightforward all-attention Transformer rather than the hybrid Mamba/attention designs many labs favor. The 8B and 30B variants go through GRPO-based reinforcement learning for agentic tasks, terminal use, and search, and support thinking, non-thinking, and low-effort reasoning modes plus native tool calling. Context extends to 512K tokens via a five-phase pretraining strategy, though native training is at 128K. Quantized formats (FP8, NVFP4, MXFP4, GGUF) support vLLM and llama.cpp deployment. Benchmarks are unremarkable overall, with Qwen 3.8 27B beating Granite across coding tests, but the 8B model stands out as an efficient, high-value option that runs well on consumer hardware. IBM also released two Granite Speech models the same day. ## Content IBM has released Granite 4.2, a new family of open-weight LLMs available in 3B, 8B, and 30B parameter sizes under an Apache 2.0 license. The models are dense, decoder-only, and built on a straightforward all-attention Transformer architecture, a choice that stands out given how many labs have moved toward hybrid Mamba/attention designs. It's a continuation of the direction IBM took with Granite 4.1, which also stuck with dense models rather than following the crowd. ## Training and architecture Each model is pre-trained from scratch on roughly 15 trillion tokens, including a full 1 trillion tokens of synthetic code generated through IBM's CodeAlchemy pipeline. Pretraining follows a five-phase strategy that pushes the context window out to 512,000 tokens, even though the models are natively trained at 128K. After pretraining, the models go through fine-tuning on chain-of-thought and agentic data. The 8B and 30B models then go through a multi-stage reinforcement learning pipeline based on GRPO. This covers verifiable rewards, skill-specific boosters, and agentic RL targeting software engineering tasks, terminal use, and search. The result is models that support three distinct modes: thinking, non-thinking, and a low-effort mode for when you don't need the model to reason at length. Native tool calling is built in as well. For deployment, IBM offers quantized variants in FP8, NVFP4, MXFP4, and GGUF formats, with support for vLLM and llama.cpp. ## How they actually perform Here's where I have to be honest: the benchmarks are unremarkable. Coding performance in particular is inconsistent, and Qwen 3.8 27B beats Granite across the board on the tests that matter. That's a tough comparison to lose, especially at the 30B size. But the 8B model deserves a mention on its own. It runs efficiently on consumer hardware and gets surprisingly close to the 30B model's performance, which makes it the more interesting release of the two for anyone who isn't running a datacenter. If you're picking between the two dense options, the 8B looks like the better value. IBM also launched two new Granite Speech recognition models on the same day, rounding out what was clearly a coordinated release rather than a single-model drop. Overall, Granite 4.2 doesn't move the needle on raw benchmark performance, but the reasoning modes, extended context, and agentic RL training make it a practical option for teams that want an open, dense model they can actually run and fine-tune without hybrid-architecture complications. ## Questions this post answers ### What parameter sizes does IBM Granite 4.2 come in and what license is it released under? IBM Granite 4.2 ships in 3B, 8B, and 30B parameter dense models, all released under the Apache 2.0 license. The models are decoder-only with an all-attention Transformer architecture rather than a hybrid Mamba/attention design, continuing the approach IBM used with Granite 4.1. _Track new open-weight model releases like this on daily.dev when picking a model to self-host._ ### How does the Granite 4.2 8B model compare to the 30B model in practice? The 8B model runs efficiently on consumer hardware and gets surprisingly close to the 30B model's performance, making it the better value pick between the two dense Granite 4.2 options. The 30B model, meanwhile, is beaten across coding benchmarks by Qwen 3.8 27B. _Compare model size trade-offs like this on daily.dev before choosing which LLM to deploy._ ### What context window does Granite 4.2 support and how was it achieved? Granite 4.2 supports a context window extended to 512,000 tokens through a five-phase pretraining strategy, even though the models are natively trained at 128K tokens. Pretraining used roughly 15 trillion tokens total, including a full trillion tokens of synthetic code from IBM's CodeAlchemy pipeline. _Follow context-window and training details like these on daily.dev when evaluating LLMs for long-context tasks._ --- Tags: [#open-source](https://daily.dev/tags/open-source), [#llm](https://daily.dev/tags/llm), [#reinforcement-learning](https://daily.dev/tags/reinforcement-learning), [#ibm](https://daily.dev/tags/ibm) [View this post on daily.dev](https://daily.dev/posts/ibm-granite-4-2-dense-reasoning-models-at-3b-8b-and-30b-0owyr0l0l)