MiniMax M3.1 Flash Explained: Benchmarks, $0.15 Pricing, and the 93% Hallucination Problem (2026)

If you are choosing a cheap model for an agent loop that makes dozens of tool calls per user request, the rate card stopped being the hard part sometime this year. Several flash-tier models now sit near $0.15 per million input tokens, so the real question has shifted to which one fails in the least expensive way. MiniMax M3.1 Flash, released on October 19, 2026, sharpens that question because it arrives with two numbers that seem to describe different models: an Artificial Analysis Intelligence Index score of 42 at roughly $0.22 per task, and a 93% hallucination rate on AA-Omniscience [2].

This post is the engineering read of that launch. It separates what independent evaluators measured from what MiniMax reports about itself, works through the architecture and pricing arithmetic, explains what the 93% figure does and does not mean with a worked example, and gives you runnable Python and curl for OpenRouter, a grounding wrapper that forces an honest "I don't know", a cost calculator, and a router that keeps fact-critical answers on a stronger model. Where sources disagree I say so, and where I am inferring I label it.

Quick summary before the depth:

• Release: October 19, 2026, from MiniMax Group, as a faster and cheaper update to MiniMax M3, which launched in June 2026 [1].
• Price: $0.15 input, $0.60 output and $0.015 cached input per 1M tokens, so 1M tokens in plus 1M out costs $0.75 [1][2].
• Independent score: Intelligence Index 42 at max reasoning effort, up 13 from M3's 29, at about $0.22 per task against about $0.51 for M3 [2][3].
• The catch: 56% correct answers on AA-Omniscience but a 93% hallucination rate, meaning that when it misses it almost always guesses instead of abstaining [2][3].
• Vendor claims: about 3x faster than M3, above 200 tokens per second at peak, P50 above 170, and 70% lower agent costs, none independently verified [1][4].
• Best fit today: high-volume agent steps a machine can check, with fact-critical answers routed to a stronger model or wrapped in the grounding code below.

What MiniMax Shipped on October 19, 2026

MiniMax Group is the Shanghai company that listed in Hong Kong in January 2026 in an IPO that raised $619 million, and Bloomberg reported that its shares fell after DeepSeek's original V4.1-Flash launched in September [1]. M3.1 Flash is a faster, cheaper update to M3 that MiniMax describes as part of its "ongoing exploration of the balance between efficiency and capability" [6]. Launch-day coverage from SiliconANGLE [1], VentureBeat [2], The Decoder [3] and Unite.ai [4] agrees on the headline facts, MarkTechPost also covered the release [5], and the table below collects what you need for planning.

Two rows deserve a closer look. Reasoning is always on, so there is no non-thinking mode to fall back to, and the five effort levels are your only dial for trading quality against tokens and time [1]. The modality row is where coverage disagrees: SiliconANGLE lists text, image and video input [1], while VentureBeat, The Decoder and Artificial Analysis list text and images [2][3], so plan on image input and treat video as unconfirmed until MiniMax's documentation settles it.

Three smaller conflicts matter before you build on this. DeepSWE v1.1 appears as 73.7%, 74% and 73.67% across SiliconANGLE, the launch post and OpenRouter's relay, which is rounding [1][4]. Open weights are dated October 23 by MiniMax's official post, VentureBeat and The Decoder, while SiliconANGLE says only "later" [1][2][3][6]. And the weights are proprietary at launch with no license terms provided [2], so a self-hosting plan is premature.

The Decoder's headline says China's AI price race has "no floor in sight" [3], and the cost-per-task numbers below suggest the competition is moving from price per token to tokens per task. For the rivals, see our DeepSeek-V4.1-Flash architecture guide and GLM-5.3 guide.

Space Bunny: The Stealth Launch

In late September an anonymous model called Space Bunny appeared on OpenRouter. Community testers linked it to MiniMax by probing its tokenizer, and MiniMax later confirmed it was an early M3.1 Flash build [1]. MiniMax says the stealth model processed more than 200 trillion tokens, while OpenRouter reports 56.7 trillion tokens on its own platform, the most of any stealth model it has hosted, and ten straight days as its number-one model before it left on October 5 and returned on October 19 under its real name [4]. The sources do not reconcile the two totals, and the launch post gives no breakdown [2].

OpenRouter's figures, relayed by Unite.ai, show time to first token falling from 1.95 seconds to 1.22 seconds, throughput rising from 70 to 100 tokens per second, and the error rate halving from 1.4% to 0.7% during the stealth run, with the gains credited to user feedback [4]. Those measure a pre-release build on one router, while 170 and 200 tokens per second are MiniMax's own claims for the launch model, so they are different series. Ten days at number one by tokens is also a demand signal more than an accuracy result.

Architecture: What About 23B Active of 428B Parameters Means

MiniMax's developer guide for the preview puts M3.1 Flash at 428 billion total parameters, and SiliconANGLE says the size has "barely changed" from M3 [1]. M3 was reported with roughly 23 billion active parameters per token, and secondary coverage carries that figure over to Flash. Neither SiliconANGLE nor The Decoder states an active count for Flash [1][3], so I treat 23B as inherited from M3 and not confirmed. If it holds, about 5.4% of the model's weights do work for any given token.

Sparse Experts in One Paragraph

A mixture-of-experts layer replaces one big feed-forward block with many smaller expert blocks plus a learned router that picks a few experts for each token. Shazeer and colleagues' sparsely-gated layer used thousands of feed-forward experts and a trainable gate that selects a sparse combination for each example [11]. The Switch Transformer simplified the routing to one expert per token and reported pre-training speedups of up to 7x at the same compute [10]. Mixtral 8x7B routes each token to two of eight experts per layer, with 47B total parameters and 13B active [12]. That is about 28% active, so a 5.4% active fraction would be roughly five times sparser.

Here is a Wan-style video prompt you can paste into any text-to-video model to make a short explainer of this routing idea for your own audience.

