Ministral 3 3B: A Vision Model Small Enough for the Edge
Models

Ministral 3 3B: A Vision Model Small Enough for the Edge

Mistral's smallest Ministral 3 model reads images, calls tools and fits in 8GB of VRAM. What it is good for, where 3B runs out, and when to step up to 8B.

The usual mistake with a 3B model is to judge it as a cheap chatbot. Put Ministral 3 3B in a chat window next to a frontier model and it will look weak, because it is. That is the wrong test. A model this size earns its place on narrow, repetitive jobs where latency, hardware and cost per call matter more than breadth.

Mistral released it on 2 December 2025 as the smallest member of the Ministral 3 family, alongside 8B and 14B siblings and the much larger Mistral Large 3. All of them ship under Apache 2.0.

What you actually get in 3B

The model card describes a 3.4B-parameter language model paired with a 0.4B vision encoder, so roughly 4B parameters in total. It is a dense model: every parameter runs on every token, which keeps serving simple.

The practical specifications, from Mistral's own documentation:

  • Context window — 256K tokens on Mistral's API and in the published weights. Some aggregators expose a smaller window, so check the provider you actually call.
  • Inputs — text and images, text out.
  • Capabilities — native function calling, structured outputs and JSON mode.
  • Languages — the card claims dozens and names eleven, including English, French, German, Spanish, Chinese, Japanese, Korean and Arabic.
  • Licence — Apache 2.0, so you can fine-tune, redistribute and ship it commercially without a separate agreement.

The family was built with what Mistral's January 2026 paper calls cascade distillation: repeatedly pruning a larger model and continuing training with distillation. Each size comes in base, instruct and reasoning variants, all with image understanding.

The jobs it is built for

Mistral's model card names the target directly: edge and low-resource devices, embedded systems and real-time applications. The example tasks are image captioning, text classification, real-time translation, data extraction and short content generation.

Those are all tasks with a fixed output shape. A ticket router that picks one of twelve labels, a receipt reader that fills a schema, a moderation pre-filter, a translator for short UI strings. None of them reward deep reasoning, and all of them run thousands of times a day, so the per-call saving compounds.

The vision encoder is what makes it unusual at this size. Reading a photographed label or a screenshot locally, without sending the image to a hosted API, is a real capability for kiosks, field devices and privacy-sensitive pipelines. LLM data extraction covers how to design the schema first, which matters more at 3B than at any other size.

Where 3B runs out

Mistral publishes instruct-model scores for all three sizes, and the gap is not subtle. On Arena Hard the 3B scores 0.305 against 0.509 for the 8B and 0.551 for the 14B. On WildBench it is 56.8 against 66.8 and 68.5. Those are open-ended chat and instruction-following tests, which is exactly where a small model struggles.

On maths the gap narrows: MATH Maj@1 is 0.830 for the 3B, 0.876 for the 8B. That pattern is typical. Small models hold up on well-defined problems and fall away on ambiguous, multi-step requests.

Three practical limits follow:

  • Long context is nominal. A 256K window does not mean a 3B model reasons well across 200K tokens. Feed it the relevant chunk, not the whole document. Context length vs effective context explains why the advertised figure overstates what you can use.
  • Tool sets must stay small. The model card itself advises limiting tools to the minimum the use case needs. Ten tools with overlapping descriptions is a recipe for wrong calls.
  • Open-ended writing is weak. Short generation is fine. Anything that needs judgement over several paragraphs belongs on a larger model.

Instruct or reasoning variant

The reasoning variant posts strong numbers for its size: 0.721 on AIME 2025, 0.534 on GPQA Diamond and 0.548 on LiveCodeBench, all vendor-reported. That makes it tempting for maths and code checks on a device.

The cost is output length. A reasoning model spends tokens thinking before it answers, and on a small device that is wall-clock time a user waits through. For classification and extraction, use the instruct variant. Reach for reasoning only when the task genuinely needs multi-step working and you can tolerate the latency.

Running it locally

The model card says the FP8 weights fit in 8GB of VRAM, less if you quantise further. That puts it on consumer GPUs, recent laptops and NVIDIA's Jetson boards, which Mistral's launch post names among the platforms NVIDIA optimised it for.

Two settings matter more than usual. Mistral recommends a temperature below 0.1 for production, starting around 0.1; small models drift quickly at higher temperatures. And in vLLM, the model card marks --enable-auto-tool-choice and --tool-call-parser mistral as required for tool use, alongside Mistral's own tokenizer, config and load formats.

vllm serve mistralai/Ministral-3-3B-Instruct-2512 --tokenizer_mode mistral --config_format mistral --load_format mistral --enable-auto-tool-choice --tool-call-parser mistral

If you would rather not host it, it is listed on OpenRouter at $0.10 per million tokens for both input and output at the time of writing, matching Mistral's own API rate, though with a 131,072-token window rather than the full 256K. The catalogue entry is a dated snapshot, 2512, which is what you want for a component that should not change underneath you.

A decision rule: 3B, 8B or 14B

  • Pick 3B when the output is a label, a short string or a filled schema, when the hardware is constrained, or when you call it so often that latency dominates.
  • Pick 8B when users will chat with it, when the instructions are long, or when you saw the 3B misread the task in testing. The Ministral 3 8B guide covers that trade.
  • Pick 14B when you need the strongest small Mistral model and have the memory for it; see the Ministral 3 14B guide.

The test is cheap. Take two hundred real inputs, label the correct outputs yourself, and run them through the 3B and the 8B at the recommended temperature. If the 3B's error rate is acceptable, you have saved memory and latency on every call from now on. If it is not, the 8B is a one-line change.

Common questions

How much memory does Ministral 3 3B need?

Mistral's model card says the FP8 weights fit in 8GB of VRAM, and less with further quantisation. That makes it runnable on consumer GPUs, recent laptops and edge boards such as NVIDIA Jetson.

Can Ministral 3 3B be used commercially?

Yes. It is released under Apache 2.0, which allows commercial use, fine-tuning and redistribution without a separate licence from Mistral.

Is Ministral 3 3B good enough for a chatbot?

For simple, scoped assistants it can work, but Mistral's own scores show a large gap to the 8B on open-ended chat benchmarks such as Arena Hard and WildBench. If users will hold free-form conversations, start with the 8B.

Similar articles

Ministral 3 14B Guide: A Local Model That Sees and Calls Tools
Models
Models·7 min read

Ministral 3 14B Guide: A Local Model That Sees and Calls Tools

Ministral 3 14B is an Apache 2.0 dense model with vision, a 256K window and FP8 weights that fit in about 24GB. When it beats Mistral Small, and when to drop to the 8B.

Read
Ministral 3 8B: The Small Mistral Model to Start With
Models
Models·8 min read

Ministral 3 8B: The Small Mistral Model to Start With

Ministral 3 8B reads images, calls tools, runs in about 12GB of VRAM and costs the same per token for input and output. Where it fits between the 3B and 14B.

Read
Llama 3.2 1B Instruct: What a One-Billion Model Is Actually For
Models
Models·8 min read

Llama 3.2 1B Instruct: What a One-Billion Model Is Actually For

Llama 3.2 1B was pruned and distilled from Llama 3.1 8B to run on phones. What it can do, what it cannot, and why calling it over an API is usually the wrong test.

Read