minimax-m2.7: the MiniMax M2.7 agentic model as a metered API

minimax-m2.7 is this platform's serving alias for MiniMax M2.7, the open-weight agentic model MiniMax announced on March 18, 2026. It is a sparse mixture-of-experts model of about 229 billion parameters with roughly 10 billion active per token, built for long coding sessions, tool-calling agents, and multi-step professional work. This page gives the identity facts with their owners, resolves the M2.7 versus M3 family confusion the search results currently spread, states the exact call contract as this gateway enforces it, and gives an honest split between calling it here and running the weights yourself. The route is live on the chat endpoint today.

Last verified: 2026-09-11

What it is

Start with the geometry, because it explains almost everything else about this model. MiniMax M2.7 is a mixture-of-experts design: the official repository's configuration file describes 256 expert modules per layer across 62 layers, with 8 experts activated for each token. In practice that means the model carries about 229 billion parameters in total but engages only around 10 billion of them on any given token, which is why a model this size can serve at the speed it does. Attention is grouped: 48 query heads share 8 key-value heads. Input is text and output is text. There is no image or video input on this model; that capability belongs to MiniMax M3, a different model covered below.

The release story is unusual and worth knowing in the publisher's own words. The announcement post calls M2.7 "our first model deeply participating in its own evolution": during development the model updated its own memory, built skills for its own reinforcement-learning experiments, and an internal version ran more than 100 rounds of optimization on a programming scaffold, improving its own benchmark score by a reported 30 percent. Treat those numbers as the publisher's account of its own work. They are also the origin of the "self-evolving" framing you will see across coverage of this model. The weights went public on Hugging Face in April 2026 and have since passed 1.2 million downloads there.

The facts that matter for planning, each with its owner:

One license row deserves its own warning, because almost no page in the search results states it. The M2.7 weights are public but not open-license in the permissive sense. The repository ships a custom license: non-commercial use is free under MIT-style terms, and any commercial use of the raw weights requires prior written authorization from MiniMax, plus a visible "Built with MiniMax M2.7" credit. For a personal rig, a university lab, or a non-profit, self-hosting is squarely permitted. For a product, read the license before you download. Calling the model through a hosted API, like the route this page describes, leaves that authorization question with the host.

The family map: M2.7, highspeed, and M3

The M2 line has several members and the search results mix them up constantly. The short version, from MiniMax's own model table:

Two confusions come straight out of that table. First, the 1 million token context number you will meet in search results and AI summaries belongs to M3, not to M2.7. On this platform's route, size requests to the served 196,608; the model's official ceiling is 204,800. Second, "highspeed" is not a different model; it is the same weights on a faster serving tier. This platform serves the standard variant under one alias.

One more family fact that trips up buyers: MiniMax operates two portals. The international platform at platform.minimax.io bills in its own currency and serves the OpenAI- and Anthropic-compatible endpoints; the China portal at platform.minimaxi.com is a separate site with separate accounts, and its Chinese-language pages rank even on United States searches for this model. On this platform there is no portal choice to make: one OpenAI-compatible endpoint, one key, and metering against a prepaid wallet.

The context window, precisely

