Granite 4.2: What It Changes?

TL;DR

• Granite 4.2 is IBM's 3B, 8B, and 30B open-weight family under Apache 2.0, per IBM Research.

• Only the 8B and 30B sizes got extra "agentic RL" training on software engineering, terminal, and search tasks. The 3B supports tools without that specialized phase. Weight files are on Hugging Face, Ollama, and watsonx; GitHub carries the project repo.

• This is a model family a buyer still has to wire into a harness — not a finished back-office product and not a law-firm suite. IBM's SWE-bench and AIME figures are vendor-reported.

• A 10-person firm or an SMB that cannot send client files to a hosted chat product should care because Apache 2.0 weights can sit on a machine they control. The work is still: pick one bounded job (intake summary, clause extract, search), add tools, keep a human reviewer.

Key Takeaways

• Three dense sizes, decoder-only, native 128K context (131,072 tokens) with long-context extension described up to 512K. Ars Technica independently confirmed the three sizes, 128K native window, decoder-only design, and agentic RL on 8B and 30B only.

• The Decoder independently confirmed Apache 2.0 and the thinking / non-thinking toggle. IBM also describes a low-effort thinking mode.

• Benchmarks (SWE-bench Verified 47.67 / 57.00 on 8B / 30B, AIME25 78.33 / 86.67 / 89.17) are IBM-published. Treat them as vendor scores.

• Speech models in the same day's release (Granite Speech 5.0 Turbo CTC, 470 million parameters) are a separate family. Do not confuse them with the 3B/8B/30B language checkpoints.

The answer in plain English

Granite 4.2 is IBM's downloadable 3B, 8B, and 30B reasoning family under Apache 2.0. As of August 25, 2026 the weights are public, per IBM Research. It is not Clio, not Harvey, and not a matter-management product. The industry tag on this page is legal because many of the buyers who need on-site models are firms and legal-ops teams that cannot ship client files to a hosted chatbot — the same constraint a clinic or an agency with a data-residency clause has.

A two-truck HVAC shop will not train a 30B model. A 10-person firm that already stores engagement letters and discovery exports on a local share might run the 8B checkpoint on a workstation or a small GPU box and point one agent at it: "summarize this intake PDF," "list the dates in this file," "draft a first-pass clause table." That is a model swap inside a harness, not a new practice of law. A shop already comparing DocuSign versus PandaDoc is deciding where signed files live. Granite 4.2 does not replace that. It can sit behind a step that reads those files without sending them to a third-party API.

Teams already routing document intake through US Tech Automations can treat Granite 4.2 as the model behind one step — extract, classify, or draft — with the same human review they use today. The weights do not file anything.

Who should use this page

This page is for an ops lead, IT owner, or counsel who has been told "just use ChatGPT" and cannot, and who is weighing a local open-weight model for a bounded document job.

Red flags: open weights are not a finished agent. You still need serving (vLLM, Ollama, watsonx), tools, logging, and a stop button. IBM's benchmarks are IBM's. Do not buy the 3B expecting SWE-bench scores.

The family, by the numbers

Native context is 128K on the model cards; IBM's Hugging Face technical blog also describes a 512K long-context extension from the Granite 4.1 pre-train recipe. Ars reported the native 128K window.

Sources: IBM Research; Hugging Face 8B card; Ollama granite4.2; Ars Technica.

According to IBM Research, Granite 4.2 ships in 3B, 8B, and 30B parameter sizes under an Apache 2.0 license, with a thinking mode for step-by-step reasoning and weights on Hugging Face, Ollama, and watsonx.

According to Ars Technica, the models are decoder-only with a native 128,000-token context window, and only the 8B and 30B variants go through an agentic reinforcement-learning block for terminal, web search, and external tools.

How thinking mode and agentic RL work

Every size can emit a … chain of thought, skip thinking entirely, or run a low-effort pass. According to Ollama's granite4.2 page, the library listing had 24.3K downloads at fetch, with a 128K context window on the 3b (2.2 GB), 8b (5.3 GB), and 30b (18 GB) tags.

