IBM introduces Granite 4.2, AI models with reasoning

IBM launched Granite 4.2, a new family of AI models capable of reasoning, using tools and working in real-world environments. It is available in three sizes: 3 billion, 8 billion and 30 billion parameters, all under the open Apache 2.0 license.

The difference from previous Granite generations lies in the training. These models do more than follow instructions: they can devote more or less effort to a task, call external functions and complete multi-step processes, such as editing code, running commands or searching the web.

Three models for different needs

Granite 4.2 is available in 3B, 8B and 30B versions. All three share the same general architecture and were trained from scratch with approximately 15 trillion tokens, a unit used to measure the volume of text and code processed during training.

IBM applied a five-phase training strategy. The first phases focused on general knowledge, the following phases progressively improved data quality and the final phase added training to handle contexts of up to 512,000 tokens. This makes it possible to work with very large documents, histories or code repositories, although the specific limit will depend on the deployment configuration.

The 3B model follows a shorter training path. The 8B and 30B versions also receive specific training to act as agents, meaning systems that do more than generate text: they perform actions and check their results.

It can reason, respond quickly and use tools

All models include three operating modes:

• Reasoning mode, for complex tasks such as mathematics, programming or analysis.
• Non-reasoning mode, for quickly answering simple questions.
• Low-effort mode, which applies a brief amount of processing to easy problems.

They also include native tool calling. In practice, you can connect a weather function, database or search engine and have the model decide when to use it. Granite 4.2 can analyze the request, make the call and then write a response based on the result received.

Compatibility with OpenAI's function-calling format allows it to connect with servers such as vLLM and agent tools such as OpenCode, OpenHands or Pi without creating specific adapters. It also supports SGLang.

How it learned to work as an agent

After the initial training, IBM fine-tuned the models with around 7.2 million samples, equivalent to nearly 100 billion tokens. The dataset combined examples of conversation, programming, mathematics, science, instruction following and tool use.

A multi-stage reinforcement learning process followed. Instead of optimizing everything at once, IBM divided the capabilities into blocks:

• Mathematics, code, science and instruction following.
• Software engineering, using real repositories and automated tests.
• Terminal use, with commands executed in isolated environments.
• Web search for answering questions that require multiple sources.
• Human preferences, safety and control of overly long responses.

The 8B and 30B versions complete all agent-training stages. The 3B model receives general reasoning training, but not the block that teaches it to operate with terminals, repositories and web searches.

Results and availability

In tests published by IBM, Granite 4.2 30B scored 57% on SWE-bench Verified, a benchmark that measures whether an agent can solve real software problems, compared with 47.67% for the 8B model. On Terminal-Bench 2.1, it reached 29.24%, while the 8B model scored 20.56%.

In reasoning, the 30B model achieved 89.17% on AIME25, a mathematics test, and 66.41% on GPQA, which includes advanced-level science questions. For long-context understanding, it scored 89.96% on RULER with 64K tokens and 81.38% with 128K.

IBM also released quantized versions in FP8, NVFP4, MXFP4 and several GGUF formats. Quantization reduces memory use so the models can run with fewer resources, although the exact result depends on the format and hardware.

For you, the main consequence is that Granite 4.2 can be installed and run locally or on your own infrastructure, without necessarily relying on a closed API. The 3B model is aimed at lighter deployments; the 8B and 30B models are designed for programming and agents capable of carrying out complete tasks.

Granite 4.2 shows where open AI software is heading: models that combine text generation, reasoning and tool use within a single system. What matters now is seeing how much of that performance holds up outside testing environments and what resources each size requires in real-world situations.