Skip to content

Build Independently confirmed3 publishers 3 min read Published Updated

Granite 4.2 ships a self-hostable reasoning tier under Apache 2.0, and its data says coding agent

IBM's 3B, 8B and 30B dense models all get a thinking switch and native tool calling, but only the two larger ones get agentic RL, and the tuning mixture leans hard on software engineering.

The Engineer · Build desk

Send a correction

What happened

  • IBM has released Granite 4.2 as three dense, decoder-only reasoning models at 3B, 8B and 30B, sharing one architecture and one training pipeline.
  • All three carry a thinking / non-thinking switch, a low-effort thinking mode and native tool calling.
  • Each was pre-trained from scratch on about 15 trillion tokens across five phases, the last extending the context window to 512K tokens.
  • Only the 8B and 30B get the agentic RL stage, which trains tool use, code editing, terminal driving and web search inside real sandboxed environments.
  • The supervised stage used roughly 7.2 million samples and 100 billion tokens, split 31.6 percent agentic and 68.4 percent non-agentic.

Why it matters

  • What's now possible capability Teams that cannot send prompts to a hosted endpoint now have a thinking-mode model in three sizes on one permissive license, runnable inside their own boundary.
  • What it limits constraint Dropping from 8B to 3B to fit a memory budget also drops the agentic training, so the small size is a reasoner with a tool-calling interface rather than a cheap agent.
  • Who has to decide decision Long-window serving becomes a cache budgeting choice between sequence length and concurrency, and the 5 to 1 head ratio sets the terms of that trade.
  • What it limits constraint Anyone evaluating this as a general reasoner should expect its trained ground to be repositories and terminals, because other domains received a fraction of the trajectory volume.

The fine-tuning mixture repays a few minutes with a calculator. The agentic block comes to roughly 2.3 million samples [16], and software engineering accounts for 69 percent of it [9], which puts SWE trajectories at about 22 percent of everything the models were fine-tuned on [13]. The rest of that block is thinner: tool calling at 12.1 percent, terminal use at 8.0 percent, then math, search and action [9]. The listed slices only add to 93.6 percent, so part of the agentic corpus is unaccounted for in the post [21].

The non-agentic figures need a reading before they mean anything. IBM lists instruction following 18.8, coding 18.8, math 14.6, multilingual 7.0, science 5.4, reasoning 3.0 and safety 0.8 [10], and those add to exactly 68.4, the same number given for the non-agentic share of the whole corpus [17]. They are shares of the full mixture, then, not of their own block. Under that reading the category actually labelled reasoning is 3 percent of the mixture, about a seventh of the software engineering volume [14], while SWE trajectories plus non-agentic coding come to roughly 41 percent [15]. IBM describes 4.2 as the release that adds explicit reasoning to a family that was previously instruction-following assistants [7]. By data volume it is a code and terminal model that can also think out loud.

Two more numbers from the same paragraph of the build post. About 35 of the 100 billion SFT tokens are not trainable [18], so roughly a third of that corpus is context the gradient never touches. And the entire supervised stage is under 0.7 percent of the pre-training token budget [19], which is a thin coat over a conventionally trained base.

On serving, the attention layout is 40 query heads to 8 KV heads [11], a five to one ratio [20]. That ratio is what makes the long-context phase [2] tractable to serve: cache is one fifth of what an equivalent multi-head configuration would want at the same sequence length. RoPE theta is set to 10 million, weights are bfloat16, input and output embeddings are untied [11]. Nothing unusual in the stack, which is rather the point, because at long sequence lengths the capacity question is cache rather than parameters.

The agentic trajectories were generated across a named set of scaffolds, among them OpenHands, SWE-agent, Terminus-2, Codex and Goose, mixing open datasets with IBM's own synthetic RL environments [12]. That breadth is also a distribution: a model trained to call tools inside those harnesses has learned their conventions. IBM's integration claim is that an OpenAI-compatible endpoint under vLLM emits function calls in OpenAI format and plugs into agentic harnesses without extra glue, with SGLang supported as well [6]. That is a claim to test against your own harness rather than accept.

What the material does not contain is a scoreboard. The post walks through architecture, data and the RL stages, and there are no evaluation figures here to place the 30B against anything else. Apache 2.0 across all three sizes [3] is what earns the family an evaluation slot at all; the mixture is what tells you which evaluation to run first.

What to watch

  • Agentic-harness or SWE benchmark numbers for the 8B and 30B published by someone other than IBM.
  • Whether a later point release puts the 3B through the same agentic RL block, which would change the cheap-tier calculus.
  • Measured KV cache footprints at full sequence length on single-card deployments, against the 5 to 1 head ratio the architecture promises.

Clarity's read

What the record supports and how the coverage leans. The claims behind it follow.

Reality

Evidence55
Adoption
Not scored
Hype gap+25
Incentives60
Confidence72

Perspective Coverage

3 publishers
Builder
Builder 63%
Operator
Operator 28%
Investor
Investor 9%
Why these scores

Claim ledger

