IBM's Granite team shipped something genuinely interesting this week: Granite 4.2, a family of three reasoning-focused language models (3B, 8B, 30B) that are Apache 2.0 licensed and trained from scratch with a sophisticated multi-stage curriculum. This isn't another quick fine-tune on top of Llama. It's a full soup-to-nuts build with explicit design choices at every layer—from a five-phase 15-trillion-token pre-training run through a multi-environment reinforcement learning pipeline that spans math, code, and full agentic workflows.
What caught my attention isn't just the release itself. It's the how. The technical writeup is remarkably transparent about training methodology, data mixtures, and the staged RL curriculum that takes these models from base→SFT→foundational RL→agentic RL. It's the kind of build log I wish more labs would publish.
Three Sizes, One Architecture, Shared Training Path
All three Granite 4.2 models—3B, 8B, and 30B parameters—share the same core architecture: decoder-only dense transformers with Grouped Query Attention (40 attention heads, 8 KV heads), RoPE positional embeddings with θ = 10,000,000, SwiGLU-activated MLPs, and RMSNorm. They're trained in bfloat16 and support a 131K token context window out of the gate, extended to 512K during the final pre-training phase.
The 3B model has 40 layers with 2560 embedding dimension. The 8B has 40 layers at 4096 dimension. The 30B scales to 64 layers, keeping the 4096 embedding size but widening the MLP hidden dimension to 32,768. Standard scaling laws, cleanly executed.
What's not standard is how they're trained. Every model follows the same five-phase pre-training curriculum, the same SFT data blend (roughly 7.2 million samples, ~100B tokens with 65B trainable), and then diverges during RL. The 3B gets foundational RL only. The 8B and 30B add an agentic RL block on top, teaching them to operate as agents with tools, terminals, and web search inside real sandboxed environments.
Pre-Training: Five Phases, 15 Trillion Tokens, 512K Context
Granite 4.2 is pre-trained from scratch on approximately 15 trillion tokens using a five-phase strategy. Phases 1–2 are foundational pre-training on broad web-scale data. Phases 3–4 shift to mid-training with progressively higher-quality data annealing—the mix becomes more curated, less noisy. Phase 5 introduces long-context training, extending the context window to 512K tokens.
Each phase uses a distinct data mixture and learning-rate schedule. The recipe closely follows Granite 4.1, which IBM documented in detail in an earlier blog post. This kind of phased curriculum is becoming standard practice for frontier models—start broad, anneal to quality, then specialize—but it's rare to see the full phase breakdown published openly.
The 512K context extension is notable. Most open models top out at 128K or 200K. IBM is pushing the window wider, which matters for agentic workflows where you need to maintain conversation history, tool call results, and environment state across long interactions.
SFT: 31.6% Agentic, 68.4% Non-Agentic, Rigorous Quality Control
Supervised fine-tuning mixes agentic and non-agentic data in a 31.6% / 68.4% split. The agentic corpus is dominated by software engineering trajectories (69% of agentic data), followed by tool calling (12.1%), terminal use (8.0%), math (3.5%), search (0.8%), and action tasks (0.2%). These samples come from a diverse set of agent scaffolds: OpenHands, OpenCode, Terminus-2, SWE-agent, OpenResearcher, MiniSWE, and others.
The non-agentic side covers instruction following (18.8%), coding (18.8%), math (14.6%), multilingual (7.0%), science (5.4%), reasoning (3.0%), and safety (0.8%).
Quality control is multi-layered. First, data from different sources is normalized into OpenAI Chat format for consistency. Then GPT-OSS-120B and Gemma 4 are used as LLM judges to score samples. Low-scoring samples are filtered out, as are samples with hallucinated information, invalid tool interactions, or tool calls to undefined functions. Dataset-specific heuristic rules add another layer of filtering. Finally, both local and global deduplication run on SHA-256 hashes of the tools and messages fields.
The resulting corpus is globally shuffled, tokenized, and partitioned into .parquet shards for distributed training. Models train for roughly two epochs at a learning rate of 1.0e-5 (constant after a 2.5% warm-up) with a global batch size of 128 and 131K packed sequence length.
The 30B model gets a second SFT phase focused on agentic coding. Agentic, SWE, and coding data are upsampled, with 16% replay data from the original SFT mix. The model trains for one more epoch at a lower learning rate (3.0e-6). This targeted second pass increases exposure to agentic coding trajectories without forgetting the broader capabilities from phase one.
Multi-Stage RL: A Chain of Focused Environments
This is where Granite 4.2 gets interesting. Instead of a single RL pass, IBM runs a staged curriculum of independent RL runs, each targeting one capability and warm-starting from the previous checkpoint.
The pipeline has two blocks. Foundational RL (runs for all sizes) covers:
- RLVR (verifiable rewards): Math, code, science, instruction following, tool use, structured output
- Skill boosters: Targeted passes on specific tasks
Agentic RL (8B and 30B only) adds:
- SWE: Software engineering in real environments
- Terminal: Command-line interaction
- Search: Web search tasks
Every stage finishes with a final RLHF pass.
Each stage is an independent GRPO (Group Relative Policy Optimization) run. GRPO is a policy-gradient method that uses group-relative advantages with a leave-one-out baseline, eliminating the need for a separate value network. Each prompt is paired with multiple sampled responses (e.g., 256 prompts × 16 responses = 4,096 examples per step), and each response is judged against the mean reward of the other samples for the same prompt.
IBM uses asynchronous GRPO so the generator and trainer never block on each other. A pool of generation workers continuously samples responses into a shared buffer. Once the buffer holds a full step's worth, the trainer pulls the batch, takes an optimizer step, and streams updated parameters back to the generators without pausing them. Workers reuse their KV cache across updates instead of rebuilding it. A staleness limit keeps workers from drifting more than one update behind the trainer, and truncated importance sampling clamps the train-versus-generation log-probability ratio to prevent stale tokens from dominating updates.
This asynchronous setup is pragmatic. Synchronous RL wastes compute waiting for the slowest sample. Async RL keeps both halves of the loop saturated, accepts mild off-policy drift, and corrects for it in the objective.
Thinking / Non-Thinking Modes and Low-Effort Reasoning
Every Granite 4.2 model has a thinking / non-thinking switch. In thinking mode, the model produces an explicit chain of thought before its answer. In non-thinking mode, it jumps straight to the response. There's also a low-effort mode that spends a short reasoning budget on easy questions.
This is similar to the reasoning budget controls in DeepSeek-R1 and OpenAI's o1 family. The idea is that not every question needs full deliberation. Simple queries can skip the reasoning trace and answer directly, saving compute. Hard questions get the full chain-of-thought treatment.
The thinking/non-thinking distinction is enforced during training, not just at inference. The models learn when to reason and when to answer directly based on task complexity. This is a more efficient approach than always running the full reasoning loop.
Native Tool Calling and Agentic Workflows
All three models support native tool calling. Served through an OpenAI-compatible endpoint (e.g., vLLM), they emit tool calls in OpenAI's function-calling format and plug into agentic harnesses without extra glue. SGLang also supports Granite 4.2 with a ready-to-serve recipe in their cookbook.
The agentic RL block (8B and 30B) teaches models to operate as agents: calling tools, editing and running code, driving a terminal, and searching the web inside real sandboxed environments. This isn't synthetic RL on held-out test sets. These are real environments with real tools, real failure modes, and real reward signals.
The agentic data pipeline spans multiple scaffolds and harnesses (OpenHands, OpenCode, Terminus-2, SWE-agent, etc.), which means the models see diverse agentic interaction patterns during training. This diversity likely improves generalization to new tools and environments at inference time.
Why This Matters
Granite 4.2 is Apache 2.0 licensed. You can run it, fine-tune it, and deploy it commercially without restrictions. That's table stakes for open models now, but it's worth emphasizing: these are reasoning models with agentic capabilities, trained from scratch, released under a permissive license.
The technical transparency is equally important. IBM published the full training recipe: data mixtures, quality control steps, hyperparameters, phase breakdowns, and the staged RL curriculum. This is the kind of documentation that makes open models actually useful for researchers and practitioners who want to understand how these systems work, not just that they work.
The multi-stage RL pipeline is particularly interesting. Most RL papers describe a single pass over a single reward function. Granite 4.2's approach is more realistic: a chain of focused stages, each targeting a different capability, each warm-starting from the previous checkpoint. It's closer to how you'd actually build a production system—iterative, modular, with clear stage boundaries.
The 8B and 30B models' agentic RL block is the differentiator. Teaching models to operate as agents in real environments with tools, terminals, and search is harder than supervised fine-tuning on static trajectories. It requires real sandboxes, diverse harnesses, and reward signals that reflect actual task success. IBM did that work and released the results openly.
Open Questions
A few things I'd like to see:
- Eval results: The blog post is a technical walkthrough, not a benchmark report. I'd like to see how Granite 4.2 performs on GPQA, AIME, SWE-bench, and agentic benchmarks like WebArena or OSWorld.
- Thinking token efficiency: How many reasoning tokens does the model emit on average in thinking mode? What's the latency cost versus non-thinking mode?
- Agentic RL reward design: The post mentions "real sandboxed environments" but doesn't detail the reward functions for the SWE, terminal, and search stages. How are success and failure defined? Are rewards sparse or dense?
- Ablations: What happens if you skip the agentic RL block? How much does each RL stage contribute to downstream performance?
These aren't criticisms—the post is already more detailed than most model releases. But ablation studies and stage-by-stage eval breakdowns would make the work even more valuable for researchers trying to replicate or extend this approach.
Bottom Line
Granite 4.2 is a serious release. It's not the biggest model, not the flashiest benchmark performance, but it's a well-executed build with transparent methodology and permissive licensing. The staged RL curriculum is pragmatic and modular. The agentic RL block for 8B and 30B is ambitious. The thinking/non-thinking modes are a smart efficiency tradeoff.
If you're building agentic systems or evaluating open reasoning models, Granite 4.2 is worth a look. The HuggingFace collection has all three sizes ready to download. The GitHub repo and docs have additional resources.
And if nothing else, read the blog post. It's a model for how to document a complex training pipeline clearly and completely.