Tested July 28, 2026: MiniMax-M3 resolved 7 of 10 original repository-repair tasks on its first autonomous attempt. It passed 92 of 114 hidden assertions, completed 54 API calls without a primary-run API error, and cost $0.0536 from reported token usage. The median task took 37.5 seconds.
This is a hands-on MiniMax M3 coding benchmark, not a summary of the vendor’s launch chart. We created ten small JavaScript and Python repositories, planted a different bug in each, exposed only public tests to the model, and graded the submitted files against hidden tests afterward. The complete task definitions, test files, sanitized call records, final solutions, and checksums are available for download below.
Results at a glance
| Primary metric | Measured result |
|---|---|
| Tasks resolved (pass@1) | 7/10 (70%) |
| 95% confidence interval | 39.7%–89.2% (Wilson) |
| Hidden assertions passed | 92/114 (80.7%) |
| JavaScript / Python | 3/5 / 4/5 |
| Completed API calls | 54/54 (100%) |
| Task latency | 37.5s p50; 56.0s p95; 60.2s maximum |
| API-call latency | 1.74s p50; 33.54s p95; 52.31s maximum |
| Reported input / output tokens | 107,738 / 35,225 |
| Usage-derived primary cost | $0.053620 total; $0.005362 per task |
| Human intervention / generation retries | 0 / 0 |
Short verdict: M3 was effective once it entered the edit-and-test loop. Every task on which it actually wrote a candidate file passed the hidden grader (7/7). Its three primary failures happened earlier: the model used the entire 4,096-token completion budget while reasoning and never called the write tool. That makes completion budget and harness design a material part of real coding performance, not a footnote.
Contents
- What we tested
- Fixed test protocol
- Results by task
- Why the three tasks failed
- 4,096 vs 8,192-token diagnostic
- Latency, tokens, and cost
- How this differs from official benchmarks
- Download the evidence
- Limitations
- FAQ
What we tested
We evaluated the MiniMax-M3 API as a tool-using coding agent. The harness gave the model a compact repository, a bug report, the visible files, and five tools: list_files, read_file, write_file, run_tests, and finish. The model could inspect code, edit the target file, run public tests, and iterate within one autonomous attempt.
The ten tasks were written specifically for this experiment rather than copied from HumanEval, SWE-bench, or a public interview set. Five used JavaScript and five used Python:
- JS-01: generate Unicode-safe user handles.
- PY-02: parse strict duration strings and reject malformed input.
- JS-03: merge and normalize integer ranges.
- PY-04: recursively merge configuration objects without mutating inputs.
- JS-05: parse quoted CSV fields, escaped quotes, and line endings.
- PY-06: allocate seats with Hamilton’s largest-remainder method.
- JS-07: sanitize local redirect targets.
- PY-08: validate safe relative filesystem paths.
- JS-09: compare semantic versions, including prerelease identifiers.
- PY-10: produce a deterministic topological ordering and detect cycles.
Across the suite, 29 public assertions supplied useful feedback during the run. A separate set of 114 hidden assertions determined the result after the model stopped. Before spending API credit, we ran a preflight: every reference solution passed both test layers, while every buggy starter failed its hidden grader.
Fixed test protocol
| Control | Value |
|---|---|
| Protocol ID | minimax-m3-coding-10-v1 |
| Model and endpoint | MiniMax-M3 through OpenAI-compatible POST /v1/chat/completions |
| Service tier | Standard |
| Thinking mode | Adaptive Thinking explicitly enabled |
| Sampling | Temperature 0.1; top_p 0.95 |
| Completion limit | 4,096 tokens in the primary run |
| Tool budget | Maximum seven API calls per task |
| Timeout | 180 seconds per API request |
| Attempts | One autonomous attempt per task; no generation retry |
| Environment | Local sandbox; candidate code had no network access, package installs, or credentials |
| Pass condition | All hidden assertions for that task must pass |
The grader did not award partial task credit: 13 of 14 assertions still counted as a failed task. We nevertheless report assertion coverage to show how much functionality survived. Timing starts immediately before the first model request and ends after the autonomous attempt; the hidden grader then evaluates the final file separately.
For readers building their own harness, MiniMax documents the OpenAI-compatible Chat Completions API and its tool-use and interleaved-thinking behavior. Our broader MiniMax API guide covers endpoint setup, while the M3 tool-calling benchmark isolates schema adherence from code repair.
MiniMax M3 coding benchmark results by task
| Task | Hidden | Result | API calls | Task time | Cost |
|---|---|---|---|---|---|
| JS-01 Unicode handles | 10/10 | Pass | 5 | 26.22s | $0.004749 |
| PY-02 Duration parser | 12/12 | Pass | 7 | 44.22s | $0.007018 |
| JS-03 Merge ranges | 9/9 | Pass | 5 | 26.59s | $0.004786 |
| PY-04 Deep config merge | 9/9 | Pass | 7 | 21.35s | $0.003156 |
| JS-05 CSV parser | 5/12 | Fail | 3 | 45.91s | $0.005554 |
| PY-06 Hamilton seats | 11/11 | Pass | 7 | 47.11s | $0.007720 |
| JS-07 Safe redirect | 12/12 | Pass | 5 | 30.84s | $0.005203 |
| PY-08 Safe relative path | 7/14 | Fail | 5 | 60.19s | $0.005864 |
| JS-09 SemVer compare | 6/14 | Fail | 3 | 50.99s | $0.005530 |
| PY-10 Topological order | 11/11 | Pass | 7 | 26.57s | $0.004040 |
What M3 did well
M3 solved tasks that required more than filling a stub. Its successful patches handled Unicode normalization, strict input validation, non-mutating recursive merges, stable tie-breaking, URL safety rules, and deterministic graph traversal. It also used the public test tool productively: whenever the primary run reached a write_file call, the final submission passed every hidden assertion.
That 7/7 observation is descriptive, not a new benchmark score. It is post hoc and the sample is small. Still, it separates two abilities that a single pass rate can blur: producing a correct patch after editing and managing the agent loop well enough to submit a patch before the budget ends.
Why the three primary tasks failed
The surprising result was that none of the three failures came from a model-written patch that failed hidden edge cases. M3 never wrote a patch on those tasks. Each attempt consumed the primary 4,096-token completion allowance in a thinking-heavy response and ended with finish_reason: length before a write_file tool call.
| Failed task | Completion tokens in capped call | Reasoning tokens reported | File writes |
|---|---|---|---|
| JS-05 CSV parser | 4,096 | 3,363 | 0 |
| PY-08 Safe relative path | 4,096 | 3,927 | 0 |
| JS-09 SemVer compare | 4,095 | 4,095 | 0 |
The hidden grader therefore tested the unchanged starter files, which explains their partial assertion scores. We count all three as failures because the intended deliverable was a working repository, not a promising internal analysis. In production, an agent that reasons past its submission window still leaves the bug unfixed.
Diagnostic: raising the completion cap to 8,192
After freezing the 7/10 primary score, we reran only the three failures as a diagnostic. We changed one control: max_completion_tokens increased from 4,096 to 8,192. The model, prompt, tasks, standard tier, sampling, thinking mode, seven-call allowance, and 180-second request timeout stayed the same. These reruns are not included in pass@1.
- PY-08 recovered: 14/14 hidden assertions, one write, 7,339 completion tokens, and 6,383 reported reasoning tokens.
- JS-09 recovered: 14/14 hidden assertions, one write, 6,102 completion tokens, and 4,477 reported reasoning tokens.
- JS-05 still failed: its third request reached the 180-second timeout before any write, leaving the starter unchanged at 5/12 hidden assertions.
The diagnostic resolved 2/3 tasks and 33/40 hidden assertions for $0.020855 in returned-usage cost. The practical implication is narrow but useful: a 4K completion ceiling was too small for two otherwise solvable tasks under this thinking-and-tool harness. Raising the ceiling is not a guaranteed fix—the CSV attempt simply moved from a length stop to a timeout.
Latency, token use, and cost
Primary task latency ranged from 21.35 to 60.19 seconds, with a 37.53-second median and 56.05-second p95. Individual API calls were more uneven: the median was 1.74 seconds, while p95 was 33.54 seconds and the slowest completed call took 52.31 seconds. Tool-only turns can be quick, while reasoning-heavy turns dominate end-to-end latency.
The primary run reported 107,738 input tokens and 35,225 output/completion tokens. The usage fields identified 87,380 cached input tokens and 27,793 reasoning tokens; these are components of the reported totals, not extra tokens to add again. Using the applicable pay-as-you-go rates produced a primary cost of $0.053620, or $0.005362 per attempted task and $0.007660 per resolved task.
This is a response-usage calculation, not a before-and-after account-balance estimate. It intentionally excludes our preflight, the separate 8K diagnostic, and any unrelated account traffic. Consult the official MiniMax pay-as-you-go pricing page for current rates, or see our MiniMax pricing guide for plan context.
How this result differs from official coding benchmarks
MiniMax reports 59.0% on SWE-Bench Pro and 66.0% on Terminal-Bench 2.1 for M3. Those are provider-reported results with their own datasets, infrastructure, scaffolds, timeouts, and evaluation rules, documented in the official M3 launch and methodology. They should not be compared numerically with our 70% result.
Our experiment answers a smaller operational question: can the standard M3 API inspect, patch, and validate ten compact repositories inside a strict tool loop? It is closer to a controlled harness check than a broad software-engineering leaderboard. The official API overview lists MiniMax-M3 as a 1,000,000-token model for agentic reasoning, tool use, coding, and long-context work, but our repositories were intentionally tiny and did not test that context limit.
For adjacent hands-on evidence, read our M3 long-context test, API endpoint parity test, and standard-versus-priority latency test. The MiniMax M3 model page covers features, and the M3 coding tools guide focuses on practical integrations.
This test also evaluated the API in our own minimal harness, not the MiniMax Code desktop product. MiniMax Code uses a richer agent environment and may behave differently; see our separate MiniMax Code hands-on review.
Download the benchmark evidence
Download the complete MiniMax M3 coding benchmark evidence bundle (ZIP).
Package maintenance — verified July 30, 2026: This ZIP was rebuilt with portable POSIX paths; its internal checksum set remains verified. The published coding result is unchanged.
SHA-256: 54bfda1864c82136f22092d335fe3dc4e12d1e4cb78a6531b429a8be4f5c57dd
The bundle contains the frozen protocol manifest, all ten starter repositories, public and hidden tests, reference solutions, sanitized primary call records, final candidate files, per-task hidden-test logs, CSV and JSON results, the three-task 8K diagnostic, runner source, and a checksum manifest. We scanned 47 text files before packaging and found no API keys, account information, local machine paths, raw response IDs, or private reasoning text.
Limitations
- Small sample: ten tasks produce a wide 39.7%–89.2% confidence interval. JavaScript-versus-Python differences are not meaningful at five tasks each.
- Synthetic micro-repositories: the tasks test targeted repair skills, not navigation through a million-line production codebase.
- One harness: different prompts, tools, scaffolds, token limits, or retry policies can change the result substantially.
- One primary attempt: pass@1 measures first-attempt reliability, not the best outcome after repeated sampling.
- No cross-model comparison: only MiniMax-M3 ran this frozen suite, so the experiment does not establish a ranking against other models.
- Post hoc diagnostic: the 8K rerun was motivated by observed failures. It explains a mechanism but must not be folded into the primary score.
- Point-in-time result: API behavior and pricing can change after July 28, 2026.
Frequently asked questions
Is MiniMax M3 good for coding?
In this controlled test, MiniMax-M3 resolved 7 of 10 original repository-repair tasks on its first autonomous attempt. More specifically, it passed all seven tasks on which it reached a file write, while three attempts exhausted the completion budget before submitting code. That is promising patch quality but also a warning that agent-loop configuration matters.
What score did MiniMax M3 achieve in this benchmark?
The primary score was 7/10 tasks resolved, or 70% pass@1. M3 passed 92/114 hidden assertions, took 37.5 seconds per task at the median, and cost $0.053620 from reported primary-run token usage.
Is this a SWE-bench result?
No. This is a ten-task original micro-repository suite with our own minimal tool harness and hidden tests. MiniMax’s provider-reported SWE-Bench Pro score uses a different dataset, scaffold, infrastructure, and evaluation method, so the percentages are not directly comparable.
Which MiniMax endpoint and thinking mode did you use?
We used MiniMax-M3 through the OpenAI-compatible POST /v1/chat/completions endpoint on the standard service tier, with Adaptive Thinking explicitly enabled, temperature 0.1, and top_p 0.95.
Why did three tasks fail?
All three primary failures reached the 4,096-token completion cap during a reasoning-heavy turn before the model wrote a file. The hidden grader therefore evaluated the unchanged starter. In a separate 8,192-token diagnostic, two recovered and one CSV attempt timed out at 180 seconds.
How much did the MiniMax M3 coding test cost?
The ten-task primary run cost $0.053620 from usage returned by completed API responses: $0.005362 per attempted task or $0.007660 per resolved task. The separate 8K diagnostic cost $0.020855 and is excluded from the primary figure.
Did you test the MiniMax Code desktop app?
No. We tested the MiniMax-M3 API inside a purpose-built, minimal coding harness. MiniMax Code provides a richer agent product and should be evaluated separately.
Can I reproduce the benchmark?
Yes. Download the evidence ZIP above. It includes task definitions, runners, public and hidden tests, reference solutions, sanitized call records, final files, results, logs, and checksums. You must supply your own MiniMax API key and credit.
Independence disclosure: We designed and executed this test ourselves. MiniMax did not supply the tasks, approve the methodology, or review the conclusions. Results reflect the API and pricing observed on July 28, 2026.