Flash AI Models Made Agents Cheap. Price Per Token Is Now the Wrong Number

Three labs shipped fast, low-cost models for agent work in three days. Here is how to tell which one is cheaper for the job you actually run.

Every AI pricing page answers the same question: what does a million tokens cost? An agent never asks that question. It asks how many tokens it will burn before the job is done, and no pricing page can answer that for you.

That gap just got a lot more important. Between October 17 and 19, three different labs put a cheap, fast model in front of builders, and all three pitched it at the same work: the long, repetitive loops an AI agent runs when it reads files, calls tools and tries again. The prices landed within cents of each other.

This means the choice between them no longer comes down to the price table. It comes down to a number you have to measure yourself: cost per finished task.

What a "Flash" model is, and why agents care

Most AI labs now sell two kinds of model. The big one is slow and expensive and gets used for hard thinking. The small, fast one is cheap enough to call hundreds of times in a row. Labs give the fast tier names like Flash, Haiku or Luna.

Agents live in the fast tier. A coding agent fixing one bug might read twenty files, run the tests four times and rewrite a function three times. Each of those steps is a model call. Multiply a price by a few hundred calls and the small model is the only one that makes the math work for overnight or always-on jobs.

So when three labs ship for that tier in the same weekend, they are fighting over the part of the market where agent builders spend most of their money.

The three launches, in plain terms

MiniMax M3.1 Flash shipped on October 19 with flat pricing of $0.15 per million input tokens, $0.60 per million output tokens and $0.015 for cached input. MiniMax claims a median output speed above 170 tokens per second and says agentic tasks cost 70% less than on its previous model. It also lists agent scores like 73.7% on DeepSWE v1.1, but the page does not say who ran those tests or against what baseline, and it does not give a parameter count, a context window or a license. The weights "will be released later." (MiniMax)

Mercury 3 from Inception shipped the same day, and it works differently. Most language models write one token at a time, left to right. Mercury is a diffusion model: it drafts a whole block of text and then cleans it up in a few passes, closer to how image generators sharpen a blurry picture. That is where its speed comes from. Inception reports 1,068 tokens per second on NVIDIA GPUs, a 1M-token context, and prices of $0.20 input and $0.70 output per million tokens, cut to $0.10 and $0.35 during a launch promotion. The page says Mercury 3 beats GPT-6 Luna and Claude Haiku 5.5, but the scores sit in a chart image and the text gives no test details, and the one agent result it reports (50% of 50 live web-navigation tasks) comes from a partner running its own test setup. (Inception)

DeepSeek-V4.1-Flash-1017 is a new checkpoint (a freshly trained version of the same model family) dated October 17, and DeepSeek did something sneakier than a launch. Its API docs say the existing deepseek-flash name now points at the new checkpoint, and the older deepseek-v4-flash names route there too. If you already called those names, you switched models this week without changing a line of code. (DeepSeek release note, DeepSeek API docs)

DeepSeek is also the only one of the three with an outside scorecard. That scorecard is where the real lesson sits.

The number the launch pages leave out

Artificial Analysis, an independent group that benchmarks models, tested DeepSeek's new checkpoint. It measured 224.7 output tokens per second and a score of 45 on its Intelligence Index, and it lists DeepSeek's prices at $0.30 input and $1.20 output per million tokens, both below the median for comparable models. (Artificial Analysis)

Those are DeepSeek's peak rates. Its pricing page halves them off-peak, to $0.15 input and $0.60 output, which matches MiniMax's sticker price exactly. Peak hours are 01:00 to 04:00 and 06:00 to 10:00 UTC on weekdays. On the US East Coast that first window is 9 PM to midnight while daylight time lasts, which is exactly when an evening or overnight agent run tends to start.

Then comes the line most people scroll past. To finish that index, the model produced about 210 million output tokens. The median for its peers was 140 million (figures as read on October 19; the page updates as it re-tests). That is about 1.5 times as much writing to get through the same test.

Think of it like two taxis. One charges less per mile. The other knows a shorter route. You only learn which ride is cheaper when you get the receipt.

Tokens work the same way. Price per token is the rate per mile. The number of tokens a model spends to finish your task is the route. The bill is the two multiplied together, and a model that talks more can erase a lower rate.

In one line: cost per finished task = tokens used × price per token ÷ tasks that actually finished.

Here is a quick illustration with round numbers, so you can see the shape. Suppose a task needs 40,000 output tokens on Model A and 60,000 on Model B (that 1.5x gap again). At $0.60 per million, Model A's output costs $0.024. At $0.50 per million, Model B's costs $0.030. The "cheaper" model loses. These are made-up task sizes, not measurements, and the gap could go either way on your work. That is the whole point: you cannot know without running it.