204,800 tokens is the official window: it appears in MiniMax's model table and as the maximum position length in the repository's configuration file. This platform serves 196,608: the registry's standing rule derives the served window as the lowest common window across the failover chain, and the pinned serving leg's limit is 196,608, the same 192K-class figure llama.cpp-based stacks default to. A live probe on 2026-08-20 (the platform's task-6 context probe) verified the route's window behavior on the chain of that day, whose common window equaled the official figure; the registry row is the number to size against today. Numbers you may have seen elsewhere: "200K" and "205K" are roundings of the official 204,800, and "1M" is M3's window appearing on the wrong model's pages.

Thinking: always on, no knob

M2.7 reasons between its steps. This is interleaved thinking: the model alternates short passages of reasoning with text and tool calls, instead of doing all its thinking up front. Two things follow, and both are stated by MiniMax's own documentation. First, thinking cannot be switched off: for the M2.x family the model thinks by design, and there is no mode toggle. Second, in the native OpenAI-format response the thinking text arrives inside the content field between <think> and </think> tags. On MiniMax's own platform a parameter called reasoning_split can move that text into separate fields; that parameter belongs to their platform and is not part of this one's contract. The practical rules for this route, including what happens if you send a reasoning effort parameter anyway, are in the API usage section.

Use cases

The model's record, publisher-run and independently sampled, points at specific jobs:

• Coding agents and supervised refactors. This is the center of gravity. The publisher's benchmark set is dominated by software engineering (SWE-Pro at 56.22 percent, Terminal Bench 2 at 57.0 percent), and independent evals at vals.ai rank it tenth on SWE-bench Verified. Hands-on accounts describe a model that is strong when a task has clear boundaries and explicit constraints, and shakier when the task requires it to infer the constraints itself.
• Long multi-turn tool workflows. The training goal is endurance: many sequential tool calls, stable instruction adherence over long sessions, and recovery when a call fails. The publisher reports a 97 percent skill-adherence rate across more than 40 complex skills, each over 2,000 tokens of instructions.
• Log analysis and incident work. The publisher's positioning emphasizes correlating monitoring metrics, tracing failures to root causes, and making operations-style decisions. Treat the dramatic versions of these claims as marketing until your own logs agree.
• Document generation. The publisher's GDPval-AA result frames office work: drafts, revisions, and deliverables in Word, Excel, and PowerPoint formats from agentic sessions. Independent finance-agent evals are more mixed, so keep a human review pass for anything factual.
• Claude Code-style harnesses. The M2 family is a popular stand-in engine in agent CLIs. MiniMax ships an Anthropic-compatible endpoint for exactly this; on this platform the OpenAI-compatible shape below drops into any harness that lets you set a base URL and a model name.

What it is not for: image or video input (M3 territory), tasks that need thinking switched off to save tokens (the model has no thinking switch at all), and unsupervised open-ended strategy work, where every hands-on account says a stronger model or a human should decide direction.

Local or hosted: the honest split

The weights are public, so the local question is real. The split:

Run it locally when you have a 128 GB-class unified-memory machine and a non-commercial use case. The full bf16 weights take about 457 GB, which is datacenter territory. A dynamic 4-bit quantization, the common local route, lands around 108 GB and runs at usable speeds on a 128 GB machine, or faster with a 16 GB GPU alongside 96 GB of system memory. The model card ships deployment guides for SGLang, vLLM, and Transformers, and Ollama's library lists the model with one-line launchers for Claude Code and OpenCode. Two local warnings from the ecosystem: the Ollama entry's run commands use the :cloud variant, which is served remotely rather than run from local weights, and llama.cpp-based stacks default to a 196,608-token window, below the model's 204,800. And the license: free for personal, academic, and non-profit use; written authorization required for commercial use of the raw weights.

Call the hosted route when there is no such machine, traffic is bursty, or you would rather have metering, a revocable key, and a billing ledger wrapped around the model than a serving stack to own. That list is the substance of what this platform does for the model: a pinned route on the chat endpoint, per-token metering against a prepaid wallet, keys you can revoke the moment one leaks, and a cost field on every response.

API usage

The route is POST /v1/chat/completions, OpenAI-compatible in shape, authorized with a Bearer key minted on the console. The model id is minimax-m2.7.

The table lists the fields you will use; it is not the whole accepted set. Accepted top-level parameters also include stop, seed, n, frequency_penalty, presence_penalty, logit_bias, user, stream_options, metadata, logprobs, and top_logprobs, and any key outside the accepted set returns a named parameter error. Two known parameters, store and service_tier, return a clear not-supported error rather than being silently ignored.

Four laws of this route that save debugging time:

1. There is no thinking knob. The platform contract exposes no thinking parameter for this model. If you send reasoning_effort, the gateway answers with a named error: the parameter is not supported on this model. This is not an accident of wiring; the model family has no thinking switch by design, and MiniMax's own documentation says thinking cannot be disabled for M2.x models. MiniMax's platform-specific reasoning_split parameter is likewise outside the accepted set here. Budget for the thinking tokens: they are part of the output and are metered as output.
2. Preserve the full assistant message in multi-turn tool calls. The thinking text arrives between <think> tags inside content. When you send the conversation back for the next turn, append the complete previous assistant message, think block included, and the complete tool result. MiniMax's integration note is explicit: dropping the model's reasoning from the history breaks the continuity of the reasoning chain. Strip tags for display, never for history.
3. Every response carries your cost. Inside usage sits cost, the retail charge for that call at this platform's rates, derived from input, cached-input, and output token counts. The same transaction that logs the call debits the prepaid wallet; the balance left after it is what the next request is checked against, and past an empty balance that request is refused with a named error. Cached tokens bill at their own rate and are reported separately. Per-key spend caps have not shipped; per-key revocation is live. Current rates live on the pricing page, and the public /v1/models endpoint lists this model's window without a key.
4. The served window is 196,608, exactly. That is the registry's chain-min derivation; the model's official ceiling is 204,800. A request sized above the served window is rejected, not truncated. Deep fresh contexts also take time to prefill before the first token, so set client timeouts with headroom on long jobs, and keep a stable prefix across turns where you can, because cached input is cheaper than fresh input.

curl

curl -X POST "https://api.ironstratum.com/v1/chat/completions" \
  -H "Authorization: Bearer $KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "minimax-m2.7",
    "messages": [
      {"role": "user", "content": "Find the off-by-one error in this loop and explain the fix."}
    ],
    "max_tokens": 2048
  }'

