MiniMax's Flash Model Is Cheap Because of the Cache, Not the Price Tag

In partnership with

SnackOnAI Engineering | Senior AI Systems Researcher | Technical Deep Dive | October 19, 2026

The promise: by the end of this issue you will know which of MiniMax M3.1 Flash's efficiency claims hold up, what actually drives the cost of an agent loop on it, and the one integration mistake that silently breaks its tool calling.

The fence: we cover MiniMax M3.1 Flash as released October 19, 2026: its launch post, API behavior, vendor benchmarks, Artificial Analysis measurements, and the Space Bunny stealth run. We skip the unreleased Pro model and the MiniMax Code desktop app, and we cannot cover model internals, because MiniMax has not published them. Weights are promised but not yet released.

What It Actually Does

M3.1 Flash is MiniMax's fast, cheap agent model, replacing M2.5 and M2.7 on its plans (those retire November 18, 2026). Before launch it ran anonymously on OpenRouter as Space Bunny Alpha, ranked first there for 10 straight days, and processed 56.7T tokens on that platform alone. MiniMax says the stealth period added up to 200T+ tokens.

The spec sheet:

Property	Value
Model ID	`MiniMax-M3.1-Flash`
Context	1M tokens, input and output combined
Modalities	Text, image, video in; text out
Thinking	Always on; effort `low`, `medium`, `high`, `xhigh`, `max` (default `max`)
Price	$0.15 input, $0.60 output, $0.015 cached input per 1M
Protocols	Anthropic Messages, OpenAI Chat Completions, OpenAI Responses
Weights	"Will be released later"

Vendor benchmarks, against MiniMax's own chosen comparison set:

Benchmark	M3.1 Flash	DeepSeek V4.1 Flash	Opus 5	GPT-5.6 Sol
Automation-Bench v1.0.6	62.2	60.5	50.3	45.8
DeepSWE v1.1	73.7	77.0	74.0	73.0
Terminal-Bench 4.0	38.1	42.3	51.8	39.9
OSWorld V2	61.7	n/r	70.6	65.7
HLE (no tools)	43.4	42.6	55.6	49.5

Also claimed: CyberGym 82%, BankerToolBench 76.2, BabyVision 91%. Independent: Artificial Analysis gives it an Intelligence Index of 42, fourth of 173 models in its class.

The honest one line summary: a strong, cheap agent workhorse that leads its weight class on automation, and trails frontier models everywhere else.

The Architecture, Unpacked

MiniMax disclosed exactly one architectural detail: efficiency came "through more aggressive sparsity." No parameter count, no expert count, no attention design. The lineage hints at what that means: MiniMax-M1 (2025) was a 456B total, 45.9B active Mixture of Experts (MoE) model with hybrid "lightning" linear attention, and MiniMax-M2 cut active parameters to about 10B of 230B. A sparser MoE means fewer weights touched per token, which is where speed and price come from.

What MiniMax did specify is the serving contract, and that is what you build against.

Caption: Focus on the cache and the loop. Cached input costs a tenth of new input, and the loop only stays cache friendly and coherent if you replay each assistant turn exactly.

Three decisions shape the experience, ranked.

One: thinking cannot be turned off. Setting effort to none or disabling thinking returns HTTP 400. The default is max. Every call pays for reasoning tokens at the output price.

Two: interleaved thinking across tool calls. The model reasons, calls a tool, sees the result, and continues reasoning. That requires you to pass its previous reasoning back. Adapters that keep only visible text break it.

Three: a 90% cache discount. Cached input is $0.015 against $0.15 for new input. In an agent loop, where each turn resends the whole conversation, that discount dominates the bill.

The Code, Annotated

First, the agent loop that keeps interleaved thinking intact, using the OpenAI SDK against MiniMax's OpenAI compatible endpoint. Near runnable: set MINIMAX_API_KEY and supply your own tool.

import json, os
from openai import OpenAI

client = OpenAI(base_url="https://api.minimax.io/v1", api_key=os.environ["MINIMAX_API_KEY"])