A 10 second animated explainer in a clean pastel flat-illustration style, locked-off front camera, soft even studio light. A wall of several hundred small drawers fills the frame, each with a tiny brass handle. A glowing paper card labeled "token" slides in from the left, a small round router device with a blinking green light inspects it, and about one in twenty drawers slides open and lights up amber while the rest stay closed. The card passes through the lit drawers, drops out the right side as a finished card labeled "next token", and the lit drawers slide shut. Smooth easing, no camera shake, readable short labels only, no extra text, no watermark, no logos.

The Back-of-Envelope Serving Math

Everything in this subsection is my arithmetic, not MiniMax's, because the serving stack is not public. A forward pass costs roughly 2 floating point operations per active parameter per token, ignoring attention, so 23B active parameters is about 46 GFLOPs per token against about 856 GFLOPs if all 428B parameters were dense. That compute saving is the basic reason sparse models can be priced far below dense models of the same total size.

Memory does not shrink the same way. All 428B parameters must stay resident for the router to choose from, which is about 428 GB at 8-bit precision, 856 GB at 16-bit and roughly 214 GB at 4-bit. An eight-GPU node with 80 GB per card holds 640 GB, so 8-bit weights fit with about 210 GB left for KV cache while 16-bit weights do not. Sparse models are therefore cheap per token mainly at high utilization, because deep batches amortize the resident weights and, at large batch sizes, different tokens touch different experts so most weights get read every step anyway.

Where the Speed Comes From

MiniMax attributes the roughly 3x speedup over M3 to "more aggressive" sparsity at inference time [1]. I could not find a source that says whether that means fewer experts per token, a tighter attention budget, or both, and no source I checked describes Flash's attention mechanism, so any specific claim is speculation until the model card appears. Our speculative decoding guide covers a separate serving technique that MiniMax has not said it uses.

Speed claims translate into agent latency in ways that are easy to underestimate. A 2,000-token response takes about 11.8 seconds at 170 tokens per second and 20 seconds at 100, and a 30-step loop generating 500 tokens per step needs about 88 seconds of generation at 170 tokens per second plus roughly 37 seconds of first-token wait at 1.22 seconds per call. Because reasoning is always on, a step that thinks for 1,500 tokens before a 500-token answer takes about four times as long as the visible output suggests, so sweep effort levels instead of leaving the default.

MiniMax's separate H3 line, a 33B omni transformer for video with native audio, is covered in our MiniMax H3 architecture guide.

Pricing: The Rate Card Versus the Cost of a Task

The rate card is $0.15 per million input tokens, $0.60 per million output tokens and $0.015 per million cached input tokens, and OpenRouter listed a free variant for the first 72 hours before moving to the same paid rates [1][4]. A workload of 1M uncached input tokens plus 1M output tokens costs $0.75, which VentureBeat puts next to the rest of the market in the table below [2].

M3.1 Flash is cheap but not the cheapest line in VentureBeat's full table, which lists GPT-6 Luna at $0.60 for the 1M plus 1M workload, MiMo-V2.6-Flash at $0.42 and a Muse Spark Contributor tier at $0.30 [2]. It halves its predecessor's rate card, and DeepSeek V4.1 Flash-1017 matches it only off-peak, with the peak rate exactly double [2]. That is why cost per task is the more useful comparison.

Why a Task Costs $0.22

Artificial Analysis reports cost per task for its Intelligence Index, defined as the weighted average cost in dollars per index task, split by token type [7]. M3.1 Flash comes out at about $0.22 against about $0.51 for M3, a drop of roughly 57% [2]. The table below puts it beside its peers and adds two ratios I computed from the published numbers.

The DeepSeek row shows the mechanism most clearly. Both models list $0.15 and $0.60 off-peak, DeepSeek wrote about 1.19x as many output tokens, and it cost about 1.18x as much per task, which is what you would expect if tokens used drives the difference. GLM-5.3 Flash wrote about 1.7x the tokens but costs only 1.27x, so its price per token must be lower, and Gemini 3.8 Flash wrote about 1.8x the tokens but costs 5.6x, consistent with its $0.75 and $3.75 list price in VentureBeat's table. I lack GLM's list price and Artificial Analysis's exact input and output mix, so treat those two readings as inference.

Two caveats keep this honest. The Index of 42 and the $0.22 are both measured at max reasoning effort [2], and I found no Artificial Analysis numbers for lower effort levels. And MiniMax's own claims use different yardsticks, 70% lower agentic cost and one third of M3's cost [1][4], against the 57% reduction Artificial Analysis measured on its own task mix. Halving the rate card alone gives a 50% cut at identical token counts, so the extra 7 points suggests somewhat fewer tokens per task, though M3's token count is not in the sources I checked.

For software tasks, The Decoder relays MiniMax's DeepSWE v1.1 figure of up to 73.7% at under $0.30 per task [3], which caps the cost per resolved task at about $0.41 ($0.30 divided by 0.737), a vendor-reported upper bound.

A Realistic Daily Workload

Per-task numbers are useful, but your invoice depends on your own mix. Take an agent fleet that sends 40 million input tokens and 4 million output tokens per day, with 80% of the input served from cache. On M3.1 Flash that is 8M fresh input tokens at $0.15 ($1.20), 32M cached tokens at $0.015 ($0.48) and 4M output tokens at $0.60 ($2.40), for $4.08 per day. The calculator below encodes every list price from this post, takes your own volumes as arguments, and bills cached tokens at the full input price wherever a cache price is not listed here, which is the conservative assumption.

python
/code
import argparse
from dataclasses import dataclass


@dataclass(frozen=True)
class Rate:
    name: str
    inp: float                   # USD per 1M input tokens
    out: float                   # USD per 1M output tokens
    cache_read: float | None     # USD per 1M cached input tokens, None if not listed here


