MiniMax-M3.1-Flash: Open-weight model with 1M-token context

MiniMax has unveiled M3.1 Flash, a multimodal Mixture-of-Experts model for coding and agents. It previously ran anonymously on OpenRouter as "Space Bunny" and, according to the company, processed over 200 trillion tokens. The weights are now on Hugging Face.

Model releases Try it yourself Oct 23, 2026 4 min read Source: r/LocalLLaMA

What this is about

Chinese AI lab MiniMax officially unveiled the language model MiniMax-M3.1-Flash on October 19, 2026. The weights, meaning the numerical values the model learned during training, are now available on Hugging Face as MiniMaxAI/MiniMax-M3.1-Flash. No license text was visible in the sources we had. Before that, the model spent weeks running anonymously under the codename "Space Bunny" on OpenRouter, a platform through which developers access many models via a single API.

MiniMax describes M3.1 Flash as a natively multimodal model for coding, agent workflows (the AI completes multi-step tasks on its own), computer use and cybersecurity. It accepts text, images and video and outputs text.

The stealth phase as "Space Bunny"

According to a Japanese blog citing TokenPost and CellCog, "Space Bunny Alpha" appeared on OpenRouter on September 23. The vendor stayed hidden at first. According to those reports, the model held the #1 spot on the OpenRouter leaderboard for ten days in a row and processed 56.7 trillion tokens there. MiniMax itself cites over 200 trillion tokens across all services. Space Bunny was pulled from OpenRouter on October 5. According to CellCog, the released version is based on feedback from that phase and isn't identical to the alpha. The OpenCode figures (12 days at #1, 106 trillion tokens) come from a post on X and aren't officially confirmed.

According to CellCog, it's still unclear how MiniMax handles the prompts it received during the anonymous phase.

Technology

The model card lists:

Architecture: Mixture-of-Experts (MoE), where only some of the expert sub-models are active for each token.
Parameters: about 428B total, 23B active per token.
Context: up to 1,000,000 tokens.
Sparse attention (MSA): The model doesn't look at every part of the text at every step, only at selected parts. This saves compute.
Quantization-aware training: The model is prepared for low numerical precision during training, so it can run more compactly.
DSpark speculative decoding: A small extra head guesses several tokens ahead, and the main model checks them. This speeds up output.

Through the API, you can set the reasoning depth (effort) to one of five levels: low, medium, high, xhigh and max. The default is max. Thinking can't be turned off; parameters that try to do so cause an error (400).

Pricing

According to MiniMax, the API costs US$0.15 per million input tokens, US$0.60 per million output tokens and US$0.015 for cached input. That's half the price of M3. Unlike M3, which charges double above 512,000 input tokens, there is no such tiering. A Yahoo Finance piece compares it with DeepSeek V4.1 Flash, which reportedly charges US$0.30 and US$1.20 at peak times. On speed, the vendor claims over 200 tokens per second. The sources contradict each other on free usage (until October 22 or 25), and MiniMax's pricing page lists no free tier.

Benchmarks

The figures come from MiniMax itself:

Benchmark	M3.1 Flash	DeepSeek V4.1 Flash	GPT-5.6 Sol	Opus 5
Automation-Bench v1.0.6	62.8	54.8	45.8	50.3
BankerToolBench	76.2	73.7	74.6	76.2
Terminal Bench 4.0	38.1	31.2	39.9	51.8
LOCA-Bench 256K	60.3	–	60.0	53.7

Other figures: DeepSWE v1.1 73.7%, OSWorld V2 61.7, Agents' Last Exam 29.6, CyberGym 82.2. On Terminal Bench, Opus 5 is clearly ahead; on GDP.pdf AA, GPT-5.6 Sol leads. CellCog points out that the comparison models aren't the vendors' latest versions. The Japanese blog gives 62.2 for Automation-Bench, the model card 62.8; the model card is authoritative.

What you need to try it

