Granite 4.2: The Open Reasoning Family That Actually Does the Work

IBM Ships Three Apache 2.0 Reasoning Models With Agentic RL

Hugging Face published the full engineering walkthrough for IBM’s Granite 4.2 family today, detailing how three dense reasoning models were trained from scratch and released under Apache 2.0.

The lineup spans 3B, 8B, and 30B parameters, with each model pre-trained on roughly 15 trillion tokens through a five-phase schedule that pushes the context window to 512K tokens.

All three variants feature thinking, non-thinking, and low-effort reasoning modes, plus native tool calling and an OpenAI-compatible serving path.

The decisive split appears in post-training, as detailed in the Hugging Face engineering walkthrough: the 8B and 30B models run an additional agentic reinforcement-learning block that teaches them to edit code, operate terminals, and search the web inside live environments.

Inside the Training Pipeline: 15 Trillion Tokens, 512K Context, and a Five-Phase Curriculum

Architecture Shared Across Scales

The family uses a decoder-only dense transformer with grouped query attention, SwiGLU feed-forward layers, RMSNorm, and rotary position embeddings with a base theta of 10,000,000.

• Attention: 40 attention heads and 8 KV heads.
• Precision: bfloat16 throughout, with separate input and output embeddings.
• 3B Dense: embedding size 2560, 40 layers, MLP hidden size 8192.
• 8B Dense: embedding size 4096, 40 layers, MLP hidden size 12800.
• 30B Dense: embedding size 4096, 64 layers, MLP hidden size 32768.

Pre-Training and SFT Quality Control

Pre-training ran from scratch on roughly 15 trillion tokens, with phases one and two building broad knowledge and phases three and four shifting toward curated, high-quality data.

Phase five is the long-context training step that extends the model to 512K tokens.

SFT uses about 7.2 million samples, or roughly 100B tokens, with 31.6 percent agentic data and 68.4 percent non-agentic data.

The agentic corpus includes software engineering, tool calling, terminal use, math, search, and action; the non-agentic side spans instruction following, coding, math, multilingual, science, reasoning, and safety.

Large-scale SFT runs used 32 to 128 nodes, each with four Grace/GB200 accelerators, a packed sequence length of 131,072 tokens, and a global batch size of 128.

Before training, samples are normalized into OpenAI Chat format and scored by GPT-OSS-120B and Gemma 4 judges.

Low-quality, hallucinated, and invalid tool interactions are removed, followed by SHA-256 deduplication across tools and messages.

The 30B model also receives a second SFT phase focused on agentic coding, using 16 percent replay from the original corpus and an additional epoch at a lower learning rate.

Multi-Stage RL Curriculum

Post-training is organized as a chain of independent reinforcement-learning stages, each warm-started from the previous checkpoint.

The sequence runs from verifiable-reward RL and skill boosters through software engineering, terminal, search, and finally RLHF.

• Verifiable rewards: exact-match checks, unit tests, format validators, and rule-based ground truth.
• Reward model / LLM judge: open-ended quality, preference, safety, and answer correctness.
• Agentic outcome: whether the model actually solved the task in a real environment.

The training algorithm is asynchronous GRPO, with generation workers and the trainer connected through a shared buffer rather than blocking each other.

Stale-policy mismatch is handled with truncated importance sampling and a leave-one-out group-relative baseline, removing the need for a separate value network.

In the foundational RLVR stage, each step pairs 256 prompts with 16 sampled responses for a 4,096-example batch; later agentic stages change the shape of each run while preserving the same backbone.

The 8B and 30B models then learn to act inside OpenHands software-engineering sandboxes, Harbor and Terminus-2 terminal environments, and live web-search loops.

Every model closes with RLHF using a generative reward model, a safety reward, and a reasoning-length penalty to prevent overly verbose chain-of-thought responses.

Infrastructure Scale

Training ran on an NVIDIA GB200 NVL72 cluster hosted by CoreWeave, combining 72-GPU NVLink domains with a non-blocking 400 Gb/s InfiniBand fabric.

The reinforcement-learning stack couples NeMo-RL on the training side with NeMo-Gym on the rollout side, exposing tools, sandboxes, verifiers, and reward models as pluggable resources.

Benchmarks, Quantization, and Deployment: The Operational Numbers

IBM’s published results show consistent gains as model size increases across reasoning, agentic coding, and long-context tasks.

On SWE-Bench Verified, the 8B reaches 47.67 percent while the 30B hits 57.00 percent; Terminal-Bench 2.1 scores are 20.56 for 8B and 29.24 for 30B.

Reasoning follows the same curve: the 30B records 89.17 on AIME25, 66.41 on GPQA, and 75.77 on LiveCodeBench v6.

Long-context quality also scales, with RULER at 128K climbing from 55.30 for 3B to 81.38 for 30B.

Supported languages include English, German, Spanish, French, Japanese, Portuguese, Arabic, Czech, Italian, Korean, Dutch, and Chinese.

The release includes four quantized paths: FP8 with dynamic per-channel weights, NVFP4 and MXFP4 via GPTQ calibrated on 2K SFT samples, and GGUF formats from Q8_0 down to Q2_K.

Serving is built around vLLM and SGLang with OpenAI-compatible endpoints; the Transformers examples cover thinking, non-thinking, low-effort, tool calling, multi-turn exchanges, and history-thinking truncation.

Native integrations with OpenCode, Pi, and OpenHands give the models a direct route into agentic coding harnesses without custom adapters.

The 3B model remains a foundational RL model and does not run the agentic SWE, terminal, or search stages.

Why Agentic RL Is the Strategic Moat in Open-Model Competition

Granite 4.2 lands at a moment when open-model providers are competing less on static text generation and more on the ability to complete work inside live systems.

By publishing full stage-by-stage RL configurations, hyperparameters, and infrastructure details, IBM shifts transparency from marketing language to operational evidence.

The agentic RL block is the real differentiator because it turns the model from a responder into an executor, and the 8B and 30B curves show that this transition is not architecture alone.

At the same time, the barrier to replication sits less in the model weights than in the infrastructure: thousands of GB200 GPUs, live sandboxes, and asynchronous GRPO orchestration remain expensive to operate.

That creates an unusual market position, where the models are open under Apache 2.0, but the full training recipe is demanding enough to protect an operational lead.

The size spread also maps cleanly to deployment economics: 3B targets latency-sensitive edge work, 8B offers agentic capability at lower cost, and 30B addresses heavier SWE and terminal workloads.

With on-prem and sovereign AI requirements rising across regulated sectors, a permissively licensed model with GGUF, FP8, and FP4 artifacts becomes a candidate for stacks that cannot depend on public APIs.

That makes Granite 4.2 less a single release and more a reproducible baseline for enterprise teams that need reasoning, tool use, and local control in the same package.

The New Baseline for Open Enterprise Reasoning

Granite 4.2 resets what an open reasoning model can disclose and deploy, moving the baseline from answering prompts to executing verified work in real environments.

For teams building AI automation or deep-research pipelines that need reliable open-model reasoning, the programmatic SEO and AI automation service at Andres SEO Expert is built for this shift — contact us to map it to your stack.