Ranked by verification strength, evidence, and original report placement.

  1. [1]

    Granite 4.2 is IBM's first family of dense, decoder-only reasoning LLMs, released in three sizes: 3B, 8B and 30B, all sharing the same architectural design and training pipeline.

    Reported Supported Source: Granite Team, IBMView cited source
  2. [2]

    Each model is pre-trained from scratch on approximately 15 trillion tokens using a five-phase strategy; phase 5 introduces long-context training, extending the context window to 512K tokens.

    Reported Supported Source: Granite Team, IBMView cited source
  3. [3]

    All Granite 4.2 models are released under the Apache 2.0 license.

    Reported Supported Source: Granite Team, IBMView cited source
  4. [4]

    Every Granite 4.2 model has a thinking / non-thinking switch, a low-effort thinking mode that spends a short reasoning budget on easy questions, and native tool calling.

    Reported Supported Source: Granite Team, IBMView cited source
  5. [5]

    The 8B and 30B models additionally go through an agentic RL block that teaches them to call tools, edit and run code, drive a terminal and search the web inside real sandboxed environments.

    Reported Supported Source: Granite Team, IBMView cited source
  6. [6]

    Served through an OpenAI-compatible endpoint (for example with vLLM), the models emit tool calls in the OpenAI function-calling format and plug into agentic harnesses without extra glue; Granite 4.2 is also supported in SGLang, with a cookbook recipe.

    Reported Supported Source: Granite Team, IBMView cited source
  7. [7]

    Earlier Granite releases were strong instruction-following assistants; Granite 4.2 adds explicit reasoning, with every model able to produce a chain of thought before its answer.

    Reported Supported Source: Granite Team, IBMView cited source
  8. [8]

    The SFT data mixture combines agentic (31.6%) and non-agentic (68.4%) data, totalling approximately 7.2 million samples, or roughly 100B tokens, of which about 65B are trainable.

    Reported Supported Source: Granite Team, IBMView cited source
  9. [9]

    The agentic corpus covers software engineering (SWE) 69%, tool calling 12.1%, terminal use 8.0%, math 3.5%, search 0.8% and action 0.2%.

    Reported Supported Source: Granite Team, IBMView cited source
  10. [10]

    The non-agentic corpus categories are instruction following 18.8%, coding 18.8%, math 14.6%, multilingual 7.0%, science 5.4%, reasoning 3.0% and safety 0.8%.

    Reported Supported Source: Granite Team, IBMView cited source
  11. [11]

    Architecture: decoder-only dense transformer with Grouped Query Attention using 40 attention heads and 8 KV heads, RoPE with theta = 10,000,000, SwiGLU MLP, RMSNorm (eps = 1e-5), separate (untied) input/output embeddings, bfloat16 precision.

    Reported Supported Source: Granite Team, IBMView cited source
  12. [12]

    Agentic samples and trajectories were generated using a diverse set of agent scaffolds and harnesses including OpenHands, OpenCode, Terminus-2, SWE-agent, OpenResearcher, MiniSWE, OpenSeeker, EnvScaler, Gemini CLI, Hermes, Codex and Goose, combining open-source datasets with IBM's own synthetically generated RL environments.

    Reported Supported Source: Granite Team, IBMView cited source
  13. [13]

    Software engineering trajectories are about 21.8 percent of the entire SFT mixture.

    Derived Supported
  14. [14]

    Read as shares of the full mixture, software engineering trajectories exceed the category labelled reasoning by about seven to one.

    Derived Supported
  15. [15]

    Software engineering trajectories plus non-agentic coding data account for roughly 41 percent of the SFT mixture.

    Derived Supported
  16. [16]

    The agentic portion of the SFT mixture is roughly 2.3 million samples.

    Derived Supported
  17. [17]

    The seven listed non-agentic category percentages sum to exactly 68.4, the same figure given for the non-agentic share of the whole SFT mixture, indicating they are shares of the full mixture rather than of the non-agentic block.

    Derived Supported
  18. [18]

    About 35 of the roughly 100 billion SFT tokens are not trainable, or about 35 percent of the corpus.

    Derived Supported
  19. [19]

    The supervised fine-tuning stage is about 0.67 percent of the pre-training token budget.

    Derived Supported
  20. [20]

    With 40 attention heads to 8 KV heads, the ratio is 5 to 1, so KV cache is one fifth of an equivalent multi-head configuration at the same sequence length.

    Derived Supported
  21. [21]

    The published agentic subcategories sum to 93.6 percent, leaving 6.4 percent of that block unlisted.

    Derived Supported

Sources

3 independent publishers whose own reporting we read for this story.

  1. huggingface.co

    1 article · August 25, 2026

    Granite 4.2 LLMs: How They're Built
  2. the-decoder.com

    1 article · August 26, 2026

    IBM drops open-weight Granite 4.2 family with built-in agentic capabilities under Apache 2.0
  3. thenewstack.io

    1 article · August 25, 2026

    IBM’s new Granite 4.2 models add reasoning and stay dense

Topics and entities

Topics