At 428B parameters, this is not a model for your home computer. Even with 4-bit quantization, you need roughly 250 GB of memory or more, which means a multi-GPU server or a very large unified-memory machine. It won't run in any useful way on a regular gaming graphics card, a laptop or Google Colab. Plan for several hundred GB of storage. For most people, the API is the practical route.

Our take

M3.1 Flash is another strong open model from China for agents and coding, with a very low API price and long context. The stealth strategy gave MiniMax real-world usage data before the name was public. A word of caution: all performance and cost comparisons come from the vendor, independent measurements against M3 are missing, and the comparison models aren't the most current ones. If you're interested, check the license on the model page yourself.

Terms explained simply

Mixture-of-Experts (MoE): The model consists of many sub-networks ("experts"), only a few of which are active per token. That makes it large but faster than a dense model of the same size.
Open weights: The trained model weights are freely available to download, so you can run the model yourself.
Sparse attention: On long texts, the model considers only selected passages instead of all of them. This saves compute time and memory.
Speculative decoding: A small helper model guesses several words ahead, and the large model checks them all at once. This speeds up text output.
Quantization-aware training: Training that prepares the model for lower numerical precision, so it loses little quality when compressed later.
Context window: The amount of text the model can consider at once; here up to 1 million tokens.
OpenRouter: A platform that lets developers use many AI models from different providers through a single, unified API.

Sources

r/LocalLLaMA reddit.com
Google News (US) news.google.com
Google News (US) news.google.com
Google News (DE) news.google.com
Google News (KR) news.google.com

#minimax#open-weights#moe#coding#agents

Read the original source

Try it yourself: MiniMax-M3.1-Flash

Explained step by step, no prior knowledge needed – on your own computer or free in your browser.

What can I do with it?

The model writes code, controls tools in multi-step agent workflows, operates computer interfaces and analyzes text, images and video. It can handle very long documents or entire codebases of up to 1M tokens.

Who is it worth it for?

Worth a look for teams with multi-GPU servers, or for developers who want to test it cheaply through the API. It's too big for home PCs with a consumer graphics card.

Size428 B parameters

Download252 GB (about 5.6 hr at 100 Mbit/s)

Licensecustom license (see Model Card)

TypeImage + text (understands images)

Hugging FaceMiniMaxAI/MiniMax-M3.1-Flash

What your computer needs

Graphics card (NVIDIA) at least 304 GB VRAMCalculated, not measured: 252.4 GB of weights × 1.2 + 1 GB ≈ 304 GB, spread across all GPUs combined. The excerpt of the Model Card has no vendor figure. More memory allows longer texts (up to 1M tokens of context).

Mac (Apple Silicon M1–M5) from 512 GB unified memoryThe GPU and CPU share the memory – the model can use about 70% of it

Storage approx. 254 GB freeModel download plus programs

According to the sources, there is only one model, with about 428B parameters. Community quantizations are possible but aren't documented in the sources. To get started, the API makes more sense than self-hosting.

428B parameters: even at 4-bit, you need roughly 250 GB of memory or more (estimate).
Only 23B parameters are active per token, but all experts must be held in memory.
A long context of up to 1M tokens needs a lot of additional memory.
Not practical on a single consumer GPU, Colab or ordinary laptops.

Groß (428 B parameters, MoE): running entirely on the GPU takes a lot of VRAM (video memory). With MoE offloading, a regular graphics card plus plenty of RAM is enough (see table). Colab Free isn't enough.

How do I find out what my computer has?

Windows: Press Ctrl + Shift + Esc → Task Manager → Performance tab → click GPU on the left. At the bottom you'll see Dedicated GPU memory (that's your VRAM). You'll find system memory under Memory.
Mac: Apple menu at the top left → About This Mac. You'll see your chip (e.g. M2) and memory (e.g. 16 GB). On Apple chips, graphics and processor share this memory.
Linux: Type nvidia-smi in the terminal (shows your graphics card and its memory) and free -h for system memory.

