IBM Published the Whole RL Recipe. Down to the KL Schedule.

TL;DR

On August 25 IBM released Granite 4.2, three reasoning models at 3B, 8B and 30B under Apache 2.0, plus a 470M speech model that transcribes three hours of audio in about a second. All three language models are dense decoder-only transformers, which in the week of a 320B MoE and a 176B MoE reads like a typo. The 30B activates 29.3 billion parameters on every single token, roughly five times what this week's much larger sparse models activate. The genuinely unusual part is not the weights. It is the build writeup, which publishes the entire post-training curriculum: eight reinforcement-learning stages, and for each one the prompts per step, the generations per prompt, the rollout turns and the KL penalty.

What actually shipped

Three sizes, one recipe. granite-4.2-3b is 3,659,737,600 parameters, granite-4.2-8b is 8,791,592,960, and granite-4.2-30b is 29,276,770,304. Every one of them is BF16 dense: grouped-query attention with 8 KV heads, SwiGLU, RMSNorm, RoPE at theta 10,000,000. No experts, no router, no Mamba block.

Pre-training runs from scratch on roughly 15 trillion tokens across five phases, of which one trillion tokens are synthetic code from IBM's CodeAlchemy pipeline. Phase five is the long-context extension. Every model carries a thinking switch with three settings (full thinking, non-thinking, and a low-effort mode that spends a short reasoning budget on easy questions) and a speculative decoding layer for serving.

Distribution is the boring kind that actually matters: Hugging Face, Ollama, FP8 / NVFP4 / MXFP4 variants for vLLM, an SGLang recipe, and fourteen llama.cpp GGUF quants from Q2_K up to Q8_0. The 30B at Q4_K_M is 17.72 GB, which is the number to notice: a 30B dense reasoner that fits a single 24 GB consumer card.

Dense, in the week of the giant sparse models

Sparse mixture-of-experts is how every frontier open-weight drop now buys capacity. Qwen3.8-Flash-Next activates about 6B parameters per token. GLM-5.3-Flash activates 18B of its 320B. Granite's 30B activates all 29.3B, because there is nothing to route.

A sparse MoE is a 300-person consultancy where each ticket gets routed to a five-person pod and everyone else stays at their desk: huge payroll, small meeting. Dense is a 30-person shop where all 30 read every ticket. The consultancy knows more things; the small shop is easier to budget for, because the meeting is always the same size.

That is the practical trade. Dense costs you full compute on every token and gives you back a memory profile that never surprises you: no expert offload, no router imbalance, no host-RAM tricks, and quantization paths that just work. BF16 weights land at 7.3 GB, 17.6 GB and 58.6 GB. The 8B at Q4_K_M is 5.35 GB, which is a laptop.

The part nobody else publishes

Most labs ship weights and a paragraph of vibes about post-training. IBM shipped the ladder. After supervised fine-tuning, Granite 4.2 goes through a chain of independent GRPO runs, each targeting one capability and warm-starting from the previous checkpoint.

The numbers are all there. The first RLVR stage pairs 256 prompts with 16 sampled responses each, for a 4,096-example batch per optimizer step. Advantages are group-relative with a leave-one-out baseline, so there is no value network. Generation and training sit on separate GPU pools and never block on each other, workers are allowed to drift at most one update behind the trainer so they can reuse their KV cache instead of rebuilding it, and whatever staleness survives that is clamped by truncated importance sampling.

The KL schedule follows the reward type, which is the kind of design note you normally only hear at a conference bar. Explore freely where the reward is objectively checkable (RLVR and the second SWE stage run at KL 0); stay close to the reference policy where the objective is preference, safety, or a narrow skill graft (RLHF and the code booster use KL 0.05).

The SFT mixture is disclosed too: about 7.2 million samples, roughly 100B tokens of which 65B are trainable, split 31.6% agentic and 68.4% not. Inside the agentic slice, software engineering is 69%, tool calling 12.1%, terminal use 8.0%. Those trajectories were generated across a dozen agent scaffolds including OpenHands, OpenCode, SWE-agent, Terminus-2, Gemini CLI, Codex and Goose. Quality control ran GPT-OSS-120B and Gemma 4 as judges, then deduplicated by SHA-256 over the combined tools and messages fields.

Training ran on an NVIDIA GB200 NVL72 cluster at CoreWeave, with NeMo-RL driving the GRPO loop and NeMo-Gym hosting the sandboxes, verifiers and tools behind one uniform interface, so a rule-based math checker and a full repo container look identical to the trainer.

One editorial detail worth savoring: the raw markdown of the 30B model card still contains the line <!-- TODO: Add pre-training details here -->. They published the per-stage KL penalties and forgot to delete the TODO.

