Attributed compile + two small offline scripts
Primary sources (MiniMax, 2026-10-19): MiniMax M3.1 Flash: Redefining Agent Performance and Cost (and the Chinese version); MiniMax API docs: Model Invocation, OpenAI SDK, Tool Use & Interleaved Thinking, Prompt Caching.
Independent numbers and reporting: Artificial Analysis model page (read 2026-10-20); Carl Franzen, MiniMax's new M3.1 Flash beats DeepSeek and Opus 5 on a key business benchmark at lower cost — but with a high hallucination rate (VentureBeat).
Community (2026-10-19 to 10-20): Hacker News thread (488 points); V2EX minimax-v3.1-flash 发布了，大家用下来怎么样？; PingWest (品玩) MiniMax 杀进 Flash 混战，我拿五个项目试了试.
I have not called the MiniMax API (no key on this box). The scripts below lint request settings and do price math from the published rules.
On October 19 MiniMax shipped M3.1 Flash and confirmed that "Space Bunny", the anonymous model some coding-tool users had been trying (MiniMax says it processed 200T+ tokens), was an early version of it. The headline: list price $0.15 / $0.60 per 1M tokens (input / output), $0.015 for cached input, a 1M context, text + image + video input, and MiniMax's claim of ~3× faster inference and 70% lower agentic-task cost than the previous generation.
MiniMax's own numbers include DeepSWE v1.1 73.7%, BankerToolBench 76.2, OSWorld V2 61.7, and CyberGym 82%. Artificial Analysis independently lists it at 43 on its Intelligence Index, $0.22 per index task, ~105 output tokens/s, and 180M output tokens to run the index (median for its class: 99M). VentureBeat, citing AA, also reports a 93% hallucination rate on AA-Omniscience. That doesn't mean 93% of answers are wrong. It means that when the model didn't know, it almost always guessed instead of saying so.
Reactions were split: HN commenters who had used Space Bunny called it "benchmaxed", and a V2EX user reported tasks burning 20M tokens where DeepSeek's Flash finished in 1M. This post skips that argument and covers the settings that decide what the model costs in your code.
OpenAI-compatible endpoint, with the one line I'd add on day one:
import os
from openai import OpenAI
client = OpenAI(api_key=os.environ["MINIMAX_API_KEY"], base_url="https://api.minimax.io/v1")
r = client.chat.completions.create(
model="MiniMax-M3.1-Flash",
reasoning_effort="low", # omit this and you get "max"
max_completion_tokens=4096, # thinking tokens count against this
messages=[{"role": "user", "content": "Label this ticket: billing, bug, or other? 'I was charged twice.'"}],
)
print(getattr(r.choices[0].message, "reasoning_content", None))
print(r.choices[0].message.content)
(Not run; no key.) The docs list the rules:
reasoning_effort accepts low | medium | high | xhigh | max, and omitting it means max. output_config.effort. On the Responses API it's reasoning.effort. thinking: {"type": "disabled"} or reasoning_effort: "none" returns disabled skipped thinking. If your M3 classifier disabled thinking, the same request now fails.temperature and top_p do nothingpresence_penalty, frequency_penalty and logit_bias. Effort is the only control you have. max_tokens / max_completion_tokens. finish_reason: "length" with an content`` n only supports 1, and service_tier (the 1.5× "priority" lane) isn't available for this model.
runs/22-minimax-m3-1-flash/lint_request.py turns those rules into an offline pre-flight check. Excerpt of the actual output:
[copied from a GPT/DeepSeek config]
WARN reasoning_effort omitted -> defaults to 'max' (slowest, most output tokens). Set it explicitly.
WARN temperature has no effect (temperature is always 1, top_p always 0.95).
WARN top_p has no effect (always 0.95).
WARN output budget 800 counts thinking tokens too; at effort max (default) you risk finish_reason='length' with empty content.
[cache-busting system prompt]
WARN system prompt contains a timestamp/id-looking value; cache is prefix-matched (tools -> system -> messages), so everything after the tool list misses the cache on every call.
[explicit low-effort classifier]
OK
The 2,048-token "too small" threshold is my own guess. MiniMax doesn't publish a number.
X user @bitsquin posted a small Python bug-fix test (215 hidden tests): M3.1 Flash at default settings took 56 s and $0.0045, and at low effort 9.5 s and $0.0006, and fixed the same two bugs. That's 5.9× the time and 7.5× the cost for the same result on that task. It's one person's test, and I didn't reproduce it. HN user chriddyp, posting Plotly's data-analytics benchmark, said it tied the top score (41/43) but was the slowest model they've tested, "because of the number of tokens it uses, not the inference speed." PingWest saw steady ~100 tokens/s in MiniMax Code on the Preview build, but the model kept re-checking finished work.
The problem isn't speed per token. It's how many tokens the default spends. My untested starting point: low for classification, extraction and routing, medium/ high for normal coding-agent turns, and xhigh/ max only where you've measured that the extra tokens pay off.
cost_math.py uses the same example agent turn as my Muse Spark Open and DeepSeek posts (60K input with 50K from cache, 4K output including reasoning). Actual output:
model $/turn $/1k turns
minimax-m3.1-flash 0.00465 4.65
deepseek-flash off-peak 0.00405 4.05
deepseek-flash peak 0.00810 8.10
minimax-m3.1-flash, zero cache hits: 0.01140/turn (11.40/1k)
The miss and output prices match DeepSeek's off-peak rates. The gap is the cache hit: $0.015 vs DeepSeek's $0.003 off-peak. Grow the cached prefix and it widens (excerpt):
cached prefix | minimax $/turn | ds off-peak | ds peak (10K fresh in, 4K out)
0 | 0.00390 | 0.00390 | 0.00780
200,000 | 0.00690 | 0.00450 | 0.00900
900,000 | 0.01740 | 0.00660 | 0.01320
MiniMax beats DeepSeek PEAK until the cached prefix passes ~433,333 tokens (10K fresh/4K out)
DeepSeek's peak windows land on Toronto evenings and early mornings, so for overnight batch jobs that run in those windows, M3.1 Flash is cheaper unless the cached prefix is huge. Long-context agents that re-send a big cached prefix are better off on DeepSeek. And once effort climbs, output dominates: at 16K output tokens per turn, 81% of the bill is output.
MiniMax returns cache usage in two shapes, and they mean different things:
prompt_tokens prompt_tokens_details.cached_tokens) input_tokens cache_read_input_tokens)
Applied to the literal sample responses in MiniMax's Tool Use guide:
OpenAI shape correct miss/hit/out=(2, 466, 37) $29.49 per 1M such calls
OpenAI shape no-cache miss/hit/out=(468, 0, 37) $92.40 (3.13x)
OpenAI shape double miss/hit/out=(468, 466, 37) $99.39 (3.37x)
Anthropic correct miss/hit/out=(280, 188, 37) $67.02 per 1M such calls
Anthropic subtract miss/hit/out=(92, 188, 37) $38.82 (0.58x)
A dashboard shared by both SDK paths can be off by 3× one way or ~40% the other. Write one parser per protocol.
The Tool Use guide says to append the full assistant message, including reasoning_content and tool_calls (on the Anthropic path, the whole response.content list). Rebuilding history from content alone breaks interleaved thinking. Unlike DeepSeek, the docs describe no 400 for this, so the failure is quiet. The model also skips thinking on simple tool calls, so read reasoning_content with getattr(..., None). check_replay() in the lint script flags both cases.
MiniMax's blog says weights will come "later". VentureBeat reports October 23, with no license announced, and Artificial Analysis still lists the model as proprietary. I did not call the API, measure token counts per effort level, reproduce any benchmark or the @bitsquin test, check hallucinations, or test video input. Given the AA finding, put retrieval or a verifier in front of anything factual it writes.
On cheap reasoning models, the price you pay per task depends on your effort setting more than on the per-token rate. Set effort explicitly, parse usage per protocol, and keep the cached prefix byte-stable. Then compare models on your own tasks.
YongBo Yu is an AI engineer in Toronto building LLM workflows and agent systems. More at yongbo-yu.vercel.app and GitHub.