MiniMax · Open-Weight Model
MiniMax M3: The Open-Weight 1M-Context Frontier Model
MiniMax M3 is an open-weight frontier model from MiniMax (Shanghai), released June 1, 2026 with weights published to Hugging Face in early June. It is a ~428B-parameter Mixture-of-Experts model (~23B active per token, per MiniMax's Hugging Face card) that combines three things that usually live in separate models: a 1M-token context window, native multimodal input (image + video), and a new MiniMax Sparse Attention (MSA) design that MiniMax says delivers more than 15x faster decode and more than 9x faster prefill at 1M context versus MiniMax M2. Verdict: it's the most capable model in this class you can actually download and self-host today — strong on agentic/coding tasks, with the headline benchmark numbers being MiniMax's own (not yet independently verified).
Can you run it locally? Only on big-memory hardware: a 4-bit build is about 257-265 GB and the smallest GGUF is 129 GB, and Ollama offers M3 only as a cloud tag. The local section has every download size and what holds it.
Open weight, not fully open source. The parameters are downloadable from Hugging Face, but commercial use of M3 or its derivatives requires a separate license agreement with MiniMax beyond the default MiniMax Community License. For other self-hostable frontier models, see DeepSeek V4 and Kimi K3.
Key takeaways
- →Open weight + frontier: ~428B MoE (~23B active), downloadable from Hugging Face, with a full 1M-token context.
- →MiniMax Sparse Attention: per-token compute ~1/20 of the prior generation; MiniMax reports >15x faster decode and >9x faster prefill at 1M context.
- →Natively multimodal: ingests image and video, and can operate a desktop computer for agentic tasks.
- →SWE-Bench Pro 59.0% — MiniMax's claim that it edges GPT-5.5 (58.6%) and beats Gemini 3.1 Pro (54.2%). Vendor-run; not independently confirmed.
- →Cheap API: $0.60/M in, $2.40/M out list, currently $0.30/$1.20 with MiniMax's permanent 50% discount — or run it yourself if you have 256-512 GB of memory.
Quick verdict
MiniMax M3 matters because of what it bundles into a model you can download. Until now, a 1M-token context, native video understanding, and frontier-tier agentic coding tended to be three different products — usually closed ones. M3 puts them in one ~428B MoE and ships the weights. If you want a self-hostable model for long-document analysis, computer-use agents, or multimodal pipelines, it's the standout pick of mid-2026.
The honest caveat: the headline benchmark numbers are MiniMax's own, run on their infrastructure with baselines they chose. At least one outlet flagged that the figures have not been independently verified — Scale AI, which maintains the official SWE-Bench Pro benchmark, has not confirmed them. Treat the "beats GPT-5.5 / Gemini 3.1 Pro" framing as a vendor claim until third parties replicate it. For privacy-first, local-first work, M3 is still a genuine step forward over its predecessor, DeepSeek V4, and Kimi K2.6 (now succeeded by Kimi K3) on multimodal + long-context throughput.
Specs at a glance
| Developer | MiniMax (Shanghai, China) |
| Release date | June 1, 2026 (weights on Hugging Face in early June; MSA technical report June 11) |
| Architecture | Mixture-of-Experts: 128 routed experts + 1 shared, 4 routed per token, 60 layers (config.json) |
| Total parameters | ~428B (427.0B in the safetensors) |
| Active per token | ~23B |
| Context window | 1M tokens (1,048,576 in config.json) |
| Attention | MiniMax Sparse Attention (MSA) |
| Modalities | Text · Image (input) · Video (input) · Computer use |
| License | MiniMax Community License — open weight; commercial use needs a separate agreement |
| Self-hostable? | Yes — weights on Hugging Face (854 GB BF16; 4-bit GGUF ~265 GB) |
| Ollama | minimax-m3:cloud only (runs remotely; no local tag) |
| Predecessor | MiniMax M2.7 (April 2026, 229B) |
| API price | $0.60/M in · $2.40/M out list; $0.30 / $1.20 with the permanent 50% discount |
MiniMax Sparse Attention (MSA): the real headline
Dense attention cost is what has historically made 1M-token context impractical to run locally — it scales badly as the context grows. MSA attacks that directly. A lightweight index branch scans incoming tokens and picks which blocks of past tokens actually need attention, then runs attention only on those blocks. The result, per MiniMax: at 1M-token context, per-token compute drops to roughly 1/20 of the previous generation.
| Stage | Speedup at 1M context vs MiniMax M2 | What it affects |
|---|---|---|
| Decode | >15x | Output generation — tokens/sec you feel during a response. |
| Prefill | >9x | Reading the prompt — time-to-first-token on long inputs. |
| Per-token compute | ~1/20 | Overall cost-to-run at full 1M context. |
In practical terms, MSA is what makes a 1M-context model viable to actually serve. The figures are MiniMax's, from its launch post and model card. The technical report, MiniMax Sparse Attention (arXiv:2606.13392), landed on June 11, 2026, so the mechanism is now documented rather than just announced.
Benchmarks (vendor-reported)
Read this section with one caveat in mind: every number below is MiniMax-reported, run on MiniMax's own infrastructure with baselines they selected. None have been independently confirmed by Scale AI (which maintains SWE-Bench Pro), and at least one outlet flagged the comparison as not independently verified. They are encouraging, not settled.
| Benchmark | MiniMax M3 | MiniMax's framing |
|---|---|---|
| SWE-Bench Pro (agentic coding) | 59.0% | MiniMax claims it edges GPT-5.5 (58.6%) and beats Gemini 3.1 Pro (54.2%); trails Claude Opus 4.7 (~64.3%). |
| Terminal-Bench 2.1 | 66.0% | Strong terminal/agent task performance. |
| MCP Atlas | 74.2% | Tool / Model-Context-Protocol use. |
| SWE-fficiency | 34.8% | Efficiency-weighted coding metric. |
| KernelBench Hard | 28.8% | Writing fast GPU kernels. |
Sources: MiniMax M3 launch blog and technical report (June 2026); VentureBeat launch coverage. All scores are vendor-run; the SWE-Bench Pro comparison to GPT-5.5 and Gemini 3.1 Pro is MiniMax's claim and has not been independently verified. We attribute rather than assert it.
Native multimodality
M3 is natively multimodal — it ingests image and video input directly rather than relying on an upstream frame-extraction or OCR step, and it can operate a desktop computer for agentic workflows. Combined with the 1M-token context, that makes it a single model for tasks that previously needed a chain of specialized tools: read a long video, hold an entire codebase or document corpus in context, and act on it.
Image & video input
Direct image and video understanding in the same model, no separate vision pipeline to wire up.
Computer use
M3 can operate a desktop computer, which is the foundation for the agentic/browsing tasks MiniMax highlights.
1M-token working memory
Whole-repository or whole-corpus prompts fit in one context — and MSA is what keeps that practical to serve.
Pricing
If you use the hosted API (MiniMax or third-party gateways like OpenRouter), M3 is priced aggressively — a fraction of frontier closed models. Note the tiered structure: the standard rate applies to requests up to 512K input tokens; above that, the request is billed at double the rate. Prices below are from MiniMax's pricing page, read 2 November 2026; a Priority tier costs 1.5x these.
| Tier | Input / 1M | Output / 1M |
|---|---|---|
| Standard (≤512K), list | $0.60 | $2.40 |
| Standard (≤512K), with permanent 50% off | $0.30 | $1.20 |
| Long-context (>512K), list / discounted | $1.20 / $0.60 | $4.80 / $2.40 |
MiniMax labels the 50% discount permanent, and OpenRouter lists the same $0.30 / $1.20. Because M3 is open weight, self-hosting is the other lever, but at 257-265 GB for a 4-bit build it only pays off on hardware you already own or for sustained high-volume work.
Can you run MiniMax M3 locally?
Yes, the weights are downloadable, but not on ordinary hardware: even the smallest 1-bit GGUF is 129 GB, a 4-bit build is about 257-265 GB, and the official FP8 weights are 444 GB. And there is no local Ollama tag: minimax-m3:cloud runs on Ollama's servers. In practice, running M3 yourself means a Mac Studio with 256-512 GB of unified memory, a multi-GPU server, or a CPU-plus-GPU setup with several hundred gigabytes of system RAM.
Sizes below were read on 2 November 2026 from the MiniMaxAI/MiniMax-M3, MiniMax-M3-MXFP8 and unsloth/MiniMax-M3-GGUF repositories (file totals from the Hugging Face API), and the Ollama registry. Add memory for the KV cache and the vision encoder on top of the weights.
| Build | Download | What can hold it |
|---|---|---|
| Original weights (BF16) | 854 GB | Multi-GPU server, e.g. 8x 141 GB or larger |
| Official MXFP8 (MiniMax-M3-MXFP8) | 444 GB | 8x 80 GB GPUs (640 GB) |
| GGUF Q8_0 | 454 GB | 512 GB Mac Studio (tight) or a CPU+GPU server |
| GGUF UD-Q4_K_M | 265 GB | 512 GB Mac Studio; 4x 80 GB GPUs |
| GGUF MXFP4_MOE | 257 GB | 512 GB Mac Studio; 4x 80 GB GPUs |
| GGUF UD-Q3_K_M | 196 GB | 256 GB Mac Studio; 3x 80 GB GPUs |
| GGUF UD-Q2_K_XL | 144 GB | 192-256 GB unified memory |
| GGUF UD-IQ1_M (smallest) | 129 GB | Does not fit 128 GB machines (Strix Halo, DGX Spark, 128 GB Macs) |
Ollama minimax-m3:cloud | none | Runs on Ollama's servers (512K context listed), not locally |
- •It is bigger than its launch coverage suggested. MiniMax's Hugging Face card gives ~428B total parameters with ~23B active per token, and the safetensors hold 427.0 billion. At BF16 that is 854 GB of weights alone.
- •Quantization is the path to a single box. A 4-bit GGUF is about 257-265 GB, which is the realistic target for a 512 GB Mac Studio or a server with four 80 GB cards. A 3-bit build (196 GB) is the floor for a 256 GB machine.
- •Only ~23B params activate per token. The MoE design (128 routed experts plus one shared, 4 routed per token) keeps compute per token far below the total, which is why CPU-plus-GPU runtimes that keep the experts in system RAM are viable. You still need memory to hold all of it. This page gives no tokens-per-second figure for an MoE model.
- •MSA helps the most at long context. The sparse-attention speedups are what make a long prompt tractable on your own hardware rather than purely theoretical.
MiniMax's card recommends SGLang or vLLM for serving, with Transformers, KTransformers (which keeps the experts in CPU memory) and unsloth's GGUFs as the other routes. To get the weights, or to try it through Ollama's cloud tier:
# Original weights, 854 GB (from MiniMax's model card)
hf download MiniMaxAI/MiniMax-M3 --local-dir MiniMax-M3
# Ollama: cloud only, nothing is downloaded to your machine
ollama run minimax-m3:cloudNew to quantization and VRAM math? Start with our quantization guide and the VRAM requirements guide. If your hardware can't hold a 428B model, a smaller open-weight coder from the best local AI models for programming roundup is the pragmatic choice, and the hosted API is a cheap stopgap while you size a rig. We will re-check the local options (including any MiniMax-M3.1-Flash builds) in the next refresh.
When to pick MiniMax M3 — and when not to
| Your situation | Best pick | Why |
|---|---|---|
| Self-hostable multimodal + long context | MiniMax M3 | Only open-weight model that bundles 1M context, native video, and frontier coding. |
| Computer-use / agentic browsing | MiniMax M3 | Native computer use + strong agentic scores (MiniMax-reported). |
| General open-weight workhorse | DeepSeek V4 | Broadly capable, widely supported, permissive licensing. |
| Agentic + coding at huge scale | Kimi K3 | Moonshot's successor to the 1T Kimi K2.6; strong agentic and coding profile. |
| Modest hardware (laptop / single GPU) | Smaller coders | A 428B model won't fit; pick a 7B–32B coder you can actually run. |
For a full side-by-side of the free models you can run, see our free local AI models guide roundup and the model comparisons hub.
Want to actually run open weights like M3?
MiniMax M3 proves open-weight models have caught up to the frontier — but only if you can deploy them. The Local AI Master deployment course walks you through quantization, multi-GPU serving, and long-context inference so you can run open models on your own hardware: unlimited inference, full data privacy, zero per-token cost.
See the deployment course →Related models & reading
- → DeepSeek V4 — open-weight frontier workhorse you can self-host
- → Kimi K3 — Moonshot's successor to the 1T Kimi K2.6
- → Free local AI models — the open models you can run at home
- → Best local AI models for programming — picks by hardware tier
- → Quantization explained — how to fit big models in less VRAM
- → Model comparisons hub — side-by-side across vendors
- → MiniMax M3 official announcement (minimax.io)
- → MiniMax model weights on Hugging Face
Go from reading about AI to building with AI
25 structured courses. Hands-on projects. Runs on your machine. Start free.

Written by
Barsha Mohapatra
Founder and Editor, Local AI Master · Founder, Little AI Master
Founder of Little AI Master and the editor behind every course and guide on Local AI Master. Years of tutoring students taught her where AI education actually fails.