python

import os
import re
import requests

THINK = re.compile(r"<think>.*?</think>", re.S)

resp = requests.post(
    "https://api.ironstratum.com/v1/chat/completions",
    headers={"Authorization": "Bearer " + os.environ["KEY"]},
    json={
        "model": "minimax-m2.7",
        "messages": [
            {"role": "user", "content": "Summarize the last 200 lines of this service log, then list likely root causes."}
        ],
        "tools": [
            {
                "type": "function",
                "function": {
                    "name": "fetch_log",
                    "description": "Fetch the tail of a service log",
                    "parameters": {
                        "type": "object",
                        "properties": {"service": {"type": "string"}, "lines": {"type": "integer"}},
                        "required": ["service"],
                    },
                },
            }
        ],
        "tool_choice": "auto",
        "max_tokens": 2048,
    },
    timeout=180,
)
resp.raise_for_status()

message = resp.json()["choices"][0]["message"]
if message.get("tool_calls"):
    call = message["tool_calls"][0]
    print(call["function"]["name"], call["function"]["arguments"])
else:
    # Thinking arrives between think tags inside content. Strip it for
    # display only; keep the raw content when you build the next turn.
    print(THINK.sub("", message["content"]).strip())
print("cost:", resp.json()["usage"]["cost"])

openai-sdk

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.ironstratum.com/v1",
    api_key=os.environ["KEY"],
)

response = client.chat.completions.create(
    model="minimax-m2.7",
    messages=[
        {"role": "user", "content": "Draft a rollback plan for a failed database migration."},
    ],
    temperature=1.0,
    top_p=0.95,
    max_tokens=2048,
)

print(response.choices[0].message.content)
print("cost:", response.usage.cost)

For an existing OpenAI-SDK integration, only two lines change: the base URL and the model id.

Benchmarks

Two evidence layers follow, each dated, each with its basis stated.

This platform's route. The served window follows the registry's chain-min derivation; a live probe on 2026-08-20 verified the route's window behavior on the chain of that day, and the measurement record is the platform's task-6 context probe log.

The model itself. From the official model card and announcement, publisher-reported. Where the publisher names a comparison, the comparison is theirs.

Read that table with its label on: it is the publisher's own run on named harnesses, several of which the publisher built or curated. The independent layer is thinner but agrees on the shape. The eval service vals.ai ranks M2.7 tenth on SWE-bench Verified and twelfth on Terminal-Bench 2.0, where it comes in ahead of its predecessor M2.5, while scoring it lower on finance-agent tasks. Community comparisons against DeepSeek V4 Flash split by axis. DeepSeek reaches its first token faster; M2.7 generates faster once it has started, and it wins praise for endurance in long tool sessions and day-to-day coding. None of this settles a workload question. Run your own tasks, on this route or any other, before you standardize.

Getting started

1. Open an account on the console. Registration runs through the invite flow while the beta lasts; the wallet and your keys are held there.
2. Issue an API key. Scope one key to each project: keys revoke independently, so a leaked one is cut off while the others keep serving. The wallet balance caps spend today; per-key caps are roadmap.
3. Check the rate. The pricing page publishes all three metered legs, input, cached input, and output, and the usage.cost field on each response shows what the call cost so far.
4. Make the first call. Take the curl tab, set KEY in your shell, and try a short prompt. An answer wrapped in think tags means thinking ran; anything bigger is only more entries in the messages array.

For deep fresh-context calls, set your client timeout past the first-token wait. The rest of the chat catalog sits on the chat category page, and the models index tracks everything the platform serves.