# List prices as of October 19 to 20, 2026 (VentureBeat's table, MiniMax's launch pricing,
# and Anthropic's published Haiku 5.5 and Sonnet 5.5 rates). Re-check before you budget.
# Simplification: cache write premiums (Anthropic charges extra to write a cache entry)
# and tokenizer differences between vendors are ignored. Measure real token counts.
RATES = [
    Rate("MiniMax M3.1 Flash", 0.15, 0.60, 0.015),
    Rate("DeepSeek V4.1 Flash-1017 (off-peak)", 0.15, 0.60, None),
    Rate("DeepSeek V4.1 Flash-1017 (peak)", 0.30, 1.20, None),
    Rate("MiniMax M3", 0.30, 1.20, None),
    Rate("GPT-6 Luna", 0.10, 0.50, None),
    # Haiku 5.5 rates apply only while each prompt stays at or under 100K tokens.
    Rate("Claude Haiku 5.5 (prompt <= 100K)", 0.10, 0.50, 0.01),
    Rate("Gemini 3.8 Flash (through Dec 31, 2026)", 0.75, 3.75, None),
    Rate("Gemini 3.8 Flash (from Jan 1, 2027)", 1.50, 7.50, None),
    Rate("Claude Sonnet 5.5", 2.00, 10.00, 0.10),
    Rate("GPT-6 Sol", 2.00, 10.00, None),
    Rate("Claude Opus 5.5", 4.00, 20.00, None),
]


def daily_cost(rate: Rate, input_m: float, output_m: float, hit_rate: float) -> tuple[float, float]:
    """Return (cost with no caching, cost with caching) in USD for one day.
    Where no cache price is listed, cached tokens are billed at the full input price,
    which is the conservative assumption."""
    uncached = input_m * rate.inp + output_m * rate.out
    cache_price = rate.cache_read if rate.cache_read is not None else rate.inp
    cached = (
        input_m * (1 - hit_rate) * rate.inp
        + input_m * hit_rate * cache_price
        + output_m * rate.out
    )
    return uncached, cached


def main() -> None:
    ap = argparse.ArgumentParser(description="Compare daily agent cost across list prices.")
    ap.add_argument("--input-m", type=float, default=40.0, help="input tokens per day, millions")
    ap.add_argument("--output-m", type=float, default=4.0, help="output tokens per day, millions")
    ap.add_argument("--hit-rate", type=float, default=0.8, help="cache hit share of input tokens")
    ap.add_argument("--days", type=int, default=30)
    args = ap.parse_args()

    base_uncached, base_cached = daily_cost(RATES[0], args.input_m, args.output_m, args.hit_rate)
    print(f"{args.input_m:g}M in / {args.output_m:g}M out per day, {args.hit_rate:.0%} cache hits")
    print(f"{'model':<42}{'no cache/day':>14}{'cached/day':>12}{'per month':>12}{'vs M3.1 Flash':>15}")
    for r in RATES:
        uncached, cached = daily_cost(r, args.input_m, args.output_m, args.hit_rate)
        note = "" if r.cache_read is not None else " *"
        print(
            f"{r.name:<42}{uncached:>14.2f}{cached:>12.2f}{cached * args.days:>12.2f}"
            f"{cached / base_cached:>14.1f}x{note}"
        )
    print("* no cache price listed here, so cached tokens are billed at the full input rate")


if __name__ == "__main__":
    main()

Running it with the defaults gives the following, where an asterisk marks rows with no cache price, billed at the full input rate.

Three results stand out. Caching cuts the M3.1 Flash bill from $8.40 to $4.08 per day, a 51% drop, so a stable prompt prefix is worth engineering for. Claude Haiku 5.5 comes out cheaper at $3.12 per day on this rate card, before its cache write premium and a tokenizer that our Claude Haiku 5.5 guide reports counts about 30% more tokens than its predecessor, and with a fivefold price jump above 100K-token prompts. And Sonnet 5.5 at $59.20 is about 14.5x the M3.1 Flash bill, the gap a router has to earn back; our Claude Sonnet 5.5 guide and GPT-6 Sol and Luna guide cover those price points.

Benchmarks: Independent Numbers First, Vendor Numbers Second

What Artificial Analysis Measured

Artificial Analysis's Intelligence Index, in the version shown on its site when I checked, combines ten evaluations including Humanity's Last Exam, CritPt, AA-Omniscience, Terminal-Bench 4.0, SciCode and several agentic and long-context suites [7]. M3.1 Flash scores 42 at max reasoning effort, up 13 points from M3's 29, which ties GLM-5.3 Flash, edges Gemini 3.8 Flash at 41, and trails DeepSeek V4.1 Flash-1017 at 45 [2][3]. VentureBeat adds that it still trails the strongest Anthropic and OpenAI models [2].

Humanity's Last Exam is a closed-ended academic benchmark of 2,500 expert-written questions across dozens of subjects [14], and M3.1 Flash's 48% is five points above DeepSeek's 43% and level with Gemini 3.8 Flash [2]. CritPt is a set of 71 research-level physics problems [3], where the jump from 4% to 22% is large in relative terms but still means roughly four out of five problems fail, and DeepSeek holds a narrow lead at 24% [2].

There is a tension in these numbers. M3.1 Flash beats DeepSeek on Humanity's Last Exam and on Omniscience accuracy (56% versus 43%) yet trails it on the aggregate Index. Launch coverage lists scores for only a few of the ten component evaluations, so I cannot say which ones pull Flash down, but the pattern fits a model that is strong at hard recall and weaker somewhere in the agentic or long-context mix.

What MiniMax Reports About Itself

The agentic benchmarks in the launch post are MiniMax-reported and have not been independently verified [1][2]. They are still informative, partly because MiniMax's own table includes a result where a rival is ahead.

Read DeepSWE first, because most developers care about it: M3.1 Flash at 73.7% sits within a point of Claude Opus 5 and GPT-5.6 Sol but four points under DeepSeek V4.1-Flash, whose own 77% is also unverified [1]. The 61.7 on OSWorld carries two names, OSWorld 2.0 in VentureBeat and OSWorld V2 in SiliconANGLE [1][2]. The original OSWorld paper defined the benchmark of open-ended tasks in real computer environments [15], and our OSWorld 2.0 explainer covers the newer hour-long-task version, so confirm the harness before comparing 61.7 with numbers in that post.