Guide

This model runs with its developers' own program (vllm-project/vllm on GitHub). The commands below come from the Model Card and the developers' instructions.

Windows 10 / 11

Windows 10 / 11: not officially tested. The sources say nothing about Windows. The safest route is WSL2 (Linux on Windows) with the Linux guide. A normal Windows PC doesn't come close to the roughly 300 GB of VRAM (video memory) needed, so otherwise use MiniMax's online offerings.

Check the prerequisites. You need Python 3 (e.g., 3.10 or newer), Git and a current NVIDIA driver with CUDA. You also need GPUs with about 300 GB of memory combined and roughly 260 GB of free disk space.
```
python --version
git --version
nvidia-smi
```
Create a folder and environment. Open PowerShell. The virtual environment keeps the programs separate from the rest of your system. If activation is blocked, Set-ExecutionPolicy allows scripts for this session.
```
mkdir minimax; cd minimax
python -m venv .venv
.venv\Scripts\Activate.ps1
```
Install vLLM. vLLM runs the model and serves it as a server.
```
pip install vllm
```
Download prebuilt kernels. Prepared compute building blocks for a faster start.
```
vllm download-kernels
```

Download the model. That's 252.4 GB and takes a long time.

pip install -U huggingface_hub
hf download MiniMaxAI/MiniMax-M3.1-Flash

Start the server. Replace 8 with the number of GPUs you have. Leave the window open.
```
vllm serve MiniMaxAI/MiniMax-M3.1-Flash --tensor-parallel-size 8
```

Ask your first question. Open a second PowerShell window. The question is our own example.

curl.exe http://localhost:8000/v1/chat/completions -H "Content-Type: application/json" -d '{\"model\": \"MiniMaxAI/MiniMax-M3.1-Flash\", \"messages\": [{\"role\": \"user\", \"content\": \"Write a Python function that adds two numbers.\"}]}'

Result. A local server running MiniMax-M3.1-Flash is up on your machine and answers a text question.

macOS

macOS: not officially tested. vLLM mentions a plugin for Apple Silicon, but it hasn't been tested with this model. With 252.4 GB of weights, it won't fit on any regular Mac. Use MiniMax's online offerings (API or MiniMax Agent) instead.

Check the prerequisites. You need Python 3, Git and the Xcode command line tools. You also need about 260 GB of free disk space and a huge amount of RAM (about 300 GB).
```
xcode-select --install
python3 --version
git --version
```
Create a folder and environment. The virtual environment keeps the programs separate from the rest of your system.
```
mkdir minimax && cd minimax
python3 -m venv .venv
source .venv/bin/activate
```
Install vLLM. vLLM runs the model and serves it as a server. Whether the installation works on a Mac hasn't been tested.
```
pip install vllm
```
Download prebuilt kernels. Prepared compute building blocks for a faster start.
```
vllm download-kernels
```

Download the model. That's 252.4 GB and takes a long time.

pip install -U huggingface_hub
hf download MiniMaxAI/MiniMax-M3.1-Flash

Start the server. Leave the window open. Whether the model starts on a Mac hasn't been tested.
```
vllm serve MiniMaxAI/MiniMax-M3.1-Flash
```

Ask your first question. Open a second terminal. The question is our own example.

curl http://localhost:8000/v1/chat/completions -H "Content-Type: application/json" -d '{"model": "MiniMaxAI/MiniMax-M3.1-Flash", "messages": [{"role": "user", "content": "Write a Python function that adds two numbers."}]}'

Result. A local server running MiniMax-M3.1-Flash is up on your machine and answers a text question.

Linux

Linux: not officially tested. vLLM supports NVIDIA, AMD and Intel GPUs. The excerpt of the Model Card we have doesn't say whether MiniMax-M3.1-Flash runs on them. You need several server GPUs with about 300 GB combined. It won't work with a regular home graphics card, so use MiniMax's online offerings (API or MiniMax Agent) instead.

