Publication timeline: Originally published July 20, 2026 as an unexecuted test plan. The benchmark was run and the results were added July 28, 2026; the downloadable evidence package was verified July 30, 2026. Current-release context checked August 26, 2026.
MiniMax Code desktop build 3.0.55.98 passed four of five original repository tasks in our July 28, 2026 Windows test. Every submission passed its visible test suite, but an external hidden grader caught a currency-parsing edge case that the agent missed. The median task time was 163 seconds. This is a dated product benchmark: MiniMax now lists v3.0.66 as the current release, and we have not rerun the five-task protocol on that version.
We ran this benchmark on July 28, 2026, using the installed MiniMax Code desktop app build 3.0.55.98. The app displayed MiniMax-M3 with Thinking enabled and Smart Authorize selected. This is a small, reproducible product test—not a vendor benchmark, not SWE-bench, and not a comparison with another coding agent.
Version context — verified August 26, 2026: This benchmark remains a historical test of desktop build 3.0.55.98 run on July 28. MiniMax’s current official changelog lists v3.0.66, released August 19. The 4/5 score must not be presented as a result for v3.0.66 unless the complete protocol is rerun.
MiniMax Code test result at a glance
- Final score: 4/5 tasks passed (80%)
- Public tests: 5/5 submissions passed when graded after each run
- Hidden tests: 4/5 submissions passed
- Median task time: 163 seconds
- Fastest task: duplicate detection optimization, 68 seconds
- Human intervention: one continuation on the first task after the app could not find Node.js
What we tested
We created five dependency-free Node.js repositories covering correctness, feature work, security, performance, and asynchronous control flow. Each repository began from a recorded clean Git commit and included a small public test suite. The hidden grader stayed outside the folder MiniMax Code could inspect.
MiniMax Code received one frozen prompt and one attempt per task. Network access and package installation were prohibited. The nominal timeout was 15 minutes. A task counted as a pass only when both the public suite and the predefined hidden checks passed; a public-only pass received no partial credit. Failures remained in the denominator.
Test environment
| Test date | July 28, 2026 |
|---|---|
| Product | MiniMax Code desktop app |
| Installed build | 3.0.55.98 |
| Operating system | Windows |
| Displayed model | MiniMax-M3 |
| Thinking | On |
| Permission mode | Smart Authorize |
| Attempts | One per task |
| Network or installs | Not allowed |
Environment caveat: Node.js was not on the app’s command path during task 1. The agent requested two broad searches that we denied, followed by two bounded checks that we approved. After it still could not run the suite, we gave one human continuation instructing it to skip in-app execution and complete the static repair. We then ran the public and hidden graders externally. Before tasks 2–5, we added the existing Node installation to the app environment. We did not rerun task 1, so this score is not a zero-touch run and the first task’s duration includes environment diagnosis.
Results: 4 of 5 repository tasks passed
| Task | Public tests | Hidden grader | Time | Outcome |
|---|---|---|---|---|
| Strict US currency parsing | Pass | Fail | 699 s | Failed a valid leading-decimal input |
| Deterministic JSON report | Pass | Pass | 90 s | Correct API and CLI behavior |
| Safe note-path reader | Pass | Pass | ≈240 s | Blocked tested traversal cases |
| O(n) duplicate detection | Pass | Pass | 68 s | 60,003-record hidden case in 14.2 ms |
| Retry and backoff semantics | Pass | Pass | 163 s | Correct attempts, delays, and error identity |
The five sessions totaled about 21 minutes, and the median was 163 seconds. Those timings describe this machine, these repositories, and the observed interaction overhead. They should not be treated as model-only latency measurements.
Task-by-task analysis
1. Strict currency parsing: public pass, hidden fail
The first repository contained a loose parseAmount function. The prompt required exact integer cents, valid comma grouping, optional signs and dollar symbols, no exponent notation, no extra text, no more than two decimals, and safe-integer bounds.
MiniMax Code replaced the loose parser with a strict regular expression and used BigInt for string-to-cents conversion. That was directionally strong: the two public tests passed when we ran them externally, and malformed grouping, exponent notation, unsafe values, and ordinary signed amounts were addressed.
The hidden grader exposed the miss. It treated .5 as a valid 50-cent input, but the generated expression required at least one integer digit before the decimal point and threw TypeError. The same expression also excludes +.50, another accepted hidden case. Because the grader stopped on the first failed assertion, this task received a hard fail.
This failure also showed why execution and independent tests matter. Unable to run Node in the app, the agent manually traced examples and claimed its cases were correct. Its final explanation even listed $+5 as accepted, although the implemented pattern only allowed the sign before the optional dollar symbol. The public suite was green, but it was not broad enough to reveal the grammar boundary.
2. JSON report feature: pass
The second task asked for an exported buildReport(rows) function and a --json CLI mode while preserving the existing text output. MiniMax Code changed two files and completed the task in 90 seconds.
The external grader verified empty-array behavior, row validation, safe-integer checks, overflow rejection, rounding, deterministic key order, exact compact CLI output, and the original text summary. All checks passed. This was the cleanest feature task in the set: the agent inspected the existing code, preserved the default path, added validation, and ran both the suite and smoke commands.
3. Path traversal repair: pass, with a Windows caveat
The vulnerable note reader relied on a path-prefix check that could confuse a root such as C:\notes with a sibling such as C:\notes-evil. It also followed links without validating their resolved destination.
MiniMax Code added separator-aware containment checks, resolved the root and candidate through realpath, rejected empty paths, required a regular file, and preserved the exported API. The hidden grader confirmed nested reads, sibling-prefix rejection, absolute-path rejection, traversal rejection, and directory rejection.
Windows did not permit the grader to create a file symbolic link under the current privileges, so that one hidden assertion was recorded as unavailable rather than executed. The in-app smoke check did create a directory junction and reported that the escape was rejected. The task passed our predefined Windows grading rule, but this single run is not direct proof for every symlink configuration on a privileged system.
4. Duplicate detection performance: pass
The original implementation repeatedly sliced and scanned the records array, producing quadratic behavior. MiniMax Code replaced that logic with two sets: one for seen IDs and one for IDs already reported. It retained the required second-occurrence ordering, input validation, and non-mutating behavior.
The hidden grader processed 60,003 records in 14.2 milliseconds on this machine, returned the expected two duplicate IDs in order, and confirmed that the input was unchanged. The full app session took 68 seconds, the fastest result in the benchmark.
5. Retry semantics: pass, including an explained test edit
The retry task required positive-integer attempt limits, finite non-negative base delays, 1-based attempt numbers, exponential backoff only between failures, immediate return on success, and rethrowing the exact final error object.
MiniMax Code repaired the implementation and also edited the public test. Test edits deserve scrutiny, but this one was required by the prompt: the existing test encoded the old 0-based behavior, while the requested API explicitly changed attempts to 1-based numbering. The agent updated the assertions from [0, 1, 2] to [1, 2, 3] and kept delays at [10, 20].
Most importantly, the functional hidden grader was outside the editable repository. It independently verified the attempt cap, 1-based sequence, delays, success path, no sleep after the final failure, input validation, and exact final-error identity. All hidden checks passed, so the test edit did not manufacture the score.
What the run says about MiniMax Code
On these five bounded repositories, MiniMax Code was effective at targeted maintenance work. It completed a small feature, a security repair, a performance refactor, and an asynchronous-control-flow fix that all survived external grading. Once Node was available in the app environment, the four remaining tasks completed without human continuations or permission decisions.
The parser failure is equally important. The implementation looked disciplined, used exact arithmetic, and passed the public suite, yet one valid grammar edge still broke it. The agent’s confident manual case list did not match the code in every detail. Our practical conclusion is not “trust” or “do not trust”; it is to pair the agent with tests it cannot see, especially for parsers, validation logic, security boundaries, and other edge-heavy code.
MiniMax Code is not the same test as the M3 API
MiniMax Code is the complete coding-agent product. The result depends on the desktop app, its tool loop, file access, permission policy, installed runtimes, displayed model, and the agent’s decisions. MiniMax-M3 is the model shown inside this particular app build, but this 4/5 score cannot be attributed to the raw model alone.
For a model-level protocol, see our separate MiniMax M3 coding benchmark. For product setup and workflows, use the MiniMax Code guide and our M3 coding tools guide. MiniMax also maintains an official MiniMax Code changelog and an official M3 model overview.
Practical recommendations from the test
- Preflight the environment. Confirm required runtimes and commands are on the app’s path before starting a timed task.
- Keep graders outside the workspace. Hidden checks are more useful when the agent cannot inspect or edit them.
- Review every test change. A test update can be legitimate when the specification changes, as in the retry task, but it must be justified and independently verified.
- Test grammar boundaries explicitly. Parsers need compact cases such as missing leading digits, sign placement, unsafe ranges, malformed separators, and trailing text.
- Do not equate a green public suite with completion. All five submissions passed their visible tests; only four survived the hidden grader.
If you are evaluating coding agents for your own workflow, our code generation use-case guide offers additional task ideas. Check the MiniMax token plan guide for account-side details; we did not convert this desktop product run into an API-dollar cost because no comparable per-task API usage record was available.
Evidence and reproducibility files
The downloadable evidence package contains the frozen manifest and prompts, starter repositories, starting Git commits, final task files, sanitized app transcripts, public and hidden result JSON, and the external grader. Account-identifying text is redacted; no credential is included.
Evidence ZIP SHA-256: 4c8e8ec233046cc4b7ed5bfc0bb28bfc1581c6b21d4dc9af66fcf634e1f43a08
Package maintenance — verified July 30, 2026: This ZIP was rebuilt with portable POSIX paths; its internal checksum set remains verified. The published hands-on result is unchanged.
Limitations
- This is a five-task case study, not SWE-bench or a statistically representative sample of software engineering.
- The repositories are small, dependency-free Node.js fixtures. We did not test large builds, package installation, browser apps, databases, compiled languages, mobile projects, or multi-day work.
- We tested one Windows machine, one installed build, one account, one displayed model, and one attempt per task. We did not measure run-to-run variance.
- Task 1 used a different command-path environment, required four permission decisions and one human continuation, and was not rerun after Node was added.
- The task timer includes app interaction and environment overhead; it is not a pure inference-speed metric.
- Windows prevented the hidden grader from creating a file symlink, so that exact check was unavailable. A junction escape was exercised only in the agent’s separate smoke check.
- We did not capture a reliable token count or per-task monetary charge, and we did not compare MiniMax Code with another agent.
Verdict
MiniMax Code earned 4/5 in this hands-on repository benchmark. It was strongest on a bounded feature addition, path hardening, performance optimization, and retry semantics. Its only hard failure was a small but valid leading-decimal parser case that public tests missed. The result supports using MiniMax Code for focused repository work with a prepared runtime, constrained permissions, diff review, and independent tests—not treating its final summary as proof of correctness.
Frequently asked questions
How many MiniMax Code tasks passed?
Four of five tasks passed both their public tests and the external hidden grader, for a hard-pass score of 80%. All five passed their public suites.
Why did the currency parser fail?
The generated regular expression required a digit before the decimal point. The hidden grader accepted .5 as 50 cents, so the submission threw instead of returning 50.
Was the benchmark fully autonomous?
Not completely. Node.js was missing from the app’s command path during task 1, and we gave one continuation telling the agent to finish without running tests in-app. Tasks 2–5 needed no human continuation after Node was added.
Why was the retry task allowed to modify a test?
The prompt explicitly changed attempt numbers from the old 0-based behavior to 1-based behavior, so the existing public assertion had to change with the specified API. An external hidden grader independently verified the implementation.
Is this a MiniMax-M3 API benchmark?
No. This tests the MiniMax Code desktop product, including its tools, permissions, local environment, and agent loop. Our separate M3 coding benchmark covers the model API protocol.
Can this 4/5 result be generalized to large repositories?
No. The sample contains five small dependency-free Node.js repositories and one attempt per task. It is useful evidence for these task types, not a universal success rate.