MiniMax M2.7 Review (2026): A 10/10 Tie With Opus 4.8, a $0.56 Benchmark, and the License Trap Nobody Reads

Last updated: June 20, 2026

MiniMax M2.7 is a 230-billion-parameter, text-only coding model from Shanghai-based MiniMax. It activates about 10 billion parameters per token, runs through an Anthropic-compatible API, and ships open weights under a non-commercial license. It is built for agentic coding and tool use, not prose or images, and it costs a fraction of a frontier model per token.

That last point is what made it loud on developer social feeds. The phrase doing the rounds, “90% of Opus quality at 7% of the cost,” comes from one third-party test by Kilo Code, run in March against the older Claude Opus 4.6. We wanted to know what happens when you run M2.7 against the current flagship, Claude Opus 4.8, in the same coding harness, and what the bill actually looks like at the end. We also read both license files, because the licensing story changed twice in three months.

Here is what the receipts showed.

Briefing summary — June 2026

MiniMax M2.7 is a cheap, fast-iterating, text-only coding model that is genuinely competitive on narrow, well-specified tasks and genuinely complicated everywhere else. In our own test it tied Claude Opus 4.8 on a small hidden-grader benchmark, and the real cost of the run was far lower than the sticker price suggested, because agentic coding spend is dominated by cached input replay rather than model output.

Three things have shifted since this review first published in April. First, MiniMax released M3 on June 1, a newer 1-million-token, natively multimodal model, so M2.7 is no longer the company’s frontier coding model. Second, MiniMax relaxed its licensing: M2.7 carries a hard non-commercial gate, while M3 ships under a more permissive community license with a $20 million revenue threshold. Third, the independent Artificial Analysis Intelligence Index moved to a new methodology (v4.1), which rescaled M2.7’s score. We have updated all three below and added our own benchmark.

TL;DR

MiniMax M2.7 is worth testing if you run high-volume agentic coding and your bottleneck is the API bill on a frontier model. In our harness it solved the same three TypeScript bug-fix tasks as Opus 4.8, passing every hidden grader, and the entire benchmark across both models cost 56 cents on OpenRouter because 80.9% of tokens hit cache.

Three caveats decide whether that matters for you. The weights are open but the license is non-commercial, so shipping anything that earns money on the self-hosted weights needs written permission from MiniMax first. The model is text-only in a year where screenshots, PDFs and UI mockups are part of normal coding. And it is parented in China, which most enterprise procurement reviews will flag. If any of those is a hard blocker, the price advantage does not reach you.

At a glance

What FSR tested

We ran MiniMax M2.7 and Claude Opus 4.8 through the same coding harness and changed only the model. The harness was Cline running inside Cursor, with both models reached over OpenRouter. OpenRouter provider routing was left on its default mode, so the request went to whichever provider the platform picked rather than a single pinned one. That is worth stating up front, because it means the routing was realistic but not fixed.

The test design was built so the model could not see how it was being graded. The model was given only an agent-workspace folder. The grader lived in a separate grader folder outside that workspace and was never shown to the model. Before every task, the repository was reset to the same clean, buggy baseline, so each model started from an identical state.

Model settings were as close as the two products allow. M2.7 ran as minimax/minimax-m2.7 with a thinking budget of 1,024. Opus 4.8 ran as anthropic/claude-opus-4.8 on Adaptive Thinking Low. These are comparable in intent but not numerically identical: M2.7 exposes a numeric thinking budget, Opus exposes named thinking levels. We did not try to pretend they were the same dial.

The three tasks were small, deterministic bug fixes with hidden assertions:

• T1, pricing bug in src/util/pricing.ts. The discount was computed without dividing the discount percentage by 100. Three hidden assertions: no discount returns the gross amount, a 10% discount applies correctly, a 25% discount applies with correct rounding.
• T2, inventory oversell bug in src/service/orderService.ts. Order placement did not reject quantities above available stock, which allowed overselling into negative inventory. Three hidden assertions: reject an order above stock and leave stock unchanged, allow a valid order and decrement stock, reject a non-positive quantity.
• T3, pagination and stock filter bug in src/controllers/productController.ts. The controller ignored the limit, offset and inStock query parameters. Four hidden assertions: default to limit 20 and offset 0, respect custom limit and offset, clamp a limit above the maximum to 100, filter to in-stock products only.