I use vendor tables only to build a shortlist, since VentureBeat notes that evaluation settings differ between results [2] and a 50 to 100 task evaluation from your own tickets tells you more than a one-point leaderboard gap.

The 93% Hallucination Problem

What AA-Omniscience Actually Measures

AA-Omniscience contains 6,000 questions across six domains and 42 topics [7], and it reports three easily confused numbers. Accuracy is correct answers divided by all questions. The hallucination rate is incorrect answers divided by all non-correct responses, meaning incorrect over the sum of incorrect, partial and not attempted. The Omniscience Index runs from -100 to 100, rewards correct answers, penalizes hallucinations, and carries no penalty for refusing to answer [7].

Now apply the definitions to M3.1 Flash's published numbers. Out of every 100 questions it answers 56 correctly, which leaves 44 non-correct responses. A 93% hallucination rate means about 41 of those 44 were confident wrong answers and only about 3 were abstentions or partial answers. The Index then lands near 56 minus 41, which is 15, and Artificial Analysis reports 16 [2][3], close enough that rounding explains the gap. Artificial Analysis does not publish the exact formula on the page I read, so that check is my inference from the stated scale, but it hangs together.

VentureBeat points out that the figure does not mean 93% of all answers were wrong, because 56% were right [2]. It describes behavior on the questions the model could not answer: M3.1 Flash attempted nearly every question and, when wrong, "overwhelmingly chose to give an incorrect one" instead of abstaining [2][3]. The calibrated alternative in the table keeps 56% accuracy but abstains on most misses, cutting the hallucination rate to about 23% and lifting the Index from 15 to 46. It is hypothetical, but it shows how much of the score depends on knowing when to stop.

The launch coverage gives DeepSeek V4.1 Flash-1017's and GLM-5.3 Flash's Omniscience accuracy (43% and 28%) but not their hallucination rates [2], so I will not claim M3.1 Flash is better or worse than them on this axis.

Why Models Behave This Way

OpenAI researchers argue in "Why Language Models Hallucinate" that models guess because training and evaluation reward guessing over admitting uncertainty, like a student who should always guess on an exam with no penalty for wrong answers [13]. Most leaderboards score accuracy only, so an abstention earns the same zero as a wrong answer, while AA-Omniscience penalizes confident errors. M3.1 Flash behaves like a model tuned against accuracy-only grading, though that is my inference because MiniMax has not published its training recipe.

Why It Matters for Agents and RAG

For agents, the damage depends on whether anything downstream can catch a wrong answer. Code that must pass tests, SQL that must run against a schema, JSON that must validate, and classifiers with a fixed label set all let a machine reject bad output, and those are good homes for a cheap model with a guessing habit. A MindStudio hands-on of the preview shows the failure shape to expect elsewhere: in a drone-planning JSON task the output was valid and the model read the 18% battery level, chose the marked landing pad and flagged a power line, but it put a wire to the left of the flight path when it actually crossed the road and skipped a hover or ascend step, while in a six-join SQL debugging task it quickly found an inclusive date-range condition that double counted boundary dates [9]. That is one tester on a preview build, but valid structure with confident small errors is what a high hallucination rate predicts.

For retrieval-augmented generation [16], the failure is quieter: when retrieval returns nothing relevant, a model that prefers answering to abstaining fills the gap from memory, and the user gets a fluent answer with nothing under it. Our guide to building a RAG system from scratch covers retrieval, the grounding wrapper below covers the other half, and our piece on why 88 percent of AI agents fail says to fix the harness before blaming the model.

Measure Your Own Rate in an Afternoon

Public numbers only give you a prior for your own data. Build 100 questions where 30 to 40 are deliberately unanswerable from your corpus, grade each response as correct, incorrect, partial or abstained, and score it with the snippet below. The unanswerable slice matters most, because a model that abstains there is safe behind your retrieval and one that answers is not.

python
/code
from collections import Counter

VALID = {"correct", "incorrect", "partial", "abstained"}


def omniscience_style_metrics(grades: list[str]) -> dict:
    """Score a list of graded answers the way Artificial Analysis describes AA-Omniscience.

    Each grade is one of: correct, incorrect, partial, abstained.
      accuracy            = correct / all questions
      hallucination_rate  = incorrect / (incorrect + partial + abstained)
      attempt_rate        = share of questions where the model gave any answer
      index (approx.)     = 100 * (correct - incorrect) / all questions
                            (+1 correct, -1 incorrect, 0 abstained; my approximation of
                            the published -100 to 100 scale, not AA's exact formula)
    """
    bad = set(grades) - VALID
    if bad:
        raise ValueError(f"unknown grades: {bad}")
    n = len(grades)
    c = Counter(grades)
    non_correct = n - c["correct"]
    return {
        "n": n,
        "accuracy": c["correct"] / n,
        "hallucination_rate": c["incorrect"] / non_correct if non_correct else 0.0,
        "attempt_rate": (n - c["abstained"]) / n,
        "index": 100 * (c["correct"] - c["incorrect"]) / n,
    }


if __name__ == "__main__":
    # Per 100 questions, using the published 56% accuracy and 93% hallucination rate:
    # 44 non-correct answers, of which about 41 are wrong and about 3 are abstentions.
    published_shape = ["correct"] * 56 + ["incorrect"] * 41 + ["abstained"] * 3
    m = omniscience_style_metrics(published_shape)
    print({k: round(v, 3) for k, v in m.items()})

    # Same accuracy, but the model abstains on most of the questions it would have missed.
    calibrated = ["correct"] * 56 + ["incorrect"] * 10 + ["abstained"] * 34
    m = omniscience_style_metrics(calibrated)
    print({k: round(v, 3) for k, v in m.items()})

Prompt-level fixes such as "say I don't know if unsure" may help, but I have no data on how far they move this model, so run the meter before and after.