tools = [{"type": "function", "function": {
    "name": "run_tests",
    "description": "Run the test suite and return failures",
    "parameters": {"type": "object", "properties": {"path": {"type": "string"}}, "required": ["path"]}}}]

def run_tests(path: str) -> str:
    return json.dumps({"failed": ["test_refund_rounding"], "passed": 41})   # stub for illustration

messages = [{"role": "user", "content": "Fix the failing refund test in ./payments"}]

for _ in range(10):
    resp = client.chat.completions.create(
        model="MiniMax-M3.1-Flash",
        messages=messages,
        tools=tools,
        reasoning_effort="medium",      # default is "max"; set it explicitly or pay for max on every turn
        max_tokens=8192,                # bound output: thinking counts against it and against your bill
    )
    msg = resp.choices[0].message

    # ← THIS is the trick: append the FULL assistant turn, reasoning included.
    # Keeping only msg.content drops reasoning_content, and the next turn
    # loses its own plan: repeated tool calls, contradictory edits.
    turn = msg.model_dump(exclude_none=True)        # keeps reasoning_content and tool_calls
    messages.append(turn)

    if not msg.tool_calls:
        print(msg.content)
        break
    for call in msg.tool_calls:
        result = run_tests(**json.loads(call.function.arguments))
        messages.append({"role": "tool", "tool_call_id": call.id, "content": result})

# Bonus: replaying turns byte for byte keeps the conversation prefix stable,
# which is exactly what the prompt cache needs to bill old context at $0.015.

Caption: The same habit fixes two problems. Replaying the full assistant turn preserves the model's reasoning chain and keeps the prefix cacheable.

Second, checking the vendor's cost math against its own price sheet. We ran this.

M3    = dict(inp=0.30, out=1.20)   # predecessor, OpenRouter listing
FLASH = dict(inp=0.15, out=0.60)   # M3.1 Flash list price

price_ratio = FLASH["out"] / M3["out"]
print(f"price ratio: {price_ratio}")                 # 0.5: list price is exactly half

# If cost = price × tokens, what token reduction do the claims require?
for claim, cost_ratio in [("1/3 the cost of M3", 1/3), ("70% lower usage cost", 0.30)]:
    tokens_ratio = cost_ratio / price_ratio          # ← THIS is the trick: price can only explain half
    print(f"{claim}: needs {tokens_ratio:.2f}x the tokens of M3 ({1 - tokens_ratio:.0%} fewer)")
# Output:
# 1/3 the cost of M3: needs 0.67x the tokens of M3 (33% fewer)
# 70% lower usage cost: needs 0.60x the tokens of M3 (40% fewer)

print(f"Artificial Analysis verbosity: {180/99:.2f}x the class median output tokens")
# Output: 1.82x the class median output tokens

Caption: To hit 70% savings at half the price, M3.1 Flash must spend 40% fewer billed tokens per task than M3. Independent testing finds it 1.8x more verbose than its peers. Caching and shorter tool loops have to close that gap.

It In Action

Input: a coding agent run on M3.1 Flash. Assumptions, stated plainly: a 20K token system prompt plus repo context, 30 turns, each turn adding 3K tokens of tool output and messages, and 1,500 output tokens per turn at high effort (500 at low effort). Prices from MiniMax's sheet.

Step one, context growth. The conversation grows from 20K to 110K tokens. Because every turn resends the whole history, total input across the run is 1,905,000 tokens.

Step two, cache. On turn 2 onward, everything but the newest 3K tokens is a repeated prefix. With cache hits, that prefix bills at $0.015 per million instead of $0.15.

Step three, output. 30 turns × 1,500 tokens = 45,000 output tokens, thinking included.

Output, the bill:

Scenario	Cost per run
High effort, cache hits	$0.070
Low effort, cache hits	$0.052
High effort, no cache hits	$0.313

Caption: Cache behavior moves the bill 4.5x. Thinking effort moves it about 1.3x. Optimize the prefix before you touch the effort knob.

For scale: Artificial Analysis measured $0.22 per task on its index workload, and MiniMax's own chart prices a full Agents' Last Exam run at $111.

Why This Design Works, and What It Trades Away

