MiniMax M3.1 Flash: $0.15 Price, Free Options, API Setup in Python, Thinking Effort, Benchmarks vs DeepSeek, Open Weights on October 23, and MiniMax on Bedrock

MiniMax M3.1 Flash is MiniMax's new low-cost multimodal model, released publicly on October 19, 2026: a 1-million-token context, text, image and video input, thinking that is always on with a tunable effort setting, and a price of $0.15 per million input tokens and $0.60 per million output ($0.015 for cached input). It is the model that ran anonymously on OpenRouter as "Space Bunny Alpha" from late September. You can use it today through MiniMax's API (Anthropic-compatible and OpenAI-compatible endpoints, model ID MiniMax-M3.1-Flash), MiniMax Code and OpenRouter, and MiniMax says the open weights arrive October 23. Its launch scores put it close to DeepSeek's V4.1-Flash-1017, which costs the same. It is not on Amazon Bedrock yet; Bedrock carries MiniMax M2, M2.1 and M2.5. Below: pricing and free options, API setup in Python with both protocols, the effort settings and the "requires adaptive thinking" error, benchmarks side by side, M3.1 Flash vs M3, what running it locally will take, MiniMax on Bedrock, and fixes for common API errors.

Ethan writes the small scripts that run Jake's computer shop, and he watches model prices the way other people watch gas prices. When a model called "Space Bunny Alpha" turned up on OpenRouter in September, fast and oddly good at reading screenshots of error messages, he used it for a week without knowing who made it. On October 19, MiniMax put its name on it. This page is what Ethan found when he looked at the real thing: what it costs, how to call it, how it compares, and whether the shop's back-room PC can ever run it.

New to running AI models yourself? Our free guide series explains models, tokens and memory in plain English, and the cards below cover the rest.

What MiniMax M3.1 Flash is

MiniMax is a Shanghai-based AI company known for open-weight models that punch above their price, a coding assistant called MiniMax Code, and audio and video models. Its text models have come in steady steps: M2 in October 2025, M2.1 and M2.5 through the following months, M2.7, and M3 in June 2026, a large open-weight multimodal model with a 1-million-token context.

M3.1 Flash is the newest step, and the "Flash" is the point: it is built to be cheap and quick for everyday work while keeping M3's headline abilities. In plain terms:

• It reads a lot at once. A 1-million-token context holds several long reports, a large codebase, or hours of meeting transcripts in one request.
• It reads more than text. Images and video go in alongside text: screenshots of errors, photos of receipts, short screen recordings.
• It thinks before answering, always. You choose how hard it thinks (the effort setting), but you cannot switch thinking off.
• It is aimed at agents and coding. MiniMax pitches it for multi-step tool use, computer-use tasks and code, the work its MiniMax Code app does.

The "Space Bunny" story explains why some developers already know it. From September 23, an unnamed model called Space Bunny Alpha ran on OpenRouter, a service that lets you call many companies' models through one API. On October 19, MiniMax confirmed Space Bunny was an earlier version of M3.1 Flash. During that anonymous run, its speed and reliability improved noticeably, which is the kind of public testing that is becoming common before big launches.

Jake: "So the bunny was this all along?"

Ethan: "An early version of it. I'd been using it for a week to read screenshots of Windows errors. Now I know whose model it is, and what it costs."

MiniMax M3.1 Flash pricing, compared

Through MiniMax's API, M3.1 Flash costs $0.15 per million input tokens, $0.60 per million output tokens and $0.015 per million cached input tokens. Cached input applies when the start of your prompt repeats across requests, such as a long system prompt or a document you ask many questions about, so it cuts costs sharply for those patterns.

Two things the price table hides. First, thinking tokens are output tokens: at the default max effort, the model writes its reasoning before the answer, and you pay for those tokens at the output rate. A question with a 200-token answer can bill several thousand output tokens at max effort. Lower effort is the main cost lever, covered below. Second, long context is billed in full: sending 500,000 tokens of documents with every question costs $0.075 per question in input alone, which adds up quickly; cache the documents or retrieve only the relevant parts.

A worked example. A support helper handling 1,000 questions a day, each with 3,000 input tokens and about 1,500 output tokens including thinking at medium effort: 90 million input and 45 million output tokens a month, or $13.50 + $27.00 = about $40 a month. The same traffic at max effort, where thinking might triple the output, lands nearer $95. Effort, not the headline price, decides the bill.