Step 1: Call M3.1 Flash Through OpenRouter in Python

OpenRouter exposes the model as minimax/minimax-m3.1-flash through its Chat Completions endpoint at https://openrouter.ai/api/v1/chat/completions, with a free variant at minimax/minimax-m3.1-flash:free [8]. The model page lists stream, max_tokens, reasoning, reasoning_effort, response_format, temperature, tool_choice, tools and top_p as supported parameters, and documents 401, 402, 429 and 502 errors, with failed generations not billed [8].

The script below uses the OpenAI Python SDK pointed at OpenRouter, reads the key from the OPENROUTER_API_KEY environment variable, prints token usage and cost per call, and includes a streaming function that reports time to first token and rough tokens per second so you can check the vendor speed claims yourself.

python
/code
# pip install openai
import os
import time

from openai import OpenAI

# The key comes from the environment. Never hard-code it or commit it.
client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key=os.environ["OPENROUTER_API_KEY"],
)

MODEL = "minimax/minimax-m3.1-flash"
# Free launch variant (the free window was announced as 72 hours; check the model page for limits):
# MODEL = "minimax/minimax-m3.1-flash:free"


def ask(prompt: str, effort: str = "low", max_tokens: int = 4096) -> str:
    """One non-streaming call. Reasoning is always on, so max_tokens must leave
    room for hidden reasoning tokens as well as the visible answer."""
    started = time.perf_counter()
    resp = client.chat.completions.create(
        model=MODEL,
        messages=[
            {"role": "system", "content": "Answer concisely. If you are not sure, say so."},
            {"role": "user", "content": prompt},
        ],
        max_tokens=max_tokens,
        # OpenRouter lists reasoning and reasoning_effort as supported parameters for this
        # model. MiniMax exposes five levels (Low to Max); confirm the accepted values on
        # the model page before relying on anything beyond low, medium and high.
        extra_body={"reasoning": {"effort": effort}},
    )
    elapsed = time.perf_counter() - started
    usage = resp.usage
    print(
        f"effort={effort} prompt_tokens={usage.prompt_tokens} "
        f"completion_tokens={usage.completion_tokens} "
        f"cost={getattr(usage, 'cost', 'n/a')} wall={elapsed:.2f}s"
    )
    return resp.choices[0].message.content or ""


def measure_speed(prompt: str, effort: str = "low", max_tokens: int = 2048) -> None:
    """Streaming call that reports time to first token and rough tokens per second,
    so you can check the vendor speed claims on your own prompts."""
    started = time.perf_counter()
    first = None
    completion_tokens = None
    stream = client.chat.completions.create(
        model=MODEL,
        messages=[{"role": "user", "content": prompt}],
        max_tokens=max_tokens,
        stream=True,
        stream_options={"include_usage": True},
        extra_body={"reasoning": {"effort": effort}},
    )
    for chunk in stream:
        if chunk.usage is not None:
            completion_tokens = chunk.usage.completion_tokens
        if not chunk.choices:
            continue
        delta = chunk.choices[0].delta
        # Reasoning tokens may stream in a separate field before the visible text.
        if first is None and (delta.content or getattr(delta, "reasoning", None)):
            first = time.perf_counter()
    done = time.perf_counter()
    if first is None or not completion_tokens:
        print("No tokens or usage received; check the provider response.")
        return
    gen_time = max(done - first, 1e-6)
    print(
        f"time_to_first_token={first - started:.2f}s "
        f"completion_tokens={completion_tokens} "
        f"approx_tokens_per_second={completion_tokens / gen_time:.0f}"
    )


if __name__ == "__main__":
    print(ask("In two sentences, what is a mixture-of-experts language model?"))
    measure_speed("Write a 300-word explanation of KV caching.")

Two details matter more than they look. Reasoning is always on, so max_tokens must cover hidden reasoning plus the visible answer, and a limit that is too small can return truncated or empty content. The effort level is also your main cost control: the Index of 42 was measured at max effort [2], and MindStudio reports effort can be changed mid-session in the preview tooling [9]. The sweep method in our Claude Haiku 5.5 guide works for any model with an effort setting: run the same 50 tasks at each level, record accuracy, tokens and cost, and pick the cheapest level within a couple of points of the top.

Step 2: The Same Call With curl, and the First-Party API

If you want to see the raw request before wrapping it in a client library, this curl call sends the same payload, reads the key from the environment, and uses jq to print the answer and usage.

bash
/code
# Requires curl and jq. The key is read from the environment, never typed into the command.
: "${OPENROUTER_API_KEY:?Set OPENROUTER_API_KEY first}"

curl -sS https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "minimax/minimax-m3.1-flash",
    "max_tokens": 4096,
    "reasoning": { "effort": "low" },
    "messages": [
      {
        "role": "system",
        "content": "Answer from your own knowledge only if you are sure. Otherwise reply exactly: I do not know."
      },
      {
        "role": "user",
        "content": "Which year was the Switch Transformer paper first posted to arXiv?"
      }
    ]
  }' | jq '{answer: .choices[0].message.content, usage: .usage}'

# Free variant: change the model to "minimax/minimax-m3.1-flash:free".
# Error codes documented on the model page: 401 bad key, 402 no credits, 429 rate limited.

MiniMax's own channels are the API at platform.minimax.io, the M Plan subscription and the MiniMax Code desktop app [1][3]. The first-party model id is reported as MiniMax-M3.1-Flash, and the API is reported to be compatible with both OpenAI and Anthropic client formats, but I did not verify base URLs, so confirm the endpoint and model id in MiniMax's documentation before leaving OpenRouter. OpenRouter is a sensible start because one key lets you compare models without new integrations, though its page notes that EU in-region routing is not currently available for this model [8], which matters for data residency.

Step 3: Add a Grounding and Abstain Layer