According to IBM's Hugging Face technical blog, the family was pre-trained from scratch on roughly 15 trillion tokens, with SFT on about 7.2 million samples, and the 8B and 30B models go through an agentic RL block while the 3B model takes a shortened path without that block.

The 8B model card publishes vendor-reported scores of SWE-bench Verified 47.67 (8B) and 57.00 (30B); Terminal-Bench 2.1 20.56 / 29.24; and AIME25 78.33 / 86.67 / 89.17 across 3B / 8B / 30B. On that card the 3B rows for SWE-bench are marked NA.

According to The Decoder, Speech 5.0 Turbo CTC models have 470 million parameters and IBM says they can transcribe three hours of audio in one second; the same piece independently confirmed the 3B / 8B / 30B split, Apache 2.0, and the thinking toggle.

Why now: the constraint that broke

Hosted frontier models bill by the token and send data off-site. IBM Research positions Granite 4.2 for cloud, on-premises, and edge deployment, and says organizations can download, fine-tune, and put it into production without licensing restrictions under Apache 2.0.

The Apache License 2.0 text, approved in 2004, grants a royalty-free copyright and patent license to reproduce, prepare derivative works, and distribute the licensed work, subject to the conditions in that document.

The GitHub repo is licensed Apache 2.0 and points to Hugging Face for the Granite 4.2 language-model weight files.

The Hugging Face collection lists the 3B, 8B, and 30B cards.

The 8B card showed 10,380 downloads last month — snapshot traffic, not production proof.

IBM also published CodeAlchemy: nearly 1 trillion tokens of synthetic code across 15 languages, with 1.3 million code-and-trace pairs.

According to the Granite 4.2 IBM Research post, the models were trained on 1 trillion tokens of synthetic code generated using that CodeAlchemy pipeline.

arXiv:2606.10087 is the CodeAlchemy paper. That is training-data provenance, not a reason to skip evaluation on your own documents.

Granite 4.1's April 29, 2026 blog describes the prior dense generation: roughly 15 trillion tokens of pre-training, a 512K long-context extension, and about 4.1 million SFT samples for that 4.1 instruct recipe. Those figures describe Granite 4.1 on that page.

USTA analysis: two of three sizes get agentic RL

Working only from IBM and Ars: 3 dense sizes, agentic RL on 2 of them (8B and 30B). That is 2 of 3 sizes. Inputs: the size list and the "8B and 30B only" agentic-RL statement in IBM Research and Ars Technica. Use that split when you pick a checkpoint: if the job needs the agentic-RL block those pages describe, start with 8B or 30B; the 3B is the size those pages do not put through that block.

Sources: IBM Research; Hugging Face Granite 4.2 blog; Ars Technica.

What this does not establish

It does not establish that a law firm can replace its DMS or its e-billing stack. It does not establish HIPAA or professional-conduct compliance; those are the buyer's policies plus whatever they wrap around the weights. It does not establish that 128K context means faithful retrieval across a whole matter file. Test with a known-answer set.

A team already choosing Zapier versus Make is wiring steps around a model, not buying a model as a product. That is the right instinct. Teams that already have US Tech Automations extracting fields from PDFs can point that extract step at a local Granite 4.2 endpoint instead of a hosted API — same schema, same reviewer, different box.

IBM's Granite docs hub and ibm.com/granite are the first-party product pages.

Serving recipes for vLLM, SGLang, OpenCode, Pi, and OpenHands live on the 8B card.

watsonx is listed as a hosted path if you do not want to run GPUs yourself — that path is not "air-gapped local."

A buyer's evaluation sequence

The 8B model card says previous-turn thinking is stripped by default (truncate_history_thinking=True) so old chains of thought do not eat the native 128K window; set that flag false to keep full reasoning history.

Speech models are a same-day side release

Granite Speech 5.0 Turbo CTC is a same-day side release: 470 million-parameter English ASR models at over 12,600 RTFx on an H200, with the Apache 2.0 variant at 5.00% WER on public OpenASR short-form sets and a non-commercial twin under CC-BY-NC-SA-4.0.