This is a controlled, synthetic benchmark. It rewards correctly fixing well-specified bugs. It does not measure architecture decisions on a large codebase, long-horizon agent stability, or anything M2.7 might do on messier, underspecified work. Treat the result as one clean data point, not a verdict on general intelligence.

MiniMax M2.7 vs Claude Opus 4.8: the results

Both models passed everything. Every hidden assertion, on every task, for both models.

Six of six task cells passed. On this benchmark, a model costing a fraction as much per token produced the same graded result as Anthropic’s flagship.

Resist the obvious headline. This is not “M2.7 equals Opus.” It is parity on three small, well-specified bug fixes with a hidden grader. Kilo Code’s earlier test, run against the older Opus 4.6, found the same pattern in a different shape: M2.7 matched Opus on detecting bugs and security issues, but Opus wrote more thorough fixes and roughly twice as many integration tests. Detection parity and graded-pass parity are real and useful. Neither is the same as matching a frontier model across the full surface of software work, and our own benchmark was not designed to test that surface.

The cost layer: Cline estimate vs OpenRouter actual spend

This is where the test stops being a model comparison and starts being something more useful. Keep two numbers separate, because mixing them is how cost reviews go wrong.

The first number is what the editor told us. Cline shows an in-editor cost estimate per task. On its meter, the two models looked like this:

The second number is what OpenRouter actually billed. The editor’s two columns sum to about $1.12. The real charge on OpenRouter for the entire benchmark, both models combined, was $0.56.

Two different ratios live in those two tables, and they are not the same thing. The 15.9x is the gap between the two models on Cline’s meter. The roughly 2x is the gap between Cline’s total estimate ($1.12) and the actual OpenRouter bill ($0.56), for this run. Do not collapse them into one sentence.

The actual bill is shaped almost entirely by input, not output. Across the whole benchmark, 80.9% of tokens were cache hits, and the token volume was dominated by prompt replay, the same system prompt and file state fed back into the model on each turn. Reasoning and completion were thin. We can see this clearly in the one cell where the per-task breakdown was captured, M2.7 on T1: about 30K prompt tokens, roughly 1K of reasoning plus completion, a 70.3% cache hit rate, four requests. The output the model wrote was a rounding error next to the context it re-read.

That kills a hypothesis we started with. The common worry about cheap reasoning models is a “verbosity tax,” the idea that a chatty model burns its price advantage on extra output tokens. In this run, output was not the cost driver. Input replay was, and caching absorbed most of it. Worth noting for anyone repeating the verbosity claim: Artificial Analysis independently ranks M2.7 as the single most concise model in its class, generating about 85M tokens on its Intelligence Index against a class median of 110M. The “M2.7 is too chatty” line usually compares it against the wrong baseline.

The honest reading of the meter gap is narrow. We are not saying Cline is always wrong, and we are not saying editor estimates are always double the bill. We are saying that in this run, with caching dominating, the in-editor meter overstated the real charge by about 2x, and the most likely reason is that the meter did not fully reflect the cache discount. If your team is sizing an agentic coding budget off the number your editor shows, that number can be meaningfully higher than what the provider charges. Check the provider dashboard before you set the budget.

The gap between what a coding tool’s meter shows and what you actually pay is not unique to this setup; we hit a related set of agentic-cost mistakes in our Cursor vs Claude Code cost breakdown.

Fix footprint: localized vs broad

The two models did not fail in different ways here. They succeeded in different styles, and the style difference is the part a senior engineer should care about.

Opus 4.8 kept its changes small. One file per task. On T3 it forwarded the raw query parameters straight to the service and let the service parse them. Minimal blast radius.

M2.7 reached wider. On T2 it changed two files, the controller and the service. On T3 it changed three, the repository, the service and the controller, and it altered the service’s return shape to an object shaped like { items, total, limit, offset }. Every one of those edits still passed the hidden grader. The point is not that M2.7 was wrong. It was right, and broader.

On a three-task sandbox, breadth is harmless. On a real codebase, more files touched and a changed return shape is more surface for a regression, more to review, more that can ripple into callers you did not test. This micro-benchmark did not expose a regression, and we are not claiming it would. We are flagging the pattern: when you let a cheaper model handle routine fixes, budget for review time on the diff, not just the API line item.