Why it works. Agent workloads are input heavy: the same growing transcript is re-read every turn. Pricing cached input at a tenth of new input rewards exactly that pattern. A sparse model keeps per token compute low, and always on thinking with adjustable effort gives one knob for quality versus cost. The Space Bunny run is the strongest evidence that it works at scale: OpenRouter reported time to first token falling from 1.95s to 1.22s, throughput rising from 70 to 100 tok/s, and errors dropping from 1.4% to 0.7% while MiniMax iterated live.

What it trades away.

No off switch for thinking. Simple classification or extraction calls still pay for reasoning.
Frontier depth. It trails Opus 5 by 13.7 points on Terminal-Bench 4.0 and 12.2 on HLE.
Shared window. The 1M limit covers input and output together.
Transparency. Closed weights for now, no architecture details, and every headline number is vendor reported.

Technical Moats

The moat is production feedback at a scale few labs can stage. Running anonymously as Space Bunny, the model absorbed 56.7T tokens of real OpenRouter traffic in two weeks, and MiniMax visibly tuned serving during the run. That is a live A/B lab with unbiased users who did not know whose model they were testing.

The second moat is price per useful token. At $0.15 and $0.60, with cached input at $0.015, it sits below its class median on both input ($0.24) and output ($0.87), per Artificial Analysis. Serving a 1M context model with interleaved reasoning at those prices requires inference efficiency that is hard to match.

Contrarian Insights

Insight One: the 70% savings is not a price story. The list price fell exactly 50% from M3 ($0.30/$1.20 to $0.15/$0.60). A 70% cost reduction therefore requires 40% fewer billed tokens per task. Yet Artificial Analysis measured M3.1 Flash at 180M output tokens on its index, 1.82x the class median of 99M. If the savings are real, they come from cache hits and shorter agent loops, which depend on your harness, not the model. Teams that rebuild context every turn will not see them.

Insight Two: the speed claim and the measured speed disagree. MiniMax says median output speed is 170+ tok/s, with peaks above 200. Artificial Analysis measured 120.1 tok/s, ranking it 70th of 151, roughly the class median. OpenRouter's stealth figures topped out at 100 tok/s. "Nearly three times faster" is relative to MiniMax's own predecessor, not to the market.

Surprising Takeaway

On a realistic 30 turn coding agent run, cache hits change the bill by 4.5x, from $0.31 to $0.07, while switching from high to low thinking effort changes it by only about 1.3x. MiniMax's most important efficiency feature is not the model's sparsity or its speed. It is a $0.015 cached input price that only pays off if your harness replays every assistant turn byte for byte, which is the same discipline its interleaved thinking already demands.

TL;DR For Engineers

MiniMax-M3.1-Flash: $0.15 in, $0.60 out, $0.015 cached; 1M shared window; text, image, video in.
Thinking is always on and defaults to max; set reasoning_effort (or output_config.effort) explicitly.
Append the full assistant turn, reasoning_content and tool_calls included, or interleaved thinking breaks.
Price halved; the claimed 70% savings needs 40% fewer billed tokens, so check your cache hit rate first.
Leads Automation-Bench (62.2), trails Opus 5 on Terminal-Bench (38.1 vs 51.8) and HLE (43.4 vs 55.6).

Explain It Like I'm New

Think of an AI agent like a contractor working on a long renovation. Every morning, before doing anything new, it rereads the entire job file: the plans, yesterday's notes, every receipt. On a big project, that rereading is most of the work.

AI models charge by the amount of text they read and write. For agents that work through many steps, rereading the growing history every step makes up most of the bill.

MiniMax's new M3.1 Flash model is built to be cheap and fast for exactly this kind of work. Its sticker price is half of its predecessor's. More importantly, it charges ten times less for text it has already seen recently, like a contractor who gets a discount for re-reading notes they have already filed.

There is a catch. The model always thinks before it answers, and that thinking is billed. And the discount only works if your software resends the job file in exactly the same way each time. Get that right, and a long coding task costs pennies. Get it wrong, and it costs several times more.

The bigger lesson: as AI moves from single answers to long-running agents, the cost of a model depends as much on how you use it as on its price list.

