Skip to main content
Last verified: 2026-10-24
MiniMax ships open-weight, agent-focused models. MiniMax M3.1 Flash (released October 23, 2026) is the current flagship — a ~428B mixture-of-experts model (about 23B active per token) with native multimodal input (text, image, video), 1M-token context, and DSpark speculative decoding. The earlier M3 is superseded by M3.1 Flash. The M2 line (M2 → M2.5 → M2.7) is the earlier, coding-agent-oriented series at ~230B; it has the most mature community quantization ecosystem. None of these are single-consumer-GPU models, but the M2 line is reachable on a big-memory Mac or workstation.

Can you run MiniMax locally?

MiniMax publishes only safetensors (BF16/F32) in its own repos — no official GGUF, AWQ, or MLX. Every quantized build comes from the community (Unsloth, bartowski, and others). What that means in practice: So the honest picture: MiniMax is a big-memory model, not a laptop-GPU one. If you have a 128 GB+ unified-memory Mac or a workstation with 128–512 GB of RAM, the M2 line runs via community GGUF. The M3.1 Flash and M3 need 249+ GB at Q4 — plan for 4x DGX Spark, 2x Mac Studio M5 Ultra 512 GB, or similar. Below that, MiniMax is effectively an API/cloud model.
MiniMax Sparse Attention (MSA) isn’t supported in llama.cpp yet. M3 and M3.1 Flash’s headline 1M-context and speed advantages come from MSA — but community GGUF builds fall back to dense attention, so a local llama.cpp/LM Studio run won’t deliver the full long-context behavior today. For the real experience at full context, serve the safetensors on vLLM/SGLang.

”MiniMax on Ollama” is cloud, not local

minimax-m3-1-flash, minimax-m3, minimax-m2.7, minimax-m2.5, and minimax-m2 all exist in the Ollama library — but each exposes only a :cloud tag. Those proxy requests to MiniMax’s hosted API; the weights never download to your machine, so there’s nothing local for a connector to point at. To self-host MiniMax on hardware you control, use a community GGUF (llama.cpp/LM Studio) or the safetensors (vLLM/SGLang), below — not Ollama’s :cloud tag.

Run it on your own hardware

Download GGUF builds from unsloth/MiniMax-M3.1-Flash-GGUF. Q4_K_XL is ~249 GB — needs 4x DGX Spark, 2x Mac Studio M5 Ultra 512 GB, or similar. Experimental VQ-GGUF from Baekpica pushes routed experts to ~2.0 bpw for a smaller footprint. Run through llama.cpp or LM Studio for an OpenAI-compatible API on http://127.0.0.1:8080/v1.

Variants & specs

Every value below is from the MiniMax model cards on Hugging Face and MiniMax’s release notes. M2, M2.1, M2.5, M2.7, and M3 are marked superseded on MiniMax’s own docs — M3.1 Flash is current. Verify against the model card before standardizing. Sources: MiniMaxAI/MiniMax-M3.1-Flash, MiniMaxAI/MiniMax-M3, MiniMaxAI/MiniMax-M2, MiniMax release notes, ollama.com/library/minimax-m3-1-flash.
Licensing varies a lot by version. M2 is MIT-with-attribution (permissive), M2.7 is non-commercial (commercial use needs written authorization), and M3 uses the MiniMax Community License (free below a revenue threshold, attribution “Built with MiniMax M3”). Read the LICENSE/LICENSE-MODEL file on the specific model card before any commercial deployment.

Which MiniMax should you run?

  • M3.1 Flash if you want the current flagship — DSpark speculative decoding, multimodal, 1M context — and have a multi-GPU server (249+ GB at Q4) or accept the llama.cpp sparse-attention limitation on a big-RAM box.
  • M3 if you need the earlier release for a specific reason (superseded by M3.1 Flash).
  • M2 / M2.7 if you’re on a 128 GB unified-memory Mac or big-RAM workstation and want a coding-agent model that runs today via mature community GGUFs. M2 has the deepest third-party tooling; M2.7 is the newer coding release (non-commercial license).

Connect it with Tokios

Once MiniMax is running on your own hardware — LM Studio, llama.cpp, vLLM, or SGLang exposing an OpenAI-compatible /v1 — pair the Tokios connector so you can reach it as https://api.tokios.com from Claude Code, Cline, or any other compatible client, instead of only from that one machine.
1

Pair the Tokios connector

Sign in at tokios.com/console, open the Setup tab, and click Start pairing to get a one-time claim code (TKS-XXXX-XXXX). Install and run the connector on the machine hosting MiniMax:
macOS
Linux
Then approve the device on the Setup or Connectors tab.
2

Point the connector at your runtime's /v1 API

LM Studio serves http://127.0.0.1:1234/v1; vLLM/SGLang serve http://127.0.0.1:8000/v1. Set the right one as the upstream in tokios-connector.json — see Connector config.
3

Register a deployment

In the Models tab, register the model and choose a public deployment name, for example minimax-tunnel. This name — not the upstream model id — is what clients send in the model field.
4

Create an API key

In the Keys tab, click Create key. Copy the sk-tok-… key now — it’s shown only once.

Call it from anywhere

The model field is always your registered deployment name (minimax-tunnel above), never the upstream model id. See Use Claude Code and Use Cline for full client setup.

Caveats

  • MiniMax publishes safetensors only — every GGUF/AWQ/MLX build is community-made. Unsloth publishes GGUF builds for M3.1 Flash at unsloth/MiniMax-M3.1-Flash-GGUF. Check the quant author before you rely on one.
  • Ollama’s minimax-* tags are :cloud-only — they run on MiniMax’s infrastructure, not yours. Self-host via community GGUF or the safetensors if you want it local.
  • llama.cpp doesn’t support MiniMax Sparse Attention yet, so local GGUF runs of M3.1 Flash and M3 fall back to dense attention and lose the full long-context advantage — use vLLM/SGLang for the real thing.
  • These are big-memory MoE models — all params must fit in memory even though only ~10–23B are active per token. M3.1 Flash at Q4 needs ~249 GB. Plan for a multi-GPU server, not a single consumer GPU.

Quickstart

Pair a connector and register your first model end to end.

Run models on a Mac Studio

Why a big unified-memory Mac is the natural home for the M2 line.

What size model fits your GPU?

The sizing math behind these memory numbers.

Which local model for which task?

Lighter models that run on hardware you already own.