# MiniMax M3.1 Flash Thinks at Max by Default: First Call, Effort as the Price Knob, and Cache Math vs DeepSeek Flash > Source: > Published: 2026-10-20 13:14:13+00:00 **Attributed compile + two small offline scripts** **Primary sources (MiniMax, 2026-10-19):** [MiniMax M3.1 Flash: Redefining Agent Performance and Cost](https://www.minimax.io/blog/minimax-m31f) (and the [Chinese version](https://www.minimax.cn/blog/minimax-m31f)); MiniMax API docs: [Model Invocation](https://platform.minimax.io/docs/guides/text-generation), [OpenAI SDK](https://platform.minimax.io/docs/api-reference/text-openai-api), [Tool Use & Interleaved Thinking](https://platform.minimax.io/docs/guides/text-m3-function-call), [Prompt Caching](https://platform.minimax.io/docs/api-reference/text-prompt-caching). **Independent numbers and reporting:** [Artificial Analysis model page](https://artificialanalysis.ai/models/minimax-m3-1-flash) (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](https://venturebeat.com/technology/minimaxs-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](https://news.ycombinator.com/item?id=50154540) (488 points); V2EX [minimax-v3.1-flash 发布了，大家用下来怎么样？](https://www.v2ex.com/t/1250234); PingWest (品玩) [MiniMax 杀进 Flash 混战，我拿五个项目试了试](https://www.pingwest.com/a/318014). 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: ``` python 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 nothing`presence_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: ``` php [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](https://x.com/bitsquin/status/2112166580448891231) 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](https://plotly.com/blog/minimax-m3-1-flash-plotly-data-analytics-bench/), 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](https://yongbo-yu.vercel.app) and [GitHub](https://github.com/YongBoYu1).*