Ways to try it for free (and the "free not supported" error)

• OpenRouter's launch window. OpenRouter listed M3.1 Flash free for its first 72 hours after the October 19 launch, with the model ID ending in :free, after which normal prices apply. Free variants on OpenRouter come with lower rate limits and can disappear without notice.
• MiniMax Code and the M Plan. MiniMax's own coding app and subscription plan include the model, which suits people who want an assistant rather than an API.
• Open weights from October 23. Once the weights are published, running the model on your own hardware costs nothing per token, though the hardware is the catch (see running it locally).

"Model ... free not supported." If code that used a free model ID such as minimax/minimax-m2.1:free suddenly fails with a "not supported" or "no endpoints found" error, the free variant was retired. Switch to the paid ID (the same name without :free) or to a current free one. The same will happen to M3.1 Flash's free listing, so build with the paid ID and treat free access as a trial.

Get started in five minutes

1. Create an account on MiniMax's developer platform, platform.minimax.io, the international site.
2. Add credit in the billing section. At $0.15 per million input tokens, a few dollars lasts a long time for testing.
3. Create an API key and copy it once; it is shown only when created.
4. Store the key in an environment variable rather than in your code. On Windows: setx MINIMAX_API_KEY "your-key", then open a new terminal. On macOS or Linux: add export MINIMAX_API_KEY="your-key" to your shell profile.
5. Run one of the snippets below and check the usage page afterwards, to see how many input, output and thinking tokens your first request really used.

That last step is worth the minute it takes: seeing a 200-word answer bill 3,000 output tokens at max effort is the fastest way to understand why the effort setting matters.

Calling M3.1 Flash from Python: two ways

Create an API key on MiniMax's developer platform (platform.minimax.io), then pick the protocol your code already speaks. MiniMax recommends its Anthropic-compatible endpoint, but the OpenAI-compatible one works with the OpenAI SDK and most tools built for it.

Anthropic-compatible (pip install anthropic):

import os
import anthropic

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

msg = client.messages.create(
    model="MiniMax-M3.1-Flash",
    max_tokens=2048,
    messages=[{"role": "user", "content": "Explain what Windows error 0x80070005 means in two sentences."}],
    extra_body={"output_config": {"effort": "medium"}},
)
for block in msg.content:
    if block.type == "text":
        print(block.text)

The response contains thinking blocks and text blocks; the loop prints only the answer. Passing output_config through extra_body works with any recent version of the SDK.

OpenAI-compatible (pip install openai):

import os
from openai import OpenAI

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

resp = client.chat.completions.create(
    model="MiniMax-M3.1-Flash",
    messages=[{"role": "user", "content": "Explain what Windows error 0x80070005 means in two sentences."}],
    reasoning_effort="medium",
)
for choice in resp.choices:
    print(choice.message.content)                              # the answer
    print(getattr(choice.message, "reasoning_content", None))  # the thinking, returned separately

Which protocol should you pick? If your project already uses one SDK, stay with it: both endpoints serve the same model at the same price. Choose the Anthropic-compatible endpoint for new code that will use tools, thinking and images heavily, since it returns thinking and answer as separate typed blocks that are easy to handle. Choose the OpenAI-compatible endpoint when a tool or library only speaks that format, which is still the most common one.

On this protocol the model's reasoning arrives in a separate reasoning_content field, so content holds just the answer. If you use OpenAI's newer Responses API instead, the setting is reasoning.effort.

Reading screenshots and photos

Images go in as content blocks next to the text, in each protocol's usual format. On the Anthropic-compatible endpoint:

import base64

with open("bluescreen.png", "rb") as f:
    shot = base64.b64encode(f.read()).decode()

msg = client.messages.create(
    model="MiniMax-M3.1-Flash",
    max_tokens=2048,
    messages=[{"role": "user", "content": [
        {"type": "image", "source": {"type": "base64", "media_type": "image/png", "data": shot}},
        {"type": "text", "text": "What is the likely cause of this error, and what should I try first?"},
    ]}],
    extra_body={"output_config": {"effort": "medium"}},
)

On the OpenAI-compatible endpoint, the same image goes in as {"type": "image_url", "image_url": {"url": "data:image/png;base64," + shot}} inside the message content list.

