Skip to main content
MiniMax ships open-weight, agent-focused models. MiniMax M3 is the current flagship — a ~428B mixture-of-experts model (about 23B active per token), with a 1M-token context, native multimodal input, and computer-use/agentic tool-calling. The M2 line (M2 → M2.5 → M2.7) is the earlier, coding-agent-oriented series at ~230B; it’s smaller, text-only, and — importantly for running locally — 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. This page covers what actually runs where, then how to put a private endpoint in front of it with Tokios.

​
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. Below that, MiniMax is effectively an API/cloud model.
MiniMax Sparse Attention (MSA) isn’t supported in llama.cpp yet. M3’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 of M3 won’t deliver M3’s full long-context behavior today. For the real M3 experience at full context, serve the safetensors on vLLM/SGLang.

​
”MiniMax on Ollama” is cloud, not local

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

On a 128 GB+ unified-memory Mac or a big-RAM workstation, run an M2.5/M2.7 community GGUF through llama.cpp or LM Studio. Start from Unsloth’s or bartowski’s quants and pick the largest that fits your combined memory (UD-Q3_K_XL ≈ 101 GB, UD-IQ4_XS ≈ 108 GB; Q8_0 ≈ 243 GB needs ~256 GB RAM). LM Studio then exposes an OpenAI-compatible API on http://127.0.0.1:1234/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, and M2.7 are marked superseded on MiniMax’s own docs — M3 is current. Verify against the model card before standardizing. Sources: MiniMaxAI/MiniMax-M3, MiniMaxAI/MiniMax-M2, MiniMax release notes, ollama.com/library/minimax-m3.
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 if you want the current flagship — long context, multimodal, agentic — and have a multi-GPU server (or accept the llama.cpp sparse-attention limitation on a big-RAM box).
  • 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. 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 fall back to dense attention and lose M3’s 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. Plan for a 128 GB+ machine, 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.