MiniMax M3.1 Flash: Fast Tokens, Broken Controls

Summary

I asked MiniMax M3.1 Flash to build a Minecraft-style game in my Kagantic style. The task was not just a familiar block world: the project had to follow my visual identity and keep working controls.

The recorded session produced a launchable Rust application with voxel terrain, a crosshair, a hotbar, and separate files for the world, player, renderer, textures, and interface. The model followed clear instructions and made some good coding decisions. The result still failed at the point that mattered: turning and breaking blocks did not work properly when I used the game, and the implementation did not consistently preserve the logic and style I asked for.

That gap is the story. Fast token generation did not produce a finished interactive application, and the agent's final report disclosed that its environment could not exercise real mouse and keyboard input. The session ended at $3.78 and took about 78 minutes of development and tool activity. I do not recommend M3.1 for this kind of work.

What M3.1 offers

MiniMax documents M3.1 Flash with a context window of up to one million tokens, text/image/video input with text output, tool use, and reasoning effort levels from low to max. The documented default is max; I used medium effort in this recording.

For a coding agent, the useful capability is the loop: inspect files, edit them, run commands, read the result, and revise. In my setup, the oh-my-pi harness supplies those tools and executes the actions; the model decides what to do next.

Context capacity gives the model room to work with more of a project, but it does not guarantee that every requirement survives a long session. The same distinction applies to vendor claims. MiniMax advertises computer-use and cybersecurity capabilities and reports 73.7% on DeepSWE, but those are vendor-reported results and capabilities. This test focused on building and using an interactive application.

What it built

The agent read my brand reference and produced a Rust project with separate files for the world, player, renderer, textures, and interface. It generated a launchable application with voxel terrain, a crosshair, and a hotbar. It organized a substantial amount of work across multiple files and handled clear implementation instructions well.

The failure appeared in the actual experience. Turning and breaking blocks did not function properly. The game also did not consistently preserve the logic and visual style I wanted. Following a visual identity is not a palette swap at the end; it is another constraint the model has to maintain while making implementation decisions.

The missing interaction test

The final report disclosed a specific limitation: the environment lacked a Wayland capture or input-injection tool. The agent described scripted input-path checks rather than testing the application through actual mouse and keyboard events.

That leaves a gap between testing internal game logic and testing how a person operates the window. A compiler can accept the code while the camera controls remain broken. The disclosure was useful, but the missing interaction check still had to happen before I could consider the game finished.

For anyone assigning a desktop application to an agent, the lesson is practical: make sure its tools can exercise the actual interface, not only build the project.

Why 74 tokens per second did not feel fast

In my notes, MiniMax generated roughly 74 tokens per second, compared with 20 for DeepSeek and 26 for GPT. Those observations came from my setup, not identical serving conditions.

The text arrived quickly, but the overall task still felt slow. The source recording is about 78 minutes long and includes development, tool activity, compilation, and revisions, not just model inference.

Token speed measures how quickly output is generated. It does not measure how much output the model needs, how many times it revises its approach, or how long the surrounding tools take. That is what I meant by overthinking in my notes: the session kept going without delivering a result that justified the wait.

For your own comparison, measure elapsed time to a passing result, alongside token speed. Keep the starting files and tools the same, and count manual corrections.

The $3.78 session and the pricing change

The recorded build ended at $3.78. For context, MiniMax was cheaper than Opus and GPT, but not cheaper than Xiaomi's MiMo or DeepSeek. Against those alternatives, I do not consider it good value, especially after accounting for supervision and unfinished functionality.

MiniMax's current API list prices are $0.15 per million input tokens, $0.60 per million output tokens, and $0.015 per million cached input tokens. These are unit prices, not a recommendation or a reconstructed invoice.

The subscription presentation also changed. An older screenshot gave approximate monthly token allowances. The newer cards describe Explore as three times Go usage and Build as seven and a half times Go usage, without an absolute allowance on those cards. A multiplier is harder to budget around when the baseline is unclear. The documentation does explain five-hour and weekly usage windows, and the discounted prices in the newer screenshot apply to the first month, not every renewal. Subscription allowances and API token purchases are separate products. A separate screenshot showing $3.94 is not a matched-task comparison with the $3.78 recorded run.

Verdict

I do not recommend MiniMax M3.1 for interactive coding. It can follow clear instructions and make good coding decisions, but its broader reasoning and consistency were not good enough in this session. Fast tokens did not compensate for a long run that left basic controls broken and dropped my style requirements.

My impression is that this is a benchmark-maxed model: more convincing on familiar tasks than when asked to preserve my specific constraints. That is an assessment, not an allegation of cheating, and one recorded session is not a universal benchmark.

I would focus on Xiaomi's MiMo or DeepSeek instead.

Sources and scope

• MiniMax M3.1 Flash launch — release, capabilities, and the vendor-reported DeepSWE result.
• MiniMax model invocation and capability page — context, modalities, tool workflows, and reasoning effort.
• MiniMax API pricing — input, output, and cached-input rates.
• M Plan overview and usage rules — tiers and usage windows.

This article is compiled from my recorded hands-on test and the project's source notes. It does not claim a controlled benchmark, a matched comparison against every model, or a reproduction of MiniMax's vendor results. The preview and Flash labels refer to the same M3.1 model by owner confirmation. Footage inspection was not end-to-end playback, and the final report's input-verification limit is part of the evidence.