The CC-BY-NC-SA-4.0 deed is the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International license text.

The 8B model card states that Granite-4.2-8B is post-trained from Granite-4.1-8B-Base.

SGLang's Granite 4.2 cookbook is a serving cookbook for that family.

The Open Source Initiative Apache-2.0 page is the OSI listing of that license.

A week-one test is a known-answer pack on the 8B checkpoint with thinking off, then on. Keep the original file next to the draft. If the extract misses a date your staff always catches, do not widen the tool list.

The Apache 2.0 speech checkpoint is granite-speech-5.0-470m-turboctc.

The non-commercial twin is granite-speech-5.0-470m-turboctc-nc.

IBM's streaming WebGPU demo is a browser check, not a production ASR contract.

The 8B language card recommends using Granite 4.2 alongside Granite Guardian to detect and flag risks — a detector, not a replacement for a human reviewer on client files.

IBM Granite community resources live on that GitHub org. The PRISM mid-training paper is listed on Hugging Face Papers. Those pages are for people reading community code and a mid-training paper, not a first-office how-to.

A first office pilot is a small known-answer pack, one tool, one reviewer, and a written stop rule if the draft disagrees with the source PDF. Time the run with thinking off and thinking on. If thinking adds latency and does not cut misses on that pack, leave it off for that job. Do not add a second tool until the first one is boring. Write the miss list and stop if it grows.

Signal vs Speculation

Demonstrated signal: as of August 25, 2026, IBM released Granite 4.2 in 3B, 8B, and 30B under Apache 2.0, with thinking modes, native 128K context, agentic RL on 8B and 30B only, and public weights on Hugging Face, Ollama, and watsonx. Ars Technica and The Decoder independently confirmed the size split, license, toggle, and (Ars) the 128K native window. IBM published SWE-bench and AIME tables; those remain vendor-reported. Speech 5.0 Turbo CTC is a same-day side release at 470 million parameters.

Our read: over 6–12 months, expect more firms with a residency constraint to trial an 8B local checkpoint on one intake or search job, not to rip out their hosted chat. The constraint that broke is "open weights used to mean no tools." Granite 4.2 still needs a harness. Some teams may later put a speech model in front of a language checkpoint for transcript-then-extract; that is two models and two failure modes, not a recipe the speech blog publishes.

Our read: over 24–36 months, if local 8B–30B agents become good enough at document tools, the buying decision splits: hosted frontier for hard reasoning, local Granite-class models for files that cannot leave the building. Empty pages and unreviewed sends still do not count as a deployment.

Frequently asked questions

What is Granite 4.2?

It is IBM's August 25, 2026 family of dense open-weight language models in 3B, 8B, and 30B sizes, with a thinking switch, Apache 2.0 licensing, and extra agent training on the 8B and 30B.

Is this a law-firm product?

No. It is a model family. A firm can run it on-site for document workflows; IBM does not ship a matter system.

Which size should a small team try first?

The 8B if the job needs tools and the hardware can hold it.

Ollama's granite4.2 page lists 5.3 GB for the default 8b tag.

The 3B is smaller. Ars Technica says only the 8B and 30B variants go through the agentic RL block.

What is the context window?

Native 128K tokens (131,072) on the 8B model card, which also notes long-context extension to 512K.

Ars Technica independently reported the native 128,000-token window.

Are the SWE-bench numbers independent?

No. They are IBM-published on the technical blog and 8B card.

Where do I download it?

Hugging Face collection, Ollama, GitHub, and watsonx, per IBM.

Does Apache 2.0 mean I can use it commercially?

IBM Research says organizations can download, fine-tune, and put it into production without licensing restrictions.

Read the Apache 2.0 text and your own counsel's view of the patent-termination and NOTICE conditions.

How should a team plug the weights into an existing workflow?

As a model swap on a bounded extract or draft step they already run, with the same reviewer. The harness and the human gate stay yours; IBM supplies the weights.

If you already route document intake, clause extraction, or search through automated steps, see how US Tech Automations can point that step at a local Granite 4.2 endpoint instead of a hosted chat product.