See It In Action

MiniMax M3.1 Flash launch post, MiniMax. minimax.io/blog/minimax-m31f. The official benchmark charts and cost per task plots, including Automation-Bench effort levels and the Agents' Last Exam run cost.
MiniMax M3.1 Flash Preview: Hands On Tests With M-Code Agent, MindStudio. mindstudio.ai. A practitioner walkthrough: a playable 3D game built in about 30 minutes, a SQL bug found in a six join query, and the spatial reasoning mistakes it still made.
Model Invocation guide, MiniMax API Docs. platform.minimax.io. How to call the model over Anthropic and OpenAI compatible protocols, including effort settings.
MiniMax M3.1 Flash: Protocol Compatibility Checklist, EvoLink. evolink.ai. The clearest write up of the interleaved thinking requirement and the "effort none returns an error" gotcha.

Community Conversation

Artificial Analysis, independent measurements. Intelligence Index 42, fourth of 173 in class, but 120 tok/s measured speed and 1.8x median verbosity, the numbers that complicate the vendor's speed and cost story.
Unite.AI, Space Bunny reveal. Documents the OpenRouter stealth run and the latency, throughput, and error improvements made during it, and flags inconsistent benchmark figures across sources.
CellCog, price and benchmark breakdown. Notes the comparison table uses GPT-5.6 Sol and Opus 5 rather than the newer GPT-6.1 Sol and Opus 5.5, and that Opus 5 still tops most rows.
Tech Insider, launch analysis. Highlights the transparency gap: closed weights at launch and no head to head benchmark against DeepSeek at release time.
Data Science in Your Pocket on Medium, a few important asterisks. Warns against mixing M3 benchmarks into M3.1 reviews and explains the default max effort cost.

Flash Models Are Now Priced on Your Harness, Not Their Rate Card

MiniMax M3.1 Flash is a credible, cheap agent model with a real lead on automation work and a stealth run few competitors can match. But its headline economics only partly come from the model. Half of the claimed savings is a price cut; the rest depends on cache hits, effort settings, and replaying every turn exactly, all of which live in your code. Treat the 70% figure as a ceiling you earn, not a discount you receive, and measure your own cache hit rate before you migrate.

References

MiniMax-M1: Scaling Test Time Compute Efficiently with Lightning Attention, MiniMax. The hybrid attention MoE and CISPO RL recipe behind the lineage.
MiniMax-01: Scaling Foundation Models with Lightning Attention, MiniMax. The linear attention foundation for million token context.
Outrageously Large Neural Networks: The Sparsely Gated Mixture of Experts Layer, Shazeer et al. The origin of sparse expert routing.
ReAct: Synergizing Reasoning and Acting in Language Models, Yao et al. The reasoning plus tool use loop that interleaved thinking extends.
OSWorld: Benchmarking Multimodal Agents for Open Ended Tasks in Real Computer Environments, Xie et al. The computer use benchmark behind the OSWorld V2 score.

MiniMax M3.1 Flash is a closed weight, always thinking agent model priced at $0.15 in and $0.60 out, with a 90% cache discount and a 1M token shared window, that leads its class on Automation-Bench and trails frontier models on coding and reasoning. Its claimed 70% cost cut needs 40% fewer billed tokens than its predecessor, so real savings depend on cache hits and correct interleaved thinking in your harness.

Sponsored Ad If you enjoy practical AI insights, check out SnackOnAI and support the newsletter by subscribing, sharing, and exploring our sponsored ad—it helps us keep building and delivering value 🚀

The AI notetaker that gets the hard words right

Your AI is only as good as what you feed it. Feed it a transcript with your product names, acronyms, and numbers spelled wrong, and you spend the afternoon hand-fixing the output.

Wispr Flow Notetaker uses your dictionary and calendar, so product names, acronyms, numbers, and uncommon names come out spelled right. It pops up when your meeting starts and captures Zoom, Google Meet, Teams, and Slack huddles with one click, no bot joining the call.

Then your meetings show up inside Claude or ChatGPT through the built-in connector. No copy paste. Try Notetaker free on Mac and Windows.

Try Notetaker Free