One environment note, so it is not misread as a model flaw. Both models hit intermittent replace_in_file and diff-editor failures during the run, the kind that show up as “failed to open diff editor” or “search patterns do not match.” Both recovered by falling back to full-file writes. We treat this as a characteristic of the Cursor plus Cline plus OpenRouter setup, not a property of either model.

The pricing M2.7 gets right

The cost story holds up, with one correction and one clarification.

The correction is the channel. There is no single M2.7 price. As of June 2026, Artificial Analysis lists the first-party MiniMax API at $0.30 per million input and $1.20 per million output. OpenRouter’s own list price is lower, $0.25 input and $1.00 output, served across eight providers. The figures third-party tools report drift between these two because they are quoting different channels at different times. Quote the channel and the date, or quote a range.

The clarification is caching. M2.7 includes automatic context caching that drops reused input to $0.06 per million, around 80% off the input rate, with cache writes billed at $0.375 per million. OpenRouter states that for repeated context the effective price can run 60 to 80% below list. Our own run is a concrete example of that mechanism doing the work: 80.9% of tokens cached, a 56-cent bill. For agent pipelines that feed the same system prompt and file state into the model on every turn, this is the difference between a runaway meter and a rounding error.

The gap against a frontier model is still large at the token level. M2.7’s input price sits well below the major proprietary models. But the cheap token is only half of an agentic cost model. The other half is how much context gets replayed and how much of it caches, which is exactly what our benchmark measured. A team that assumes “17x cheaper per token” translates directly into “17x cheaper per task” is reasoning from the sticker, not the workflow.

We documented an extreme version of that sticker-versus-workflow gap in our Ahrefs Agent A review: $99 on the sticker, an $827 real bill, and an agent that never showed the difference.

Where the benchmarks get slippery

The vendor benchmark scores need reading with care, and the one independent score moved.

Most of MiniMax’s strongest published numbers, SWE-Pro at 56.22%, Terminal Bench 2 at 57.0%, VIBE-Pro at 55.6%, were run by MiniMax on its own infrastructure. SWE-bench Pro is maintained by external researchers, but MiniMax evaluated M2.7 against it itself, and no independent lab has replicated the exact figure. MiniMax’s own model cards describe running these evaluations with Claude Code as scaffolding and the default system prompt overridden, which is a heavily optimized setup. VIBE-Pro is explicitly an internal benchmark in MiniMax’s documentation. None of this means the numbers are fabricated. It means the strongest numbers come from evaluations the vendor controls, and that is a different evidence class from an independent test.

The one number you can lean on changed. Artificial Analysis independently scores M2.7 on its Intelligence Index. When this review first published, that index was version 4.0 and M2.7 scored 50. The index has since moved to version 4.1, a different suite of nine evaluations, and on that scale M2.7 scores 38, ranked #12 of 92 in its open-weight size class against a class median of 24. The drop from 50 to 38 is a methodology change, not a regression in the model. The honest summary is the same as it was: a strong score for a model at this price, above average for its class, not frontier.

Two other independent readings are worth keeping in view. Artificial Analysis measures M2.7’s output speed at about 47 tokens per second, slow for its class (median around 63), with a time to first token of roughly 2.3 seconds. And there is a genuine disagreement in the sources about whether M2.7 improved or regressed against M2.5, with some agentic and vibe-coding evaluations reporting lower scores than the previous version. Our benchmark does not resolve that debate. It tests a narrow slice and finds parity on that slice.

What M2.7 cannot do

M2.7 processes text and outputs text. That is the whole list. No image input, no audio, no video.

In 2026 that is a real limit, not a footnote. A lot of coding now runs through screenshots of errors, UI mockups, PDFs with embedded diagrams and the occasional voice note. A text-only model covers the part of that work that is already text. For the rest you are reaching for another model, which is fine if you have already decided to run a hybrid stack, and friction if you have not.

The context window is adequate but not a selling point. At about 200K tokens it handles most single-repository tasks and sits well below the million-token windows the frontier models now offer. And the speed, as measured independently, is on the slow side for its class. None of these sinks the model. They define the lane it runs in: routine, text-shaped coding work where price matters more than breadth.