The most direct mitigation for a model that prefers to answer is to take the choice away from it. The wrapper below puts four gates in front of any answer. A deterministic support gate drops passages that share too few key terms with the question and skips the model call when nothing relevant remains. The answer call must return a cited source id and a quote copied word for word from that source, and a plain string check rejects the answer if the quote is not in the source. A verifier pass then checks the whole answer against the passages, and any failure returns "I don't know" with a machine-readable reason.

python
/code
# Save as grounding.py. pip install openai
import json
import os
import re
from dataclasses import dataclass

from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key=os.environ["OPENROUTER_API_KEY"],  # read from env, never hard-coded
)

WORKER = "minimax/minimax-m3.1-flash"
# For fact-critical paths, point this at a stronger model's OpenRouter id.
VERIFIER = os.environ.get("VERIFIER_MODEL", WORKER)

IDK = "I don't know based on the sources I was given."

STOPWORDS = {
    "what", "which", "when", "where", "who", "whom", "does", "have", "has", "that", "this",
    "with", "from", "about", "into", "their", "there", "than", "then", "will", "would",
    "could", "should", "your", "the", "and", "for", "are", "was", "were", "how", "much",
}


@dataclass
class Passage:
    id: str
    text: str


def content_words(text: str) -> set[str]:
    words = re.findall(r"[a-z0-9$%.\-]+", text.lower())
    return {w.strip(".-") for w in words if len(w) > 3 and w not in STOPWORDS}


def support_gate(question: str, passages: list[Passage], min_overlap: float = 0.5) -> list[Passage]:
    """Deterministic first gate: keep only passages that share enough key terms with the
    question. Replace this with your retriever's similarity score if it has one."""
    q = content_words(question)
    if not q:
        return []
    return [p for p in passages if len(q & content_words(p.text)) / len(q) >= min_overlap]


def parse_json(raw: str) -> dict:
    try:
        return json.loads(raw)
    except json.JSONDecodeError:
        start, end = raw.find("{"), raw.rfind("}")
        if start != -1 and end > start:
            try:
                return json.loads(raw[start : end + 1])
            except json.JSONDecodeError:
                pass
    return {}


def chat_json(model: str, system: str, user: str, max_tokens: int = 3000) -> dict:
    resp = client.chat.completions.create(
        model=model,
        messages=[{"role": "system", "content": system}, {"role": "user", "content": user}],
        max_tokens=max_tokens,  # reasoning tokens count too, so leave headroom
        temperature=0,
        response_format={"type": "json_object"},
    )
    return parse_json(resp.choices[0].message.content or "")


ANSWER_SYSTEM = (
    "Answer the question using ONLY the numbered sources. Reply with JSON: "
    '{"answer": string or null, "source_id": string or null, "quote": string or null}. '
    "The quote must be copied word for word from the cited source. If the sources do not "
    "contain the answer, return null for all three fields. Never use outside knowledge."
)

VERIFY_SYSTEM = (
    "You check answers against sources. Reply with JSON: "
    '{"supported": true or false, "unsupported_claims": [string]}. '
    "supported is true only if every factual claim in the answer is stated in the sources."
)


def norm(s: str) -> str:
    return re.sub(r"\s+", " ", s).strip().lower()


def render(passages: list[Passage]) -> str:
    return "\n\n".join(f"[{p.id}] {p.text}" for p in passages)


def grounded_answer(
    question: str, passages: list[Passage], worker: str = WORKER, verifier: str = VERIFIER
) -> dict:
    # Gate 1: no relevant evidence means no model call at all.
    kept = support_gate(question, passages)
    if not kept:
        return {"status": "abstained", "reason": "no_support", "answer": IDK}

    # Gate 2: answer with a verbatim quote, or return null.
    draft = chat_json(worker, ANSWER_SYSTEM, f"Sources:\n{render(kept)}\n\nQuestion: {question}")
    if not draft.get("answer"):
        return {"status": "abstained", "reason": "model_abstained", "answer": IDK}

    # Gate 3: the cited source must exist and must really contain the quote.
    cited = next((p for p in kept if p.id == draft.get("source_id")), None)
    quote = draft.get("quote") or ""
    if cited is None or not quote or norm(quote) not in norm(cited.text):
        return {"status": "abstained", "reason": "quote_not_verbatim", "answer": IDK}

    # Gate 4: a second pass checks the full answer, not just the quoted span.
    verdict = chat_json(
        verifier,
        VERIFY_SYSTEM,
        f"Sources:\n{render(kept)}\n\nQuestion: {question}\n\nAnswer: {draft['answer']}",
    )
    if verdict.get("supported") is not True:
        return {
            "status": "abstained",
            "reason": "verifier_rejected",
            "answer": IDK,
            "unsupported": verdict.get("unsupported_claims", []),
        }

    return {
        "status": "answered",
        "answer": draft["answer"],
        "source_id": cited.id,
        "quote": quote,
    }


if __name__ == "__main__":
    docs = [
        Passage("s1", "MiniMax M3.1 Flash is priced at $0.15 per 1M input tokens and $0.60 per 1M output tokens."),
        Passage("s2", "Cached input tokens cost $0.015 per 1M tokens, and the context window is 1,000,000 tokens."),
    ]
    for q in ("What does M3.1 Flash cost per 1M output tokens?",
              "What license will the M3.1 Flash open weights use?"):
        print(q, "->", json.dumps(grounded_answer(q, docs), indent=2))

The design borrows from Chain-of-Verification, where a model drafts an answer, plans verification questions, answers them independently and then writes a checked final response [17], but it makes the cheapest checks deterministic. The quote check proves the quoted words exist in the source, which a model cannot talk its way past, while the verifier pass catches an answer that quotes accurately and then claims more than the quote supports. Neither gate guarantees truth, since your passages can be wrong.

The cost is small at these rates. A call with 3,000 input tokens and 500 output tokens costs about $0.00075 at list price ($0.00045 input plus $0.0003 output), so the answer call plus the verifier call cost about 0.15 cents per question before reasoning tokens, which I would expect on the output side of the bill, so check usage.completion_tokens on your own calls. Pointing VERIFIER_MODEL at a stronger model gives you an independent judge, the better choice when the answer reaches a customer.

