Granite-4.2-30B

Granite-4.2-30B

Works through a problem in steps before it answers, for math, code, tool calling and multilingual chat. IBM's largest dense Granite 4.2 model, under Apache 2.0, for teams that run open models on their own hardware.

Made by ibm-granite on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Granite-4.2-30B is IBM's largest reasoning model in the Granite 4.2 line, a dense text model with about 30B parameters. It writes out its reasoning steps before it gives a final answer. That helps with math, code and multi-step tasks that call tools.

Who it suits: It suits developers and teams who want an open reasoning model for code, tool calling, agent workflows and multilingual chat. The license allows commercial use.

Title: Who runs it
Industry | Who uses it | How they use it | Example
Software | Application developers | Generate and review code with a reasoning pass | A coding assistant inside an internal tool
Enterprise IT | Platform teams | Host an open model on their own hardware | A private chat service for staff
AI engineering | Agent builders | Let the model decide which tool to call and why | A workflow that picks among several functions
Research | Model researchers | Compare thinking modes inside a single model | Full thinking against low effort

If you only have a laptop or a small GPU, you can skip it. Even the 4-bit estimate is about 14.6 GB.

Where to use it:

• The transformers library, the one listed for this model
• Windows, macOS or Linux with Python, for downloading the files
• Your own server or workstation with enough memory for the weights
• Agent and tool-calling setups, which the card names as a target use

Title: Jobs it does
Use case | Who | What they get back
Hard reasoning questions | Developers | An answer after the model works through the steps
Code generation | Software teams | Code written after a reasoning pass
Tool calling | Agent builders | Function calls chosen with reasons
Multilingual dialog | Support teams | Replies in the languages the card tested

How to set it up:

• Python on Windows, macOS or Linux
• Memory for about 58.6 GB of BF16 weights, or about 14.6 GB at 4-bit as an estimate
• The Hugging Face tools below, to fetch the files

1. Install the Hugging Face Hub tools.
2. Download the model files.
3. Load the model with the transformers library, following the model card.

pip install -U huggingface_hub
hf download ibm-granite/granite-4.2-30b

How to use it: You choose how much the model thinks for each request. Full thinking is the default, and you can switch to a mode with no thinking or one with low effort. That trades depth against speed. The visible card text shows no run command.

Title: Thinking modes
Tool | What it does
Full thinking | The default mode, which reasons at length before answering
Non-thinking | Skips the reasoning pass for a quicker reply
Low effort | Reasons briefly to save time

hf download ibm-granite/granite-4.2-30b

Example: You ask a multi-step math word problem in full thinking mode. The model writes out its reasoning and then gives a final answer. With low effort, the same question gets a shorter reasoning pass. The card shows no sample reply.

For newcomers and experts: If you are new, this is a large text AI that works a problem through in steps before it replies. The first small thing to try is reading the model summary and checking that your computer has room for the files.

If you know the field, it is a decoder-only dense transformer built on Granite-4.1-30B-Base. Attention is grouped query with 32 heads and 8 key-value heads, with rotary position embeddings and SwiGLU feed-forward layers. The trade-off is time: each reasoning pass costs speed, which the modes let you control.

Send a request in one thinking mode
The model reasons through the steps
It can pick a tool and say why
The final answer comes back

Good to know:

Title: Weight size in gigabytes
BF16: 58.6 GB
4-bit (estimate): 14.6 GB

• Context: it supports 128K tokens natively, and an extension for long input reaches 512K.
• Languages: tested on English, Chinese, Japanese, Korean, Arabic and several European languages. Others may work but are not fully tested.
• Variants: other people have published 42 quantized and 14 fine-tuned versions.
• License: apache-2.0.
• Cost to run: no API key, account or paid service is named, but you need a large GPU or a lot of memory.
• Data it reaches: you download files from Hugging Face, and the model reaches only what your own program gives it.
• Not for: small machines that cannot hold the weights.

On Hugging Face, 13 November 2026

• Task: text generation
• Library: transformers
• Parameters: 29.3B
• Weights: about 58.6 GB in BF16; about 14.6 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 36,287
• Likes: 143
• License: apache-2.0
• Languages: en, de, es, fr, ja, pt, ar, cs
• Based on: ibm-granite/granite-4.1-30b-base
• Quantized versions: 43
• Fine-tunes: 14
• Tags: transformers, safetensors, granite, text-generation, granite-4.2, reasoning, thinking, tool-calling, conversational

Links

• Model: https://huggingface.co/ibm-granite/granite-4.2-30b
• Files: https://huggingface.co/ibm-granite/granite-4.2-30b/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download ibm-granite/granite-4.2-30b

Then follow the usage in its model card. Nothing in this kit runs by itself.