The license boundary

This is the part most coverage gets wrong, and it is the part that decides whether you can legally ship anything. MiniMax has now published two different licenses for two consecutive models, and the difference is the whole story.

We read both license files directly, on the public repositories, in June 2026.

MiniMax M2.7 ships under a NON-COMMERCIAL LICENSE. Non-commercial use is free on MIT-style terms. Commercial use is prohibited without separate, prior written authorization from MiniMax. There is no revenue threshold. If your use is approved, you must prominently display “Built with MiniMax M2.7” in your product, and you request authorization by emailing [email protected] with the subject line “M2.7 licensing.” The license defines “Commercial Use” broadly, including offering products or services for a fee that rely on the software, the commercial use of APIs built on the software, and deploying fine-tuned or modified derivatives for any commercial purpose.

MiniMax M3 ships under a MINIMAX COMMUNITY LICENSE. Same MIT-style free non-commercial grant, but the commercial terms are looser. You still display “Built with MiniMax M3.” Then the threshold appears: if your products or services generate more than $20 million a year in revenue, you need prior written authorization. If you are under that, you only send a one-time notice to [email protected]. For almost any independent developer or small company, that is a notify-and-go arrangement rather than a permission gate.

Step back and the pattern is the actual finding. MiniMax shipped M2 and M2.5 under MIT in late 2025 and early 2026. It tightened M2.7 to a hard non-commercial gate in April, days after its Hong Kong listing, and the developer community pushed back hard, calling the “open source” framing misleading. Then it loosened M3 to a revenue-threshold community license in June. MiniMax’s own license lead acknowledged on the M2.7 discussion page that calling it a “modified MIT license” was a poor choice of framing, and described the intent as free personal use with enterprise use handled case by case through email. Openness here is a lever the company pulls based on competitive position and commercial pressure, not a fixed commitment. If you build on these weights, plan for the terms to move again.

One distinction the broad “it is non-commercial” summaries blur. The non-commercial gate is about the open weights. Using MiniMax’s paid API, whether first-party or through OpenRouter, is a commercial service MiniMax sells you, which is the normal commercial path for most teams. The hard restriction bites when you take the open weights and self-host them in a product that earns money, or build and resell an API on top of them. Where the license language about “commercial use of APIs” lands relative to MiniMax’s own paid API terms, and what rights you have to the generated outputs, are governed by MiniMax’s API terms of service, which we have not separately verified. If your plan depends on those edges, read the API terms before you commit.

Data residency, China risk, and procurement

For a solo developer this section is optional. For anyone running a procurement or security review, it is the section that decides the vendor.

MiniMax runs two separate API endpoints. The global platform at api.minimax.io is operated by Nanonoble Pte. Ltd., a Singapore-registered entity, and falls under Singapore’s Personal Data Protection Act. The Chinese domestic platform at api.minimaxi.com (note the extra “i”) serves the mainland. The keys are not interchangeable, and mixing them is a common source of authentication errors. This structure gives the global endpoint a degree of jurisdictional separation that an all-China-routed provider does not have.

The parent company is still headquartered in Shanghai. The physical server locations for the global endpoint are not publicly documented. MiniMax offers SOC 2 and ISO 27001 reports, but under NDA, and zero-retention modes for enterprise customers. MiniMax is not currently on the U.S. Entity List, though another major Chinese lab, Zhipu AI, was added in 2025, so the individual-targeting risk is not zero for a compliance team modeling worst cases. China’s National Intelligence Law contains provisions whose extraterritorial scope is debated, and that ambiguity itself creates friction in enterprise reviews handling regulated data.

The dependency question is not unique to MiniMax; we reached the same verdict on another cheap, capable Chinese model in our DeepSeek review: strong on the benchmark, risky to build a business on top of.

When you reach M2.7 through the stack we tested, more layers appear, and most of them are configuration choices rather than defaults. OpenRouter’s default routing is global, not EU-pinned; in-region EU routing exists but is an enterprise-tier feature that has to be turned on. OpenRouter lets you restrict routing to providers that do not train on prompts, but that is also not the default. Prompt logging and data-handling settings, and what rights a provider acquires over logged prompts, vary by tier and should be read in the provider’s own terms before sending anything sensitive. At the editor layer, Cline keeps code on your machine unless you connect an external API and you bring your own keys, while Cursor can reach workspace files and credentials, with its privacy mode off by default. We have not payload-inspected any of this. The point is structural: the stack from local repo to provider has several governance switches, most of them off until you flip them, and an enterprise buyer needs to flip and audit them before deployment rather than assume safe defaults.

