IBM has released Granite 4.2, a family of three open-source reasoning models designed to teach AI systems how to use tools and take actions in the real world. The models, available in 3 billion, 8 billion, and 30 billion parameter sizes, represent a shift in how companies are training large language models (LLMs), which are AI systems trained on vast amounts of text data. Rather than simply answering questions, these models can now write code, run terminal commands, and search the web inside sandboxed environments.

What Makes Granite 4.2 Different From Earlier AI Models?

Granite 4.2 is IBM's reasoning-focused follow-up to earlier Granite models that were built primarily as conversational assistants. The new generation adds an explicit reasoning step, allowing every model to generate a chain of thought before answering questions. Users can run the models in three modes: a full thinking mode that spends more computational effort on reasoning, a non-thinking mode for straightforward answers, or a low-effort thinking mode that uses less reasoning power on easy questions.

The clearest capability split appears after supervised fine-tuning, which is a training process where models learn from human-labeled examples. The 8 billion and 30 billion parameter models go through an additional agentic reinforcement learning stage that teaches them to call tools, edit and run code, drive a terminal, and search the web. The 3 billion model completes foundational reinforcement learning and alignment training but skips that agentic block.

How Does IBM's Training Pipeline Actually Work?

All three Granite 4.2 models follow the same overall training recipe, just at different scales. Each model is trained from scratch on approximately 15 trillion tokens, which is roughly equivalent to reading 10 million books. The training happens in five phases: two phases handle foundational pre-training, two phases run mid-training with progressively higher-quality data, and a final phase extends the context window to 512,000 tokens. A context window is the amount of text a model can process at once; 512,000 tokens roughly equals 400,000 words, allowing the model to work with very long documents.

After pre-training, IBM applied supervised fine-tuning using roughly 7.2 million samples covering about 100 billion tokens. The training data split between two types: agentic data focused on tool use and action-taking (31.6% of the mix) and non-agentic data covering general instruction-following, coding, math, and safety (68.4%). The agentic data leans heavily on software engineering trajectories, with the rest split across tool calling, terminal use, math, search, and general action tasks.

Steps to Understanding Granite 4.2's Multi-Stage Reinforcement Learning Approach

• Supervised Fine-Tuning Foundation: Models first learn from human-labeled examples combining agentic and non-agentic data, establishing baseline capabilities for reasoning and tool use.
• RLVR Stage: The models undergo reinforcement learning with verifiable rewards (RLVR), a technique that trains them using feedback from actual task outcomes rather than human judgments alone.
• Agentic RL for Larger Models: The 8 billion and 30 billion parameter models receive additional agentic reinforcement learning that teaches them to operate as coding, terminal, and web-search agents inside real sandboxed environments.

Before training began, IBM applied several quality-control passes to ensure data reliability. The team normalized data into a consistent chat format, used other AI models as judges to filter low-quality or hallucinated samples, removed invalid tool calls, and deduplicating the corpus with SHA-256 hashing, a technique that identifies and removes duplicate entries.

Why Does This Training Approach Matter for AI Development?

The multi-stage reinforcement learning pipeline represents a meaningful shift in how companies approach AI training. Rather than one single reinforcement learning pass, Granite 4.2 runs a chain of separate, focused reinforcement learning stages, each building on the previous stage's checkpoint. This approach allows IBM to progressively teach the models more complex behaviors, starting with basic alignment and moving toward real-world tool use in sandboxed environments.

The 30 billion model receives an additional second supervised fine-tuning phase focused specifically on agentic coding data, reflecting IBM's emphasis on making larger models particularly capable at software engineering tasks. All three models use the same dense, decoder-only transformer architecture with grouped query attention, a technique that reduces computational requirements while maintaining performance.

IBM released all Granite 4.2 models under the Apache 2.0 license, making them freely available for commercial and research use. The company also published quantized variants in FP8, NVFP4, MXFP4, and GGUF formats, which are compressed versions that reduce memory requirements and make the models easier to deploy on consumer hardware or smaller servers. These variants work with popular deployment tools like vLLM and llama.cpp.

The release of Granite 4.2 signals that open-source AI development is moving beyond pure language understanding toward practical tool use and agentic capabilities. By training models to operate in real sandboxed environments rather than just predicting text, IBM is addressing a key limitation of earlier AI systems: the gap between language understanding and real-world action-taking.