Granite 4.0 Micro
Granite 4.0 Micro is a 3B-parameter dense language model from IBM’s Granite 4.0 family, optimized for low-latency, cost-efficient workloads and local or edge deployment.
What is Granite 4.0 Micro?
Granite 4.0 Micro is a compact, 3B-parameter transformer-based language model in IBM’s Granite 4.0 series, designed as a dense alternative to the hybrid Mamba-2/transformer variants. It is mainly used for lightweight conversational assistants, instruction following, and general-purpose text generation in resource-constrained environments. It is also suited for agentic workflows, including fast function-calling and serving as the text backbone for add-on capabilities like Granite 4.0 3B Vision. As part of the broader IBM Granite family of foundation models, Granite 4.0 Micro follows earlier Granite generations (such as Granite 3.x) while emphasizing open, enterprise-ready deployment.
Providers
Different companies host the same model. OpenRouter routes your request to one of them based on the routing mode you pick — Balanced (price + speed), Nitro (fastest), or Exacto (highest tool-calling accuracy).
| Provider | Input | Output | Cache read /M | Latency | Throughput | Uptime |
|---|---|---|---|---|---|---|
| IBM watsonx | ~$0.30 | ~$0.30 | — | ~220ms | ~40 tps | 99.9% |
| AWS Bedrock | ~$0.25 | ~$0.25 | — | ~190ms | ~55 tps | 100.00% |
| Azure AI Studio | ~$0.28 | ~$0.28 | — | ~200ms | ~50 tps | 99.9% |
Try this model
Test Granite 4.0 Micro right here — free to start.
Suggestions for your first prompt
Code snippet
Call the model through the OpenAI-compatible API.
from openai import OpenAI
client = OpenAI(
api_key="YOUR_API_KEY",
base_url="https://inference.example.com/v1"
)
response = client.chat.completions.create(
model="ibm/granite-4-0-micro",
messages=[
{
"role": "user",
"content": "Describe this image in one sentence."
}
],
)
print(response.to_json())
{
"model": "ibm/granite-4-0-micro",
"messages": [
{
"role": "user",
"content": "Describe this image in one sentence."
}
]
}
5 Core Capabilities
-
Instruction Following
Executes general natural language instructions for diverse tasks, serving as a foundation for building AI assistants across business domains.
-
Tool Calling
Supports function and tool calling within agentic workflows, enabling integration with external APIs like weather or business systems.
-
Text Generation
Performs long-context text-to-text generation for drafting, summarization, and dialogue, using a compact 3B-parameter decoder-only architecture.
-
Multilingual Handling
Processes and generates text in multiple languages, suitable for globally deployed enterprise applications requiring multilingual communication capabilities.
-
Vision Adapter Support
Acts as the text backbone for a 3B Vision LoRA adapter, enabling multimodal document and structured data understanding when combined.
6 Most Valuable Use Cases
- Lightweight Chatbots
- Fast Text Summaries
- Support Ticket Triage
- Simple Log Classification
- On-device Assistants
- Tool-calling Orchestration
Why Build on LLM.API?
One unified API. Every major model. Built-in reliability, cost control, and observability.
-
Unified AI Routing
Dynamically route each request to the optimal model across providers based on latency, price, and quality—without changing your integration or redeploying.
One endpoint, any model -
Cost-Aware Control
Enforce budgets, price caps, and per-team limits while automatically selecting cheaper equivalents when possible, so you avoid surprise bills as usage scales.
Predictable AI spend -
Resilient Fallbacks
Define provider- and model-level fallbacks that auto-trigger on errors, timeouts, or degraded quality, keeping your AI flows reliable in production.
No single point of failure -
Deep Observability
Get per-request traces, latency, cost, and provider breakdowns in one place, so you can debug failures fast and tune prompts across models.
See every token -
Task-Native Workflows
Express higher-level tasks like chat, tools, RAG, and workflows via one consistent API, while LLM.API orchestrates the best models under the hood.
Tasks, not glue code -
High-Volume Batching
Submit large batches of requests across providers with automatic concurrency control and retry semantics, maximizing throughput without overwhelming your infrastructure.
Scale to millions
When to Use — When NOT to Use
Use it if...
- You need a very small, efficient model for on-device or edge deployment.
- You need low-cost inference for straightforward classification, routing, or short-form generation.
- Your use case involves simple chatbots handling FAQs or tightly scoped support workflows.
- Your use case involves lightweight code helpers, snippets, or boilerplate generation with modest complexity.
- You need a controllable model for deterministic, template-like outputs in backend services.
- Your use case involves fine-tuning a compact model on proprietary domain data.
Avoid if...
- You need state-of-the-art reasoning for complex problem solving or multi-step planning.
- You need high-quality long-form writing, narrative coherence, or sophisticated stylistic control.
- Your workload requires handling very long contexts, large documents, or extended conversations.
- You need advanced code synthesis, debugging, or architecture design across large repositories.
- Your workload requires top-tier multilingual performance, nuanced translation, or cross-lingual reasoning.
- You need strong safety tooling, ecosystem integrations, and capabilities rivaling frontier general-purpose models.
Frequently Asked Questions
-
What is Granite 4.0 Micro?
Granite 4.0 Micro is an IBM small-footprint language model optimized for fast, low-cost text generation and assistant-style tasks.
-
What is Granite 4.0 Micro best suited for?
It is best for lightweight chatbots, classification, short-form content generation, and on-demand reasoning where low latency and cost are priorities.
-
How is Granite 4.0 Micro priced on LLM.API?
LLM.API charges per input and output token, with Granite 4.0 Micro positioned as a budget-friendly option compared to larger Granite variants.
-
What context window does Granite 4.0 Micro support?
Granite 4.0 Micro supports a mid-sized context window suitable for typical chat sessions and short documents, but not long reports or multi-document analysis.
-
How fast is Granite 4.0 Micro in terms of latency?
Because of its compact size, Granite 4.0 Micro generally offers lower latency and faster first-token times than larger Granite 4.0 family models.
-
What modalities does Granite 4.0 Micro support?
Granite 4.0 Micro is a text-only model, supporting text prompts and returning text completions or chat responses.
-
How do I call Granite 4.0 Micro via LLM.API?
You select the IBM provider and the Granite 4.0 Micro model name in your LLM.API request, then send standard chat or completion payloads.
-
How does Granite 4.0 Micro compare to larger Granite models?
It trades some reasoning depth and output richness for lower cost and latency, making it better for high-traffic or resource-constrained applications.
-
What are the main limitations of Granite 4.0 Micro?
It may struggle with very long contexts, complex multi-step reasoning, and highly specialized domain knowledge compared to larger frontier models.
-
Does Granite 4.0 Micro support function calling or tool use via LLM.API?
If enabled by LLM.API, you can use its standard function-calling interface with Granite 4.0 Micro for structured tool invocation.
COMPARE
Competitive Models
-
Kimi K2.5
Kimi K2.5 is MoonshotAI’s flagship open-source multimodal Mixture-of-Experts model with native vision and strong agentic capabilities, designed for long-context reasoning and complex tool use.
-
GLM 4.6V
GLM 4.6V is Z.ai’s open-source, large-scale vision-language model that supports images, video, documents, and text with a long context window and native tool use. It is notable for combining high-quality multimodal understanding with function calling and cloud- or local-friendly variants.
-
Qwen3.5-9B
Qwen3.5-9B is a 9‑billion‑parameter multimodal language model from Qwen that supports long-context reasoning over text and images. It is designed to offer strong reasoning, coding, and visual understanding capabilities in a relatively compact, efficient architecture.
Get one key to every model
Swap your API key. Keep your code.