For data-sensitive teams the cleanest path is self-hosting the open weights behind your own firewall, which removes the residency question and reintroduces the license question and a hardware bill. Running the model unquantized needs roughly 461 GB of VRAM, on the order of seven H100 80GB GPUs; an aggressively quantized 4-bit version needs about 115 to 130 GB, which is where the “128 GB Mac” ceiling comes from. The capital cost is where the cheap-API story and the self-host story stop being the same story.

The M3 caveat: M2.7 is no longer the newest MiniMax coding model

If you are choosing a MiniMax model today, start by knowing that M2.7 is not the current frontier one.

MiniMax released M3 on June 1, 2026. Per MiniMax’s own announcement, it brings three things M2.7 does not have: a context window of up to 1 million tokens, built on a new attention design the company calls MiniMax Sparse Attention; native multimodality, with image and video input and the ability to drive a desktop; and frontier-level coding and agentic performance, which MiniMax reports as 59.0% on SWE-Bench Pro on its own evaluation setup. The open weights are now on Hugging Face under the community license described above.

We have not hands-on tested M3, so we are not going to tell you it is better in practice. What we can say is narrower and still useful for a buyer. If you need long context, image or video input, or the newest license terms, M3 is the model to look at, not M2.7. If your work is text-only, fits comfortably inside 200K tokens, and you want predictable cost on a smaller model that you can self-host on more modest hardware than M3’s larger architecture would need, M2.7 still has a lane. M3’s arrival changes the segmentation more than it makes M2.7 obsolete.

A full head-to-head, with our own benchmark on M3, is a separate piece. We will link it here when it is published.

Who should use M2.7, and who should not

Use it if you run high-volume agentic coding and cost is the constraint. This is the core case. Multi-agent pipelines that fire thousands of tool calls will bleed money on a frontier model’s pricing. M2.7 gives you a cheap, cache-friendly, Anthropic-SDK-compatible model for the routine 80% of coding work, and switching is roughly a one-environment-variable change. Keep a frontier model for the hardest problems and anything involving images. Budget review time for M2.7’s broader edit style.

If you are weighing agentic coding tools more broadly, our Grok Build CLI review covers a different one we ran hands-on, including where its agent keeps going past a task it has already finished.

Use it if you self-host for data control and your use is non-commercial, or you have cleared the license. Behind your own firewall, no data leaves and you get a capable coding model. But the non-commercial license means you cannot ship a revenue-earning product on the self-hosted weights without written permission from MiniMax, and the hardware floor is steep. Treat the email-for-authorization step as part of the project plan, not an afterthought.

Skip it if you need multimodal input, frontier-level breadth, or truly open-source weights. It is text-only, it is strong on narrow tasks rather than across the full surface, and the license is not OSI open source. If any of those is a requirement, M2.7 is not your model.

Skip it, for now, if you have a strict enterprise compliance posture and cannot self-host. Routing regulated data through a China-parented API provider will not clear most security audits without serious work on residency, DPA terms and provider routing controls. If you cannot self-host, the regulatory friction usually outweighs the price advantage.

Skip it for prose, content, or general assistant work. It is a coding and agent tool. For writing, research and broad tasks, a general frontier model will serve you better.

FAQ

Is MiniMax M2.7 as good as Claude Opus 4.8? On FSR’s own three-task TypeScript benchmark, MiniMax M2.7 and Claude Opus 4.8 both passed 10 of 10 hidden grader assertions, run in the same Cline and OpenRouter harness in June 2026. That is parity on narrow, well-specified bug fixes, not a claim that M2.7 matches Opus across general software work.

How much does MiniMax M2.7 cost? As of June 2026, the first-party MiniMax API lists $0.30 per million input tokens and $1.20 output, while OpenRouter lists $0.25 input and $1.00 output across eight providers. Cached input drops to about $0.06 per million. Prices change often, so re-check the provider page before relying on them.