Check the prerequisites. You need Python 3 (e.g., 3.10 or newer), Git and a current NVIDIA driver with CUDA. CUDA is the technology that lets programs use the GPU. You also need several GPUs with about 300 GB of memory combined and roughly 260 GB of free disk space.
```
python3 --version
git --version
nvidia-smi
```
Create a folder and environment. A virtual environment (venv) keeps the programs separate from the rest of your system.
```
mkdir minimax && cd minimax
python3 -m venv .venv
source .venv/bin/activate
```
Install vLLM. vLLM is the program that runs the model and serves it as a server.
```
pip install vllm
```
Download prebuilt kernels. These are prepared compute building blocks. They help vLLM start faster.
```
vllm download-kernels
```
Download the model. That's 252.4 GB and takes a long time. If it gets interrupted, just rerun the command.
```
pip install -U huggingface_hub
hf download MiniMaxAI/MiniMax-M3.1-Flash
```
Start the server. Replace 8 with the number of GPUs you have. The option spreads the model across all cards (tensor parallelism). Leave the window open.
```
vllm serve MiniMaxAI/MiniMax-M3.1-Flash --tensor-parallel-size 8
```

Ask your first question. Open a second terminal. The server runs on port 8000. The question is our own example; the source doesn't give one.

curl http://localhost:8000/v1/chat/completions -H "Content-Type: application/json" -d '{"model": "MiniMaxAI/MiniMax-M3.1-Flash", "messages": [{"role": "user", "content": "Write a Python function that adds two numbers."}]}'

Result. A local server running MiniMax-M3.1-Flash is up on your machine and answers a text question.

Try it

Analyze this Python project and suggest a refactoring that removes duplicate code.

Describe what this screenshot of a table shows and summarize the key figures.

Plan step by step how I can find and fix a bug on a Linux server using the terminal.

If something goes wrong

The license isn't named in the sources, so check the model page before commercial use.

Thinking can't be turned off; effort "none" causes a 400 error. To save cost, lower the effort level instead.

Without a setting, the API runs at effort "max", which costs more tokens and time.

An Ollama tag or GGUF files aren't documented; you need inference software that supports the MSA architecture.

“out of memory,” a crash, or your computer freezes

The model is too big for your VRAM (video memory). Pick a smaller variant from the table above and close other programs, especially games and browsers with lots of tabs.

It runs, but extremely slowly

Your CPU is probably doing the work instead of your graphics card. In Ollama, the PROCESSOR column of ollama ps shows how much runs on the GPU. If it says "100% CPU", update your graphics driver or pick a smaller variant that fits entirely into VRAM (video memory).

“ollama” or “python” is not found

Close the terminal window and open it again so it recognizes the newly installed program. For Python on Windows: reinstall it and check Add python.exe to PATH.

Windows: "Running scripts is disabled on this system"

Run the script with exactly the command above: powershell -ExecutionPolicy Bypass -File try_windows.ps1. This allows execution for this one time only.

Error message when loading the model (version, "trust_remote_code", unknown architecture)

Brand-new models often need the latest software version. With Ollama: update Ollama. With Python: pip install -U transformers in the activated environment. The Model Card usually lists the exact version.

Tokenstrom generates the scripts and notebook automatically. Please take a quick look before running them – they're plain, readable text. Mind the model's license: custom license (see Model Card).

Ask the AI assistant

Questions about this article, installation or background? Our assistant knows this page and runs on our own machine, not in someone else's cloud.

Connecting …

The Assistant is an AI (Gemma 4) and can make mistakes – please check important details against the source. Questions are used only to generate an answer and are deleted after one hour. Please don't enter any personal data.

Comments

What do you think? Already tried it? Write it here, no sign-up needed.

Loading comments …

Comments are public. Links aren't allowed, and we delete abusive posts. You can delete your own comment at any time in this browser. Learn more in the Privacy Policy.