Granite-4.2-8B

Granite-4.2-8B

Reasons step by step, writes code, calls tools and chats in several languages with a context of up to 128K tokens, extendable to 512K. IBM's dense 8B model, for developers building agents and assistants.

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-8B is a reasoning model from the Granite team at IBM, a dense decoder-only transformer with about 8 billion parameters. It builds on Granite-4.1-8B-Base and thinks through a problem step by step before it answers. The card lists reasoning, code generation, tool calling, agentic workflows and multilingual dialog as its best uses.

Who it suits: Developers and teams who want an open reasoning model for assistants, coding help and agents that call tools. The weights carry the Apache 2.0 license.

Industry | Who uses it | How they use it | Example
Software | Developers | Use the reasoning mode for code generation and debugging | Asking it to explain and fix a failing function
AI platforms | Agent builders | Run agents whose tool calls come with reasoning | An assistant that picks a tool and says why
Customer service | Product teams | Build multilingual dialog systems | A chat assistant that switches between English and Japanese

Anyone who needs only quick short replies can skip the reasoning cost, since the card also offers a non-thinking mode for that.

Where to use it:

• Python with the transformers library, the one Hugging Face lists
• Long-document and multi-turn setups, thanks to the context window
• Windows, macOS or Linux with Python, for downloading the files

Use case | Who | What they get back
Reasoning tasks | Developers | Step-by-step answers to math, coding and logic problems
Tool calling | Agent builders | Function calls chosen after reasoning about which tool to use
Long documents | Analysts | Answers over inputs of up to 128K tokens, extendable to 512K

How to set it up:

• Python and the huggingface_hub package
• The transformers library to load the model
• Room for the weights, about 17.6 GB in BF16, or about 4.4 GB at 4-bit as an estimate

1. Install Python if you do not have it yet.
2. Install the huggingface_hub package with the first command below.
3. Download the model files with the second command.
4. Load the model with the transformers library, following the model page.

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

How to use it: Once the files are on your computer, you load the model and send it chat messages. The card describes three thinking modes you can pick per query. Full thinking is the default, with non-thinking and low-effort modes for lower latency. Hugging Face points to the model page for the exact run steps.

Example: You give the model a multi-step math word problem with full thinking on. The card says it works through built-in chain-of-thought reasoning before it gives its final answer.

For newcomers and experts: A reasoning model writes out its thinking before it answers, which can make answers on hard problems better and slower. A good first step is to download the files and read the model page to see how to switch the thinking mode.

The design is a dense decoder-only transformer with grouped query attention, 32 attention heads and 8 key-value heads, rotary position embeddings, SwiGLU feed-forward layers and RMSNorm. Input and output embeddings are separate, and precision is bfloat16. Native context is 128K tokens, with a long-context extension to 512K.

Download the files with hf
Load the model with transformers
Send chat messages
Pick a thinking mode
Get reasoning and an answer

Good to know:

• License: Apache 2.0
• Cost to run: none named
• Data it reaches: the download fetches files from Hugging Face, and the source names nothing else
• Tested languages: twelve, including English, Japanese, Arabic and Chinese, and the card says others may work but are not fully tested
• Hugging Face lists 8.8B parameters, while the card's table says 8B

Title: Context length in thousands of tokens
Native context: 128 K
With long-context extension: 512 K

On Hugging Face, 13 November 2026

• Task: text generation
• Library: transformers
• Parameters: 8.8B
• Weights: about 17.6 GB in BF16; about 4.4 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 61,674
• Likes: 120
• License: apache-2.0
• Languages: en, de, es, fr, ja, pt, ar, cs
• Based on: ibm-granite/granite-4.1-8b-base
• Quantized versions: 64
• Fine-tunes: 19
• Tags: transformers, safetensors, granite, text-generation, granite-4.2, reasoning, thinking, tool-calling, conversational

Links

• Model: https://huggingface.co/ibm-granite/granite-4.2-8b
• Files: https://huggingface.co/ibm-granite/granite-4.2-8b/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-8b

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