Why is my Cline cost estimate higher than my OpenRouter bill? In FSR’s benchmark, Cline’s in-editor estimates summed to about $1.12 while OpenRouter actually billed $0.56, roughly double. The most likely reason is that the editor meter did not fully reflect prompt-cache discounts; the run hit an 80.9% cache rate. Size budgets from the provider dashboard, not the editor.

Can I use MiniMax M2.7 commercially? Not without permission. M2.7’s open weights ship under a NON-COMMERCIAL LICENSE, with no revenue threshold, so any commercial use of the weights needs prior written authorization from MiniMax, requested at [email protected]. Using MiniMax’s paid API is a separate commercial service. Read the API terms for output and reseller rights.

What is the difference between the M2.7 and M3 licenses? M2.7 carries a hard non-commercial gate: commercial use needs written authorization regardless of size. M3’s community license is looser, commercial use is allowed with a one-time notice under $20 million in annual revenue, and only requires written authorization above that. Both require “Built with MiniMax” attribution for commercial use.

Is MiniMax M2.7 open source? It is open weights, not open source. The weights are publicly downloadable, but the NON-COMMERCIAL LICENSE restricts commercial use, which does not meet the Open Source Initiative definition. MiniMax’s own license lead has agreed the earlier “modified MIT” framing was misleading. Treat it as open-weight with a commercial gate.

Is MiniMax M2.7 safe for EU or enterprise use? That depends on configuration and is not safe by default. MiniMax’s global API processing is China-linked, there is no public DPA for standard accounts, and OpenRouter’s EU routing and no-train provider controls are opt-in. FSR did not verify payload-level handling. Enterprise teams should run a full residency and DPA review first.

What are the best alternatives to MiniMax M2.7? For frontier breadth and multimodal input, Claude Opus 4.8, GPT-5.4 and Gemini 3.1 Pro. For a newer MiniMax model with 1M context and image and video input, MiniMax M3, released June 2026. For self-hosted open weights with permissive commercial terms, look at the Llama and Qwen families.

Does MiniMax M2.7 support images? No. M2.7 is text-only. It accepts text input and produces text output, with no image, audio or video understanding. For multimodal coding work, such as reading a screenshot or a UI mockup, you need a different model. MiniMax’s newer M3 model does support image and video input.

Should I switch from M2.7 to M3? It depends on your needs, and FSR has not yet hands-on tested M3. M3 adds 1M context, native multimodality and a more permissive license. M2.7 stays relevant for text-only work inside 200K tokens and for self-hosting on more modest hardware. A tested head-to-head is a separate review.

Methodology and sources

The benchmark was run by FSR in June 2026. Harness: Cline inside Cursor, both models reached through OpenRouter on default provider routing. The model was shown only an agent-workspace folder; the grader sat in a separate grader folder it never saw. The repository was reset to the same clean, buggy baseline before each task. M2.7 ran as minimax/minimax-m2.7 at thinking budget 1,024; Opus 4.8 as anthropic/claude-opus-4.8 on Adaptive Thinking Low. These thinking settings are comparable in intent, not numerically identical. Costs are reported in two layers that we keep separate throughout: Cline’s in-editor estimate, and OpenRouter’s actual billed spend.

What we did not test: large or messy real-world codebases, long-horizon agent stability, wall-clock solve time, per-task retry counts, the per-model dollar split of the $0.56 bill, individual per-model cache rates, the M2.7-highspeed variant, MiniMax M3 in practice, and payload-level data handling across the stack. Treat any claim beyond the three-task result as out of scope for this benchmark.

Primary and independent sources read for this update, June 2026: the MiniMax M2.7 and M3 license files on their public repositories; the MiniMax M3 announcement; the OpenRouter and Artificial Analysis model pages for M2.7; Kilo Code’s M2.7 vs Opus 4.6 test; and contemporary reporting on the M2.7 license controversy. Company financials are from the Hong Kong Stock Exchange listing and related reporting. Vendor benchmark scores are labeled as vendor-evaluated where that applies.

FSR verdict

Pricing and benchmark figures verified on provider pages as of June 2026. License terms read directly from the MiniMax M2.7 and M3 repositories. This review is updated when the facts change, not on a schedule.