Artificial Analysis does the math in one place: it puts the average cost at $0.26 per index task for this model. That is the right kind of number. It is just measured on their tasks, not yours.

Agents make three hidden costs bigger

A single chat answer barely notices any of this. An agent loop magnifies it, for three reasons.

Agents re-read their own history. Each step usually sends the conversation so far back to the model, so input tokens pile up faster than output. That makes the cached-input price, the discount for text the provider has seen recently, matter more than the headline rate. MiniMax lists cached input at a tenth of its normal input price. Inception says cached input is 90% off. DeepSeek charges $0.006 per million for cached input at peak, a 98% discount. If your agent code keeps the start of each prompt stable, those discounts do real work. If it reshuffles the prompt every turn, you pay full price every time.

Agents retry. A model that fails a tool call and tries again spends tokens twice. Completion rate belongs in the cost math. A model that finishes 9 tasks out of 10 for a dollar beats one that finishes 6 out of 10 for eighty cents.

Agents wait. Speed is a cost too, measured in minutes instead of cents. A browser agent that takes a step every two seconds feels broken next to one that steps every half second. This is the bet Inception is making with diffusion, and it is why output speed now shows up next to price on every launch page.

Watch for the silent swap

DeepSeek's alias change deserves its own warning, because it will happen again with other providers.

When a provider points an existing model name at a new checkpoint, everything built on that name changes behavior on the provider's schedule. A prompt you tuned last month may now produce longer answers. A budget alarm set on last month's usage may trip. And because the endpoint name did not change, nothing in your deploy logs explains why.

The fix is boring and it works: use the most specific model name the API accepts, and log the model name the response says actually answered.

Put this into practice

You can get a real answer for your own workload in an afternoon. Here is the lowest-friction version.

Pick one real task your agent runs often. Not a benchmark. Something like "fix a failing test in this repo" or "summarize these ten support tickets into a report." Write down what finished looks like, so you can score pass or fail without arguing with yourself.
Put a gateway in front of the models. A gateway is a small local service that gives you one OpenAI-style API and forwards each request to whichever provider you choose, so you can switch models with a config change instead of a code change. Bifrost is one open-source option: npx -y @maximhq/bifrost starts it on localhost:8080. If you would rather not run anything, OpenRouter carries both Mercury 3 and DeepSeek V4.1 Flash. MiniMax lists its own API.
Run the same task five times on each of two models. Five runs is not science, but it is enough to see whether one model is wildly wordier or flakier than the other.
Record four numbers per run: input tokens, output tokens, wall-clock time and whether it finished. OpenAI-compatible APIs return token counts in the response, so this is a logging change, not a research project.
Do the division. Cost per finished task = (input tokens × input price + output tokens × output price) ÷ tasks finished. Use the cached-input price for the share of input your provider reports as cached. Providers differ on what counts as cached and for how long, so read the cached-token field in each response instead of assuming.
Pin the winner by its full model name, and add a log line that records which model answered every call.

What to expect: on short, simple tasks the cheapest sticker price usually wins. On long, tool-heavy tasks, the differences in output volume and retries tend to decide it, and the ranking can flip.

Honest limitations

Five runs of one task tell you about that task. They do not tell you about the next one, so repeat the test when your agent's job changes.

Artificial Analysis's figures are the only independent ones here, and they come from its own index, which may look nothing like your workload. MiniMax's and Inception's benchmark claims are their own, with missing details, so treat them as reasons to test rather than reasons to switch.

Launch promotions end. Mercury's half-price rate is temporary, so price your test at the regular rate.

And cheap is not free of other costs. MiniMax has not released weights or a license yet, Inception's announcement offers API and enterprise access but announces no open weights, and DeepSeek's alias already changed under its users once this week. If you need to run a model on your own hardware or freeze it forever, only one of these three gives you weights today: the MIT-licensed DeepSeek checkpoint. Its Hugging Face repo is about 510 GB, so "your own hardware" means a serious server, not a laptop.

The receipt is the benchmark

The fast tier is now where agent work happens, and the competition there will keep pushing prices down. That is good news, as long as you stop reading the price table as the answer.

Run your own task. Count the tokens. Divide by what finished. The model that wins that math is the cheap one, whatever its pricing page says.

Sources: MiniMax M3.1 Flash announcement (October 19, 2026); Inception, Introducing Mercury 3 (October 19, 2026); Artificial Analysis, DeepSeek V4.1 Flash 1017 (read October 19, 2026); DeepSeek API news and October 17 release note; DeepSeek API pricing; DeepSeek-V4.1-Flash-1017 on Hugging Face; Bifrost repository; OpenRouter, DeepSeek V4.1 Flash.