Where it actually lands

The 30B posts 57.0 on SWE-bench Verified, 33.29 on SWE-bench Pro, 41.89 on SWE-bench Multilingual and 29.24 on Terminal-Bench 2.1. On reasoning it turns in 89.17 on AIME25, 66.41 on GPQA, 75.77 on LiveCodeBench v6 and 77.60 on MMLU-Pro. The 8B gets 47.67 on SWE-bench Verified, which for a model you can run on a laptop is the more interesting row.

Now the honest framing. Z.ai's own published table puts GLM-5.3-Flash at 84.3 on Terminal-Bench 2.1. Granite's flagship posts 29.24 on the same benchmark. These are not competitors; one is a 320B sparse frontier model and the other is a 30B you can quantize onto a gaming card. Buy the second one for what it is, not for what the first one does.

Two caveats on the scores. They are IBM's own runs through an evaluation framework built on the NeMo Evaluator SDK, with no independent replication yet. And IBM's two artifacts disagree with each other on one row: the technical blog lists the 8B at 50.29 on BFCL v4, the model card says 52.39. Small, but it is a reminder that these tables are vendor-reported.

512K is a number on the box

The marketing line is a 512K context window. The model card is more precise: natively 128K, with a long-context extension to 512K, and the architecture table lists a sequence length of 131,072. The published long-context evaluation stops at 128K.

None of this is unusual, and none of it is a lie. It is just the standard gap between a trained-for length and a measured-at length. Budget your agent for 128K, and if you need more, run RULER yourself before you promise it to anyone.

The speech model is the sleeper

Shipped the same day and getting a fraction of the attention: Granite Speech 5.0 Turbo CTC, 470 million parameters, Apache 2.0, English only. Unlike the 4.1 speech models it has no LLM backbone at all. It is 16 conformer blocks trained with connectionist temporal classification on roughly 60,000 hours of public English audio, decoded non-autoregressively with greedy search.

The architecture is built around throwing frames away on purpose. Temporal subsampling of 8x takes the frame rate from 100Hz to 12.5Hz, first by stacking and skipping log-mel and delta frames, then through strided convolutions and pooled residuals in the first two conformer blocks, with block attention over 128-frame windows.

The payoff, per IBM's testing: the current speed leaders on the Open ASR Leaderboard sit around 6,000 RTFx, and this one comes in near 12,600 on a single H200. Which works out to about three hours of recorded audio transcribed per second. It needs transformers 5.16.0 or newer, and it will run on a laptop.

What to do with this

• Running local agents: start with the 8B. It went through the agentic RL block, emits OpenAI-format tool calls out of the box, and its Q4_K_M GGUF is 5.35 GB.
• One 24 GB card: the 30B at Q4_K_M is 17.72 GB, so the flagship is genuinely reachable, KV cache permitting.
• Training your own: the RL configuration table is the artifact here, not the weights. Stage list, prompts per step, generations per prompt, sequence length, rollout turns, KL and learning rate, all published for a model you can also download and check.
• Transcribing anything English: the 470M CTC model is a drop-in speed upgrade over anything with an LLM decoder stapled to it.

Key Takeaways

• Granite 4.2 landed August 25 in 3B, 8B and 30B, all dense decoder-only transformers under Apache 2.0, pre-trained from scratch on roughly 15T tokens including 1T tokens of synthetic code.
• The 30B activates 29.3B parameters per token, about five times what Qwen3.8-Flash-Next activates and more than GLM-5.3-Flash's 18B, despite being a fraction of their size on disk.
• IBM published the complete post-training curriculum: eight staged GRPO runs with per-stage prompts, generations, rollout turns and KL penalties, plus the async training design and the SFT data mixture.
• Benchmarks are respectable for the size and not frontier: 57.0 on SWE-bench Verified for the 30B, against 29.24 on Terminal-Bench 2.1 where a 320B sparse model posts 84.3.
• The 512K context is advertised but only evaluated to 128K, where the 30B scores 81.38 on RULER. Plan around the measured number.
• Granite Speech 5.0 Turbo CTC is 470M parameters with no LLM backbone and roughly 12,600 RTFx on one H200, about three hours of English audio per second.

Sources: IBM Research, Granite 4.2 brings native reasoning to enterprise agents, Granite 4.2 LLMs: How They're Built (IBM Granite technical blog), ibm-granite/granite-4.2-30b model card, ibm-granite/granite-4.2-8b model card, ibm-granite/granite-4.2-3b model card, Granite Speech 5.0 Turbo CTC model card, ibm-granite/granite-4.2-language-models on GitHub, Granite 4.2 Hugging Face collection, Z.ai, GLM-5.3-Flash, Qwen3.8-Flash-Next model card, The Decoder