Tolz.me
AI ModelsMiniMaxLLMCost

MiniMax M3.1 Flash: What's New, What It Costs, and What the Benchmarks Do and Don't Tell You

MiniMax claims faster inference and a 70% lower agent cost for M3.1 Flash. Here is the price math and how to test a model on your own work.

Tolz.me team8 min read
Illustration of a glowing AI processor chip on a circuit board

MiniMax announced M3.1 Flash on October 19, 2026. The announcement leads with speed and price: nearly three times faster online inference, and 70% lower usage cost for agentic tasks than the previous model. The release drew a busy Hacker News discussion.

What MiniMax says changed

  • An early version of the model ran anonymously under the name "Space Bunny". MiniMax says that version processed more than 200 trillion tokens.
  • Online inference is nearly 3x faster than the predecessor.
  • Usage cost on agentic tasks is 70% lower.
  • Output speed runs at 200+ tokens per second, with a median of 170+.
  • The model is available through the MiniMax API, the M Plan, and MiniMax Code.
  • Weights will be released later, and a Pro model is planned for later still.

That last pair deserves attention. Open weights and a Pro tier are both on the roadmap rather than available today. If you need to self-host now, the wait is part of the product, not an afterthought.

The price list

Per one million tokens, as published by MiniMax:

  • Input: $0.15
  • Output: $0.60
  • Cached input: $0.015

Output costs four times input, which is normal for the industry and worth noticing if your workload generates a lot of tokens. The cached input rate is a tenth of the input rate. Both numbers matter, and the second one matters more than most people expect.

The cost math on one agent run

Here is a concrete shape: an agent session that sends 2 million input tokens and returns 500 thousand output tokens.

Input:   2,000,000 tokens x $0.15 / 1M = $0.30
Output:    500,000 tokens x $0.60 / 1M = $0.30
Total:                                       $0.60

Sixty cents for a session that pushed 2.5 million tokens through it. If the 2 million input tokens are served from cache instead, the same session costs:

Cached input: 2,000,000 tokens x $0.015 / 1M = $0.03
Output:         500,000 tokens x $0.60 / 1M = $0.30
Total:                                            $0.33

Now scale it up. A thousand sessions like that in a month comes to $600, or $330 if the input is cached. If your agent loops and re-sends the same context on every turn, caching is the difference between a bill you notice and a bill you do not.

Cost per finished task is the number that counts

The 60 cents is per session, not per result. An agent that needs five attempts to finish one task has spent $3.00 on that task, and the gap between two models on price is often smaller than the gap in attempt count.

This is why cost per finished task is the metric to track. A model at half the price that takes twice as many attempts is the expensive one.

What the benchmarks do and don't tell you

MiniMax published five scores with the announcement. The short labels below say what each benchmark name refers to. The scores are MiniMax's:

  • BankerToolBench: 76.2, a tool-use result built around finance tasks.
  • DeepSWE v1.1: 73.7%, a software-engineering agent result.
  • OSWorld V2: 61.7, an operating system and computer-use result.
  • Agents' Last Exam (ALE): 29.6, which MiniMax describes as testing real professional work and complex tasks, and the lowest score on the list.
  • CyberGym: 82%, a security result.

Two things to keep straight about that list. First, the numbers are vendor-reported. Second, a score does not carry its own methodology. You cannot rerun these from a blog post, because the harness, the prompts, and the scoring rules live with whoever ran them.

MiniMax also says the model ranks first among Chinese models on OSWorld V2 and on ALE. That is a narrower claim than topping those benchmarks overall, and it comes from the same source as the scores.

What the list is good for is showing where to look. CyberGym at 82% and BankerToolBench at 76.2 sit next to ALE at 29.6. A model can do well on a targeted benchmark and still be far from dependable on open-ended agent work, where the goal is ambiguous and the task runs for many steps. If that is your use case, the low score on the hardest evaluation is the number to read twice.

Why two vendors' scores rarely line up

Scores from different announcements are rarely comparable, even when they name the same benchmark. Each lab runs the suite inside its own harness, with its own agent scaffolding, its own retry policy, and its own version of the task set. A model that scores higher on one leaderboard and lower on another has not necessarily changed. The setup changed.

The practical consequence is that cross-vendor comparisons are close to meaningless, and even the same vendor's numbers across releases are only comparable when the harness is unchanged. Treat each release note as a set of claims to be checked, not a ranking to be trusted.

How to check the speed and cost claims yourself

The three headline claims are easy to test on your own traffic:

  • Speed: run your longest real prompts, not short greetings. A model that reports 200+ tokens per second on a 200-token reply tells you nothing about a 4,000-token one.
  • Cost: log your cache hit rate before switching. The $0.015 cached input rate only turns into savings if your workload actually reuses context. Check how often yours does.
  • Agent cost: compare tokens spent per finished task against the model you use now. If the 70% lower usage cost claim holds on your prompts, this is where it shows up.

One more thing to confirm before you move a workload: what access through the MiniMax API, the M Plan, and MiniMax Code actually gives you in terms of rate limits and concurrency. A cheap token price is not useful if the endpoint throttles the agent loop that needs it.

How to test a model on your own work

A vendor leaderboard cannot tell you whether the model handles your codebase, your ticket format, or your API. Build a small test set instead.

  1. Collect twenty tasks from your own backlog. Real tickets, real bugs, real requests.
  2. Write the prompt you would actually give the agent, not a friendly demo prompt.
  3. Per task, record whether it finished, how many attempts it took, how long it took, and how many tokens it used.
  4. Run the same set on the model you use today. You need the comparison, not the absolute number.
  5. Multiply the cost of a single run by the number of attempts. That is your real unit cost.

Small utilities like the Unix timestamp converter make good test tasks, because the right answer is easy to check and the edge cases are known. That is a good shape for a test set: a clear correct answer, a few cases that break naive solutions, and no ambiguity about what finished means.

Latency

MiniMax reports output at 200+ tokens per second with a median of 170+. For an agent, latency shows up as time per turn, and time per turn compounds across a long task. At 170 tokens per second, a 500-token answer takes roughly three seconds. At 200, roughly two and a half.

Tool calling

The tool-use scores are the part most likely to transfer to your work, and also the part least like your work. Real tool calling breaks on things a benchmark does not cover: your tool names, your parameter shapes, your error messages, your rate limits. Test the exact tools the agent will call, with the exact schemas it will see.

Reliability over peak performance

Check that the model handles a tool that returns an error, a tool that returns an empty result, and a task where the right move is to stop and ask a person. Those three cases show up constantly in real agent runs, and they separate models more often than the headline numbers do.

For reference, an independent model tracking page exists at Artificial Analysis. It is worth a look if you want numbers from a third party rather than from the vendor. We do not repeat its figures here.

What to take away

MiniMax M3.1 Flash is a fast, cheap model with open weights still to come. The vendor numbers look encouraging on tool use and security tasks, and the pricing is simple enough to reason about without a spreadsheet. The cheapest way to find out whether it fits your work is to run twenty of your own tasks through it and compare cost per finished task against whatever you use today.

Tolz.me builds with AI coding agents and tests models on real tasks rather than published leaderboards. It is the evaluation that actually decides the question for your code, and it is the one most teams skip.

Sources

Tools used in this guide

Open a tool, make the change, and copy the result. No account needed.