Step 4: Route Cheap Steps and Fact-Critical Answers Separately

A router turns the cost gap from the daily workload table into savings. Send steps where mistakes are cheap to detect or retry, such as planning, tool calls, browsing, field extraction and format conversion, to M3.1 Flash, and send steps where a confident wrong answer reaches a user or a record, such as final answers, citations and compliance statements, through the grounded path with a stronger model as the escalation target. Our model routing guide covers production routers like NVIDIA NeMo Switchyard and Runway's model router.

python
/code
# Save next to grounding.py. Set STRONG_MODEL to the OpenRouter id of the stronger model
# you trust for fact-critical answers (copy the exact slug from OpenRouter's model list).
import os
from dataclasses import dataclass, field

from grounding import Passage, client, grounded_answer

CHEAP = "minimax/minimax-m3.1-flash"
STRONG = os.environ["STRONG_MODEL"]

# Step kinds where a wrong guess is cheap to detect or retry (tools, formats, plans).
CHEAP_KINDS = {"plan", "tool_call", "browse", "extract_fields", "transform"}
# Step kinds where a confident wrong answer reaches a user or a record.
FACT_KINDS = {"final_answer", "citation", "compliance", "pricing_claim"}


@dataclass
class Step:
    kind: str
    prompt: str
    passages: list[Passage] = field(default_factory=list)


def plain_call(model: str, prompt: str, max_tokens: int = 3000) -> str:
    resp = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        max_tokens=max_tokens,  # reasoning tokens count toward this limit
    )
    return resp.choices[0].message.content or ""


def run(step: Step) -> dict:
    if step.kind in CHEAP_KINDS:
        return {"status": "answered", "answer": plain_call(CHEAP, step.prompt), "model": CHEAP}

    if step.kind in FACT_KINDS and step.passages:
        # 1) Cheap model first, with every grounding gate switched on.
        first = grounded_answer(step.prompt, step.passages)
        if first["status"] == "answered":
            return {**first, "model": CHEAP}
        # 2) Escalate only when evidence exists but the cheap path could not use it safely.
        #    With no supporting passages a stronger model has nothing more to ground on.
        if first["reason"] != "no_support":
            second = grounded_answer(step.prompt, step.passages, worker=STRONG, verifier=STRONG)
            return {**second, "model": STRONG}
        return {**first, "model": None}

    # Closed-book or unknown step kinds fail safe toward the stronger model.
    return {"status": "answered", "answer": plain_call(STRONG, step.prompt), "model": STRONG}


if __name__ == "__main__":
    steps = [
        Step("plan", "List the three API calls needed to fetch a user's invoices, as a numbered list."),
        Step(
            "pricing_claim",
            "What does M3.1 Flash cost per 1M output tokens?",
            [Passage("s1", "M3.1 Flash costs $0.15 per 1M input tokens and $0.60 per 1M output tokens.")],
        ),
    ]
    for s in steps:
        print(s.kind, "->", run(s))

Two design choices are deliberate. Unknown step kinds fail safe toward the stronger model, and escalation happens only when evidence exists but the cheap path could not use it safely, because a stronger model with no supporting passages has nothing to ground on and should abstain too.

The savings are easy to estimate. Suppose, hypothetically, that 85% of your daily tokens (34M input and 3.4M output of the earlier 40M and 4M) belong to cheap-eligible steps and 15% (6M input, 0.6M output) go to Claude Sonnet 5.5 uncached. That is $7.14 on M3.1 Flash plus $18.00 on Sonnet, or $25.14 per day, against $120 for all-Sonnet and $8.40 for all-Flash, both uncached. The routed bill is about 79% below all-Sonnet and about three times all-Flash, and the extra spend buys a stronger model exactly where a hallucination does damage. Measure your own split first.

Decision Guide: M3.1 Flash, DeepSeek V4.1 Flash-1017, Claude, or Gemini 3.8 Flash

No single model wins every column, so the table ties each option to a situation, using only numbers from this post and the linked guides.

A few rules follow from it. For verifiable, high-volume steps, M3.1 Flash and DeepSeek V4.1 Flash-1017 are the natural pair to test head to head: DeepSeek has the higher Index and weights already on Hugging Face [3], while M3.1 Flash has the higher Humanity's Last Exam score and the lower cost per task. If you already run on Anthropic, Haiku 5.5 under a Sonnet 5.5 orchestrator is the lowest-friction version of the same architecture. Gemini 3.8 Flash costs about 5.6x more per task on Artificial Analysis and its list price rises on January 1, 2027 [2]; see our Gemini 3.8 Flash guide. Do not pick on an Index gap of three points, because a different task mix can reverse it.

Common Mistakes When Adopting a Cheap Agent Model

Comparing rate cards instead of cost per task. A cheaper token that writes more tokens can lose, as the GLM and Gemini rows show, so measure tokens per completed task on your own work.

Reading 93% as the share of wrong answers. It is the share of non-correct responses that were wrong, and at 56% accuracy most answers are right.

Trusting vendor agent benchmarks without a local run. The DeepSWE, OSWorld and BankerToolBench figures are MiniMax-reported, and a harness mismatch can move a score by more than the gaps between models.

Using the free variant in production. The free window was announced as 72 hours [4], and the model page does not state numeric rate limits [8].

Planning around open weights before the license exists. The weights are dated October 23 in some sources and "later" in others, with no license published at launch [2].

A Production Checklist

• Log prompt_tokens, completion_tokens and cost per call, then aggregate per task so you track cost per task and not only spend per day.
• Put a stable system prompt and tool definitions at the front of every request so the $0.015 cached-input rate applies to the bulk of your input.
• Retry 429 and 502 responses with exponential backoff, and note that failed generations are not billed [8].
• Keep a small unanswerable-question set in CI, re-run it whenever the prompt or model changes, and fail the build if the hallucination rate rises.
• Review abstain reasons weekly, since a rising no_support count usually points to retrieval and not the model.
• Check data-handling terms with your legal team before sending customer data to any model provider, whichever route you use.

