IBM Teaches Tool Use Only to Granite 4.2's 8B and 30B Models

All three models share the same transformer architecture and go through the same training pipeline — pretraining, supervised fine-tuning (SFT), and multi-stage reinforcement learning. But the actual capabilities each size ends up with diverge sharply. Agentic training on real tool use was applied only to the 8B and 30B models; the 3B was skipped entirely. So while all three can "think," only two of them know how to actually use their hands.

15 trillion tokens, built in five stages

Granite 4.2 was trained from scratch. It went through roughly 15 trillion tokens of training across five stages: stages 1 and 2 cover basic pretraining, stages 3 and 4 are mid-training that progressively narrows toward higher-quality data, and stage 5 is long-context training that extends the context window out to 512K tokens. At 512K tokens, the model can take in and read something on the scale of several thick books' worth of text in a single pass.

After that came the SFT stage, where the model was shaped into something actually usable as an assistant. The SFT dataset consists of about 7.2 million samples, roughly 100 billion tokens (of which about 65 billion tokens actually factored into training). Agentic data made up 31.6% of that, with general instruction and reasoning data accounting for the remaining 68.4%.

Agentic data subcategory	Share
Software engineering (SWE)	69.0%
Tool calling	12.1%
Terminal use	8.0%
Math	3.5%
Web search	0.8%
Action	0.2%

The agentic data was generated using a range of agent harnesses, including OpenHands, OpenCode, Terminus-2, SWE-agent, Gemini CLI, Hermes, Codex, and Goose, supplemented with reinforcement learning environment data IBM built in-house. For quality checks, IBM used OpenAI's open-weight model gpt-oss-120b and Google DeepMind's Gemma 4 as judge models to filter out hallucinated responses and tool calls invoking undefined functions. Deduplication was handled using SHA-256 hashes computed over the combined tool list and conversation content.

The 8B and 30B learned how to actually use tools

After SFT comes multi-stage reinforcement learning. The first phase is RLVR, which trains on math, code, science, instruction-following, tool use, and structured output using verifiable rewards. That's followed by a block of agentic RL that proceeds through software engineering (SWE), then terminal use, then web search, in that order. The final stage is RLHF, which incorporates human preferences and safety considerations.

Each stage is a separate GRPO (Group Relative Policy Optimization) run that picks up from the previous stage's checkpoint. The first round of RLVR samples 16 responses per prompt across 256 prompts, training on batches of 4,096. The 3B and 8B models repeat this round twice, while the 30B repeats it three times.

Model	Parameters	Agentic RL (SWE → terminal → search)	Additional SFT
Granite 4.2 3B	3B	None	None
Granite 4.2 8B	8B	Yes	None
Granite 4.2 30B	30B	Yes	Second-round agentic coding SFT (~1 epoch, learning rate 3.0e-6)

The 3B goes only through the base RL and alignment stages, skipping the agentic RL block entirely. The 30B, on the other hand, goes through an additional round of SFT, in which the share of SWE and coding data was increased while 16% of the original SFT data was kept as replay to preserve prior capabilities.

A switch for turning reasoning on and off, plus tool calling

All three models can toggle between thinking and non-thinking modes, with a low-effort mode in between that spends a smaller reasoning budget on easy questions. Tool calling follows OpenAI's function-calling format exactly, so serving the models through an OpenAI-compatible endpoint like vLLM lets them plug straight into existing agent harnesses without any format conversion. A ready-to-serve recipe is also available in the SGLang cookbook.

How to try it

All three weight sets — 3B, 8B, and 30B — for Granite 4.2 can be downloaded from the github.com/ibm-granite/granite-4.2-language-models repository, and since all three are released under Apache 2.0, there are no restrictions on modifying them for commercial use. Serving them through vLLM or SGLang produces tool calls in OpenAI's function-calling format out of the box, which means agent code already built for OpenAI models can be migrated over simply by swapping in the Granite model.

The real decision point in practice is which size to pick. For chat and summarization tasks that don't require tools, the 3B is plenty. But for actual agentic workflows — fixing code, running terminal commands, searching the web — you'll want the 8B or larger, since those are the ones that went through agentic RL. The 30B goes a step further with a second round of SFT focused specifically on software engineering tasks, making it the best fit for a coding agent that needs to directly modify code repositories.

Editor's view

IBM's timing in adding reasoning to the Granite line — previously known for its strength in instruction-following — is well chosen. The open reasoning-model race kicked off by DeepSeek has run through the entire year, and just recently Meta released Muse Glimmer, a 30B-class dense model aimed at local agent use. IBM matching that same 30B weight class and adding a second round of agentic-coding SFT on top suggests it isn't chasing chat quality — it's aiming squarely at the market for agents that fix code directly inside enterprise environments.

The decision to leave agentic RL out of the 3B model is also worth noting. This isn't a case of holding back performance — it's a deliberate division of purpose. The 3B stays in its lane as an instruction-following assistant meant for on-device or low-cost API use, while tool-manipulation capability was concentrated entirely in the 8B and 30B. Past open model releases often just scaled the same capability up or down across sizes. Stripping out a specific capability from a specific size class, as IBM has done here, actually makes deployment decisions clearer — if you picked the 3B, you shouldn't expect it to handle agentic work in the first place.

For teams in Korea running agent pipelines on-premise, the combination of the Apache 2.0 license and OpenAI-compatible function-calling format is a real practical advantage — tool definitions and harness code already built for OpenAI or other vendors can stay as-is, with only the model swapped out. Still, the choice between the 8B and 30B should be based on GPU budget and task difficulty. Simple tool calling may be well served by the 8B, while tasks that involve fixing an entire repository will likely be more reliable on the 30B, given its extra round of SFT.

In the coming weeks, we should start seeing agentic coding benchmark results comparing this model against other 30B-class open models. Whether IBM's SWE-focused second-round SFT actually translates into a measurable difference in code-fix success rates will be the first real test of whether concentrating tool use in only the 8B and 30B was the right call.