A few habits make image questions work better. Crop to the part that matters: a screenshot of the error dialog beats a photo of the whole desk. Resize phone photos to around 1,500 pixels on the long side, because images are billed as input tokens and full-resolution photos cost more without adding detail. And ask a specific question; "what's wrong here?" gets a general answer, while "which driver does this error point to?" gets a useful one.

Video input, a less common ability at this price, suits short screen recordings ("this is what happens when I plug in the dock") and clips that need a summary. Keep clips short and to the point: video is the most token-hungry input there is.

Jake: "So I can just photograph the customer's screen?"

Ethan: "Photograph the error, crop it, and ask what it means. That's what the bunny was doing for me all September."

Streaming shows the answer as it is written, which matters at higher effort levels where the model may think for a while first. With the Anthropic SDK, stream and print only the answer text:

with client.messages.stream(
    model="MiniMax-M3.1-Flash",
    max_tokens=4096,
    messages=[{"role": "user", "content": "Write a PowerShell one-liner that lists the 10 largest files in C:\\Users."}],
    extra_body={"output_config": {"effort": "high"}},
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

text_stream yields only the answer text, so the thinking does not scroll past the user. With the OpenAI SDK, pass stream=True and print each chunk's delta.content, skipping the reasoning deltas.

Through OpenRouter, use OpenRouter's base URL and key with the OpenAI SDK, and the model ID OpenRouter lists for M3.1 Flash. That is the quickest way to compare it with DeepSeek, Gemini or others behind one key.

Thinking effort: settings, cost and the "requires adaptive thinking" error

Every M3.1 Flash request thinks first. The effort setting decides how much:

Where the setting goes depends on the protocol: output_config.effort on the Anthropic-compatible endpoint, reasoning_effort on the OpenAI-compatible one, and reasoning.effort on the Responses API. Leave it out and you get max, the slowest and most expensive level, which surprises people whose first bill is higher than the price list suggested.

The 400 error. Thinking cannot be turned off. Sending thinking: {"type": "disabled"} or effort: "none", which some tools do by default, returns a 400 error saying the model "requires adaptive thinking." The fix is to remove that setting and use low effort when you want speed.

How much does effort matter? On the Automation-Bench agent test, M3.1 Flash's launch figures run from about 53% at low effort to about 63% at max. That is a real gap for hard agent work, and an irrelevant one for "summarize this email." Match the effort to the job, per request.

Jake: "So 'max' is like the ten-minute diagnostic, and 'low' is a glance?"

Ethan: "Exactly. And the default is the ten-minute one, every time, unless you say otherwise."

Using the 1M context without wasting money

A million tokens is roughly 2,500 pages of text. Being able to send that much is useful; sending it with every request is expensive and slow. A few patterns get the benefit without the bill:

• Put stable material first. Caching works on the beginning of a prompt. Place the long, unchanging part (instructions, a manual, a codebase summary) at the start and the changing question at the end, and repeated requests read the start at $0.015 per million tokens instead of $0.15.
• Send what is relevant, not everything. For a large document set that changes, retrieve the few passages that matter for each question (RAG) instead of pasting the whole set every time. Use the full context for the cases that need it: comparing two long contracts, or reading a whole codebase once.
• Expect slower first answers on huge prompts. The model has to read every token before it starts writing. A 500,000-token prompt takes noticeably longer to begin answering than a 5,000-token one, which matters for anything interactive.
• Check that the answer used the right part. Long-context models are good at finding details, but not perfect. Ask the model to quote the passage its answer relies on, and spot-check it.

For the shop, the sweet spot was the repair manual for one laptop line, about 120,000 tokens, sent once with caching and then queried all day. The first question cost about two cents in input; the rest cost a fraction of that.

Benchmarks: M3.1 Flash next to DeepSeek V4.1-Flash-1017

MiniMax launched with scores on several of the same tests DeepSeek used two days earlier for its V4.1-Flash-1017 update, at the same price. Both sets are the companies' own launch figures, measured with their own setups, so treat small gaps as noise until independent tests appear:

Read plainly: two cheap models, close on most tests. DeepSeek's update leads on code fixing, terminal work and long agent tasks; MiniMax's leads on automation and hard reasoning, and it publishes a computer-use score DeepSeek does not. At identical prices, the practical differences are elsewhere: MiniMax takes video input and offers an Anthropic-compatible endpoint; DeepSeek's weights are already out and run on more hosting providers. For your own work, an afternoon with twenty real tasks on both, through OpenRouter, will tell you more than either table.

A month of the same work on four cheap models

Per-token prices are only half the story; the other half is how many tokens each model writes. Here is one month of an app that reads 10 million input tokens and writes 2 million output tokens of answers, before any thinking:

• MiniMax M3.1 Flash: 10 × $0.15 + 2 × $0.60 = $2.70, plus thinking tokens at the output rate. At low effort that might add a few dollars; at max effort it can double or triple the output line.
• DeepSeek V4.1-Flash-1017 off-peak: the same $2.70, with thinking optional and weekday peak hours at double the rate.
• Anthropic's Haiku 5.5 on Bedrock (prompts up to 100K tokens): 10 × $0.10 + 2 × $0.50 = $2.00, billed on your AWS account.
• Gemini 3.8 Flash at its introductory price: 10 × $0.75 + 2 × $3.75 = $15.00.

So among the cheapest models, the headline prices are within a dollar or two of each other, and what decides your real bill is thinking: how much each model writes before answering, at the effort you choose. That is why the test sheet below has a cost column measured from real usage numbers rather than per-token rates. For the shop's screenshot reading, M3.1 Flash at medium effort and DeepSeek with thinking off landed within pennies of each other per week; the choice came down to MiniMax's video input, which Ethan wanted for short screen recordings.

Test it on your own work before switching

Launch benchmarks are a starting point. Your own tasks decide whether M3.1 Flash replaces what you use today. An afternoon is enough:

1. Pick 20 real tasks from your actual work: a few easy, a few hard, a few with images if you need vision.
2. Write down what a good answer looks like for each, before you run anything.
3. Run them through OpenRouter on M3.1 Flash at medium effort, at max effort, and on your current model, using the same prompts.
4. Score the answers blind: paste them into a sheet without model names and mark each good, partly good or wrong.
5. Note the cost and time of each run from the usage data, including thinking tokens.
6. Decide per kind of task, not overall. Many teams end up with a cheap model at low effort for routine work and something stronger, or higher effort, for the hard tenth.

Effort deserves its own column in that sheet. If medium matches max on your tasks, you just halved the bill; if it does not, you know exactly which tasks need the extra thinking.

Agents and computer use: what to know first

MiniMax aims M3.1 Flash at agents, and its launch figures include a computer-use score (OSWorldV2, operating a desktop through screenshots and actions) that few cheap models publish. If you plan to let it drive tools or a computer, a few rules keep it useful and safe:

• Use high effort for agent steps that change things, and low or medium for simple lookups inside the same agent; mixing effort per step keeps long sessions affordable.
• Cap the loop: a maximum number of steps and a token budget per task, so a confused agent stops instead of running all night at max effort.
• Keep humans on irreversible actions: deleting files, sending emails, paying invoices. Let the agent prepare them and a person confirm.
• Sandbox computer use: run it in a virtual machine or a test account, never on a PC with saved passwords and live customer data.
• Log every tool call with its inputs and results; when something goes wrong, the log is the only way to see why.

Tool calling works through the usual tools parameter on both endpoints, so agent frameworks built for Anthropic- or OpenAI-style tools can use it with a base URL and model name change. Test your exact framework, since small differences in how providers return tool calls are the most common source of agent bugs after a switch.

Pick the effort per request, automatically

Because effort is the main cost lever, the cheapest setups choose it per request instead of using one value for everything. A simple rule in code is enough:

1. Classify the request by type: a lookup or rewrite, an everyday question, a debugging or analysis task, or an agent step that changes something.
2. Map each type to an effort: low, medium, high and xhigh respectively, and keep max for the rare hard task.
3. Check the answer where you can (a JSON parse, a test run, a length check).
4. Retry once at higher effort only when the check fails, rather than paying for max on every request.

For the shop, that rule cut the monthly output tokens by more than half compared with leaving the default max, with no change the team could see in the answers that mattered.

Using M3.1 Flash inside VS Code chat

You do not need MiniMax's own app to use the model while coding. VS Code's chat can add models from other providers through its Language Models editor, including any endpoint that speaks the OpenAI Chat Completions, OpenAI Responses or Anthropic Messages format, and models added this way work without a Copilot plan:

• Open the chat panel's model picker, choose the gear (or run Chat: Manage Language Models), then Add Models and Custom Endpoint.
• Choose the Messages API type with MiniMax's Anthropic-compatible URL, or Chat Completions with the OpenAI-compatible one, and enter your MiniMax key.
• Set the model name to MiniMax-M3.1-Flash, then pick it in the chat panel.

Agent mode needs a model with tool calling, which M3.1 Flash is built for. Inline completions (the gray suggestions as you type) still come from your Copilot plan, since VS Code uses custom models for chat only. Our GitHub Copilot Free guide explains how custom and local models fit next to Copilot.

M3.1 Flash vs M3: which one?

The rest of the MiniMax lineup, as listed on its API:

For most new projects, start with M3.1 Flash: it is newer, cheaper and quick, and its effort setting lets you spend more only where you need to. Keep M3 in mind if you need thinking switched off entirely (M3 allows it, Flash does not) or if you already run M3's open weights. MiniMax M2.x models remain available as legacy options, with a 204,800-token context, for code that depends on them.

Running M3.1 Flash locally: what it will take

MiniMax says the weights for M3.1 Flash arrive on October 23, 2026. Until then nobody can say exactly how large the files will be, because MiniMax has not published the model's parameter count. What we can do is look at its sibling, M3, whose weights are already public, as a guide to the scale involved:

• M3 has about 428 billion parameters, of which about 23 billion are active for each token. It is a mixture-of-experts model: fast to run for its size, but every expert must sit in memory.
• At full 16-bit precision that is roughly 850 GB of weights. A 4-bit quantized version, the usual choice for home use, would be around 230 to 250 GB.
• That means a 256 GB or 512 GB Mac Studio, a workstation with 256 GB+ of RAM plus a graphics card for the active parts (KTransformers and llama.cpp both split mixture-of-experts models this way), or a multi-GPU server. Not a gaming PC, and not a laptop.

If M3.1 Flash turns out smaller than M3, which a "Flash" name would suggest, the bar drops; if it is the same size, these numbers hold. Either way, the practical first steps on October 23 will be the same as for other big open models: look for official GGUF or MLX conversions from the usual community builders, check that your runner (llama.cpp, Ollama, LM Studio, MLX) has added support for the architecture, and only then download hundreds of gigabytes. Our local LLM hardware guide covers what each memory tier buys, and our tool comparison covers which runner to pick. We will add file sizes and commands to this page once the weights are out.

What to check on October 23, before downloading anything:

• The license: whether commercial use is allowed, and under what conditions.
• The file sizes for each precision, and whether official FP8 or 4-bit versions are published.
• Runner support: whether llama.cpp, Ollama, LM Studio and MLX can load the architecture yet. New architectures often need a few days or weeks.
• Community conversions (GGUF and MLX) from the builders you trust, with honest notes about what works.
• Independent benchmarks, which usually appear within a week of open weights.

The license matters too. M3's weights use the MiniMax community license rather than a standard open-source license like Apache 2.0 or MIT, and M3.1 Flash's license has not been published yet. Read it before building a commercial product on the weights.

Jake: "So the back-room PC is out?"

Ethan: "For this one, almost certainly. The API at fifteen cents a million tokens is cheaper than the electricity for anything big enough to run it."

MiniMax on Amazon Bedrock

If your company works inside AWS, Amazon Bedrock already offers three MiniMax models, billed on your AWS account with no separate MiniMax contract:

All three support Bedrock's Priority and Flex service tiers, so you can pay more for guaranteed speed or about half for work that can wait. M3 and M3.1 Flash were not on Bedrock as of mid-October 2026; open-weight models from MiniMax have typically reached Bedrock some weeks or months after launch, so watch our Bedrock model list. Calling M2.5 through the Converse API looks like any other Bedrock model:

import boto3

brt = boto3.client("bedrock-runtime", region_name="us-east-1")
resp = brt.converse(
    modelId="minimax.minimax-m2.5",
    messages=[{"role": "user", "content": [{"text": "List three causes of a laptop not charging."}]}],
    inferenceConfig={"maxTokens": 800},
)
print(resp["output"]["message"]["content"][-1]["text"])

Reasoning models can return a reasoning block before the text, which is why the example reads the last content block. For LangChain users, ChatBedrockConverse(model="minimax.minimax-m2.5") works the same way; our LangChain with Bedrock guide has the setup.

Data, privacy and where your requests go

Using any AI API means sending your text, and any images, to the provider. With M3.1 Flash you have three different arrangements to choose from, depending on how sensitive the data is:

• MiniMax's API (or OpenRouter routing to it): your requests go to MiniMax, a company based in China, under MiniMax's terms of service and privacy policy. Read those before sending customer data, and check whether your industry or your clients restrict where data may be processed.
• Amazon Bedrock (for MiniMax M2.x today): the model runs inside AWS, billed on your AWS account, and Bedrock does not share your prompts with the model provider or use them for training. For companies already on AWS, this is often the simplest answer for sensitive work, accepting the older model.
• Your own hardware, once the weights are out: nothing leaves your machines. The cost moves from tokens to hardware, which, at this model's likely size, is substantial.

A practical rule for small businesses: strip what the model does not need before sending it. A repair note can be summarized without the customer's phone number; a screenshot can be cropped to the error. Less data sent is less data to worry about, whichever provider you use.

Common MiniMax API errors and fixes

The "empty reply" row deserves a note: with thinking always on, a small max_tokens can be used up entirely by reasoning before any answer is written. Allow a few thousand tokens at medium effort and more at max.

What to watch over the next few weeks

A model launched days ago is still settling. These are the changes most likely to affect how you use it, and what each would mean:

• The open weights on October 23: file sizes, the license, and which runners support the architecture. That decides whether self-hosting is realistic for anyone below data-center scale.
• Independent benchmarks: launch figures come from the maker. Third-party results on coding, agents and long context usually appear within a week or two of open weights, and they are the ones to trust when choosing between close rivals.
• Other hosts: open weights let more providers serve the model, which often brings lower prices, more Regions and better uptime than a single provider can.
• Amazon Bedrock: if and when M3.1 Flash or M3 arrives there, AWS customers get it under their existing account and data terms; until then, M2.5 is the MiniMax option on Bedrock.
• Price changes: launch prices in this part of the market move often, in both directions. Keep the model name and endpoint in configuration so a better deal is a one-line change.

We will add dated updates to this page as each of these lands, starting with the weights and license on October 23. If you build on the model now, write down which of these you depend on, so you know which update to look for, and set a reminder to re-run your test set when the first independent results appear.

Who should use M3.1 Flash, and who should wait

• Use it now if you need a cheap model that reads images or video, want a 1M context at a low price, or run coding and automation agents where its launch scores are strong. The Anthropic-compatible endpoint makes it easy to swap into tools built for that API.
• Compare first if you already use DeepSeek V4.1 Flash or Gemini 3.8 Flash: at similar prices, your own tasks decide it.
• Wait if you need the model on Amazon Bedrock under your AWS agreement (use M2.5 there today), if you need to run it locally on modest hardware, or if your legal team needs a published license.

For small businesses, the low price makes experiments nearly free: a thousand questions at medium effort cost well under a dollar. The bigger risk is not cost but dependency on a fast-moving provider, so keep your prompts and code portable, through the OpenAI- or Anthropic-compatible endpoints, and switching later stays a configuration change.

Frequently asked questions

Ethan moved the shop's screenshot-reading script from the anonymous Space Bunny ID to MiniMax-M3.1-Flash at medium effort the same evening. The answers were the same as before; the bill for the week came to eleven cents. He put October 23 in the calendar to read the license and the file sizes, and then crossed out "run it on the back-room PC" with a small, resigned line. The effort rule went in the same night: low for reading error codes, medium for drafting replies, high only for the PowerShell scripts he asks it to write, which is where a mistake costs real time. A week later the usage page showed output tokens down by more than half compared with the default, and nobody in the shop had noticed any change in the answers at all. Jake asked why the model was called Flash if it still needed a server room. "Flash is the price," Ethan said. "The size is a different word."

Revision note. Written October 19, 2026, launch day. File sizes and local commands will be added after the weights arrive on October 23. A model called Flash can still be big; the name describes the bill, not the box.