Where This Fits in a Content Pipeline

A cheap model with a large context window suits the unglamorous parts of a creator workflow: turning a transcript into chapter titles, tagging a library of clips, drafting metadata variants, or reformatting one script for several platforms. Those outputs are checkable, which is where hallucination risk is smallest, while fact-bearing claims such as a benchmark number in a video script should pass through the grounding path or a stronger model first. Once the script is ready, Miraflow covers the visual side in one place, with Text2Shorts for vertical videos, the AI image generator for explainer graphics such as the sparse routing diagram described earlier, and AI Clipping for turning a long walkthrough into scored shorts.

What to Watch Next

Four things will change this picture within weeks. The open weights and license, dated October 23 by MiniMax's official post [6], will settle whether you can self-host and on what terms. The more capable Pro model has no date [1]. Artificial Analysis may publish lower-effort scores, which would show whether the $0.22 per task falls faster than the score. And independent hallucination rates for DeepSeek V4.1 Flash-1017 and GLM-5.3 Flash would finally put the 93% in context.

Frequently Asked Questions

What is MiniMax M3.1 Flash?

It is a multimodal mixture-of-experts model from MiniMax Group, released on October 19, 2026 as a faster and cheaper update to M3, with a 1,000,000-token context window, always-on reasoning with five effort levels, and text output [1].

How much does MiniMax M3.1 Flash cost?

It costs $0.15 per million input tokens, $0.60 per million output tokens and $0.015 per million cached input tokens, so 1M tokens in plus 1M out comes to $0.75 [1][2]. OpenRouter offered a free variant for 72 hours after launch and then moved to the same rates [4].

What does the 93% hallucination rate mean?

It is the share of non-correct responses on AA-Omniscience that were outright wrong instead of abstentions or partial answers, not the share of all answers that were wrong. M3.1 Flash answered 56% correctly and attempted almost every question, so most of its misses were confident errors [2][7].

Is MiniMax M3.1 Flash open source?

Not at launch. Weights were proprietary at release, MiniMax's official post says open weights arrive October 23, other reports say only "later", and no license has been published [1][2][6]. Check Hugging Face and the license text before relying on it.

How does it compare with DeepSeek V4.1 Flash-1017?

DeepSeek scores higher on the Intelligence Index (45 versus 42) and on CritPt (24% versus 22%), while M3.1 Flash is ahead on Humanity's Last Exam (48% versus 43%), on Omniscience accuracy (56% versus 43%) and on cost per task ($0.22 versus $0.26) [2][3].

What is the OpenRouter model id, and is it free?

The id is minimax/minimax-m3.1-flash, with a free variant at minimax/minimax-m3.1-flash:free [8]. The free promotion was announced for 72 hours, so check the model page for current pricing [4].

Was Space Bunny really M3.1 Flash?

Yes. Community testers linked the stealth model to MiniMax through its tokenizer, and MiniMax confirmed it was an early M3.1 Flash build [1].

Does M3.1 Flash accept video input?

Sources disagree. SiliconANGLE lists text, image and video input, while VentureBeat, The Decoder and Artificial Analysis list text and images [1][2][3]. Confirm in MiniMax's documentation before building on video.

Should I use it for RAG?

Only with an abstain layer. Its accuracy is competitive, but a model that guesses on nearly every miss will fill retrieval gaps from memory, so require a verbatim supporting quote and a verifier pass, as in the grounding code above.

Conclusion

MiniMax M3.1 Flash is a real step forward for cheap agent models: an Intelligence Index of 42 at about $0.22 per task, a $0.75 price for 1M tokens in and out, a 1M-token context window, and a strong showing on Humanity's Last Exam, all from a sparse model that MiniMax says runs near three times faster than its predecessor. The same independent evaluator also shows its weakness, a 93% hallucination rate that means it would rather guess than say it does not know.

The practical takeaway is to use it where wrong answers are cheap to catch and to wrap or reroute it where they are not. Put it on tool-heavy, verifiable steps, measure cost per task and not cost per token, sweep effort levels, keep a set of unanswerable questions in your tests, require verbatim support before any factual answer, and send fact-critical responses to a stronger model. For the models you will compare it against, read our guides to DeepSeek-V4.1-Flash, Claude Haiku 5.5 and Gemini 3.8 Flash.

References

1. [1] MiniMax launches M3.1 Flash model, says it cuts AI agent costs by 70%, SiliconANGLE
2. [2] 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
3. [3] MiniMax M3.1 Flash shows China's AI price race has no floor in sight, The Decoder
4. [4] MiniMax launches M3.1 Flash, revealing Space Bunny stealth model, Unite.ai
5. [5] MiniMax M3.1 Flash release, MarkTechPost
6. [6] Official MiniMax announcement of M3.1 Flash, MiniMax on X
7. [7] Artificial Analysis, Intelligence Index and AA-Omniscience methodology
8. [8] MiniMax M3.1 Flash (free), OpenRouter
9. [9] MiniMax M3.1 Flash and M-Code hands-on, MindStudio
10. [10] Switch Transformers: Scaling to Trillion Parameter Models with Simple and Efficient Sparsity, Fedus, Zoph and Shazeer, arXiv 2101.03961
11. [11] Outrageously Large Neural Networks: The Sparsely-Gated Mixture-of-Experts Layer, Shazeer et al., arXiv 1701.06538
12. [12] Mixtral of Experts, Jiang et al., arXiv 2401.04088
13. [13] Why Language Models Hallucinate, Kalai et al., arXiv 2509.04664
14. [14] Humanity's Last Exam, arXiv 2501.14249
15. [15] OSWorld: Benchmarking Multimodal Agents for Open-Ended Tasks in Real Computer Environments, arXiv 2404.07972
16. [16] Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks, Lewis et al., arXiv 2005.11401
17. [17] Chain-of-Verification Reduces Hallucination in Large Language Models, Dhuliawala et al., arXiv 2309.11495