IBM Granite 4.2 8B Now Available on DeepInfra

Granite 4.2 8B ships with three selectable reasoning modes: full chain-of-thought via <think>…</think> tags, a low-effort shortcut, and a direct-answer mode that skips reasoning entirely.

This lets you trade compute for latency on a per-query basis without swapping model weights.

It is the mid-size member of IBM’s Granite 4.2 dense reasoning family, built for general-purpose enterprise workloads.

On AIME 2025 the 8B scores 86.67, and it hits 47.67 on SWE-Bench Verified. The latter tends to be a more honest signal for agentic coding capability than synthetic evals.

The reasoning capability comes from a three-stage training pipeline: supervised fine-tuning on permissive and synthetic data, then multi-environment reinforcement learning via GRPO.

The GRPO stage spans math, code, tool use, and structured output.

A preference-alignment phase for helpfulness and safety follows. Tool calling is reasoning-augmented, so the model thinks through which tool to invoke before calling it, using OpenAI’s function definition schema.

It ships under Apache 2.0 with full transparency disclosures and supports a native 128K context window. The model became available on IBM’s GitHub and Hugging Face on August 25, 2026.

Granite 4.2 8B is available on DeepInfra as a public API endpoint.

What Makes This Model Different

Granite 4.2 8B is a decoder-only dense transformer built on the GraniteForCausalLM architecture, post-trained from Granite 4.1 8B Base through a three-stage pipeline.

This pipeline runs large-scale pre-training, then supervised fine-tuning on a mix of permissive public datasets, synthetic data, agentic traces, and curated human data.

It finishes with multi-phase reinforcement learning using Group Relative Policy Optimization across math, code, science, tool use, and instruction following.

A preference-alignment phase for safety and conversational quality follows that.

The architecture uses grouped query attention with 32 attention heads and 8 KV heads, SwiGLU activations, RMSNorm, and RoPE with a base frequency of 10M.

This setup balances throughput with long-context stability.

Selectable Reasoning Modes

Selectable reasoning per query is one of the more practical design decisions here. Rather than committing to always-on chain-of-thought, the model exposes three modes:

• Thinking (enable_thinking=True): full <think>…</think> chain-of-thought before answering
• Non-thinking (enable_thinking=False): direct answer, no reasoning overhead
• Low-effort (enable_thinking=True, low_effort=True): brief reasoning for simpler queries

This lets you tune inference cost and latency to query complexity without maintaining separate model checkpoints, which matters at scale and simplifies deployment.

If you want to run the model locally, ibm/granite4.2:8b-q3_K_M is available on Ollama as a quantized build.

The model is also accessible directly through HuggingChat for quick experimentation without any infrastructure setup.

Long Context and Benchmarks

The model natively supports a 128K context window (sequence length of 131,072 tokens), with a 512K long-context extension available. On the RULER long-context benchmark, the 8B scores 80.99 at 64K and 71.41 at 128K, solid retention for a model this size.

On benchmarks, the 8B holds up well across reasoning and coding tasks:

IBM’s benchmarks are self-reported, so treat these numbers as directional rather than definitive until independent evaluations catch up.

Tool Use and Deployment

Tool calling is reasoning-augmented: the model reasons through tool selection before invoking, using OpenAI’s function definition schema. It has been validated with agentic coding environments including OpenCode, Pi, and OpenHands, and is optimized for deployment via vLLM (v0.20+). Multilingual support covers 12 languages: English, German, Spanish, French, Japanese, Portuguese, Arabic, Czech, Italian, Korean, Dutch, and Chinese.

Getting Started on DeepInfra

Granite 4.2 8B is available on DeepInfra as a public API endpoint. Pricing is usage-based: $0.06 per 1M input tokens, $0.25 per 1M output tokens, and $0.015 per 1M cached tokens.

The context window on DeepInfra is 131,072 tokens, and the model runs in bfloat16 precision. JSON output and function calling are both supported out of the box.

DeepInfra exposes Granite 4.2 8B through an OpenAI-compatible API, so there is no SDK to learn and no infrastructure to manage. Swap your base URL and model name, and you are running.

DeepInfra operates with a zero data retention policy and is SOC 2 and ISO 27001 certified. The API reference has the full breakdown of supported parameters and request formats.

Quickstart

cURL:

curl https://api.deepinfra.com/v1/openai/chat/completions \

  -H "Authorization: Bearer $DEEPINFRA_TOKEN" \

  -H "Content-Type: application/json" \

  -d '{

    "model": "ibm-granite/granite-4.2-8b",

    "messages": [{"role": "user", "content": "Explain GRPO in two sentences."}]

  }'
copy

Python:

from openai import OpenAI

client = OpenAI(

    api_key="$DEEPINFRA_TOKEN",

    base_url="https://api.deepinfra.com/v1/openai",

)

response = client.chat.completions.create(

    model="ibm-granite/granite-4.2-8b",

    messages=[{"role": "user", "content": "Explain GRPO in two sentences."}],

)

print(response.choices[0].message.content)

JavaScript:

import OpenAI from "openai";

const client = new OpenAI({

  apiKey: "$DEEPINFRA_TOKEN",

  baseURL: "https://api.deepinfra.com/v1/openai",

});

const response = await client.chat.completions.create({

  model: "ibm-granite/granite-4.2-8b",

  messages: [{ role: "user", content: "Explain GRPO in two sentences." }],

});

console.log(response.choices[0].message.content);
copy

The only things you need to change from an existing OpenAI integration are the base URL, your API key, and the model name. The official OpenAI Python and Node.js libraries work without modification.

Head to the Granite 4.2 8B model page on DeepInfra to explore the API playground, review live request examples, and start building.

Conclusion

Granite 4.2 8B is a well-engineered 8B model with a few design decisions that actually matter in production. Per-query reasoning control is a meaningful operational lever for teams running mixed workloads where latency and cost vary by task type.

Apache 2.0 licensing, a 128K native context window, and reasoning-augmented tool calling make it a credible foundation for agentic pipelines.

If you are building coding assistants, multi-step reasoning agents, or enterprise workflow automation, it is a compact, auditable option.

It does not require over-provisioning just to get coherent tool use.

Run your first call in the playground, or drop Granite 4.2 8B into an existing OpenAI-compatible integration.