Last verified: July 16, 2026.
MiniMax M2.5 is an open-weight M-series language model released for coding, agentic tool use, search, and office productivity workflows. Its hosted MiniMax API identifiers are MiniMax-M2.5 and MiniMax-M2.5-highspeed. Its self-hosted repository identifier is MiniMaxAI/MiniMax-M2.5. Those identifiers are not interchangeable across every provider.
This page is for developers maintaining an M2.5 integration, reproducing an earlier evaluation, reviewing its open-weight license, or planning a migration. It does not target the broad “MiniMax AI” entity query handled by the site’s homepage.
Legacy model notice: MiniMax’s API model catalog classifies MiniMax-M2.5 and MiniMax-M2.5-highspeed as legacy language models. They remain listed in the API and pricing documentation reviewed for this page, but teams beginning an integration should evaluate M3 and M2.7 before choosing M2.5. No first-party retirement date for M2.5 was located in the reviewed documentation.
Independent guide: MiniMax-AI.chat is not owned, operated, or endorsed by MiniMax. This historical integration guide summarizes first-party material and does not replace the official model catalog, API schemas, licenses, or billing console.
MiniMax M2.5 decision summary
| Question | Verified answer |
|---|---|
| Is M2.5 a non-legacy API model? | No. MiniMax places it in the legacy section of the language-model catalog. |
| Can an existing MiniMax API integration still call it? | It remains listed by exact model ID in the API and pricing pages reviewed on July 16, 2026. Confirm access with the Models API for your credential. |
| What is the hosted API context window? | 204,800 total input-and-output tokens in MiniMax’s OpenAI SDK and API overview documentation. |
| Does it accept image or video input? | No. MiniMax documents M2.5 as text and tool-call capable; image and video input are documented for M3. |
| Can thinking be disabled? | No. MiniMax states that thinking cannot be disabled for M2.x models. |
| Is it open source? | Use the more precise term open-weight. Model materials and repository code have separate licenses. |
| Should a fresh project start with M2.5? | Usually not without a measured reason. Compare M3 and M2.7 on the application’s own tasks, cost, latency, and response format. |
What MiniMax M2.5 was designed to do
MiniMax announced M2.5 on February 12, 2026 as a model for real-world productivity. The official M2.5 release article emphasizes four areas:
- Coding: repository-level software work, planning, implementation, review, and testing.
- Search and tool use: multi-step agents that choose tools, inspect results, and continue a task.
- Office work: structured Word, PowerPoint, Excel, research, and financial-modeling workflows inside an agent scaffold.
- Efficiency: reducing time and token use for long agent trajectories rather than optimizing only short answers.
Those are release-positioning claims, not guarantees for an untested application. M2.5 does not include MiniMax Agent’s surrounding skills, browser, file tools, Office integrations, or execution environment by itself. A raw model call produces model output; your application must provide tools, permissions, state, validation, and safety controls.
Verified MiniMax M2.5 specifications
| Specification | MiniMax M2.5 | Interpretation |
|---|---|---|
| MiniMax API model ID | MiniMax-M2.5 | Standard hosted API route |
| Faster API model ID | MiniMax-M2.5-highspeed | Higher-speed, higher-priced hosted route |
| Open-weight repository ID | MiniMaxAI/MiniMax-M2.5 | Used by supported self-hosted inference frameworks |
| API status | Legacy | Listed below M3 and M2.7 in the model catalog |
| Hosted API context | 204,800 tokens | Total input and output, not a recommended prompt size |
| Self-hosted sequence limit in the official vLLM guide | 196K tokens | Separate from the hosted MiniMax API limit |
| Input and output | Text input, text output, and tool calls | No documented image or video input for M2.5 |
| Thinking behavior | Thinking cannot be disabled | reasoning_split changes formatting, not whether reasoning runs |
| Hosted protocols | OpenAI-compatible and Anthropic-compatible | Use the schema for the chosen protocol |
| Open-weight status | Weights and deployment resources are published | Use is still governed by license terms |
The official MiniMax model catalog is the source for legacy classification. The catalog describes M2.5 as optimized for code generation and refactoring and lists M2.5-highspeed as the faster-serving variant.
How to interpret the context window
The hosted MiniMax API lists a 204,800-token context window for both M2.5 identifiers. MiniMax defines this as the combined input and output budget. It does not mean every request should approach that ceiling.
- Reserve space for the response, thinking content, tool definitions, tool results, and conversation history.
- Large prompts increase latency and cost and can reduce the model’s ability to identify relevant evidence.
- Third-party hosts and self-managed runtimes may expose a different sequence limit.
- For local vLLM deployment, MiniMax’s guide specifies 196K as the maximum context length per individual sequence.
- Use retrieval, summarization, and context budgeting instead of filling the window indiscriminately.
A migration test should use the real distribution of prompt sizes, not only a single maximum-context demonstration.
Historical benchmark claims and their limits
The first-party MiniMax M2.5 repository reports the following launch-era results:
| Evaluation | MiniMax-reported M2.5 result | Methodology warning |
|---|---|---|
| SWE-Bench Verified | 80.2% | MiniMax says SWE evaluations used internal infrastructure, Claude Code scaffolding, prompt changes, and averaging over four runs. |
| Multi-SWE-Bench | 51.3% | Agent harness, tools, timeouts, and repository environment materially affect results. |
| BrowseComp with context management | 76.3% | The repository says a specific WebExplorer-style framework discarded history after a context threshold. |
These are self-reported release results, not benchmarks run by MiniMax-AI.chat. They describe a model-plus-scaffold setup and should not be presented as an application success rate. Compare models with the same prompt, tool set, repository state, timeout, retry policy, context policy, and scoring rubric.
MiniMax M2.5 API access
For the hosted MiniMax platform, the verified OpenAI-compatible base URL is https://api.minimax.io/v1. Use POST /v1/chat/completions for Chat Completions. MiniMax also documents an Anthropic-compatible base URL at https://api.minimax.io/anthropic, which resolves Messages calls to POST /anthropic/v1/messages.
Before relying on a legacy model, query GET /v1/models with the same credential and environment used by the application. Catalog presence, account access, balance, and a successful test request are separate checks.
export MINIMAX_API_KEY="replace-with-a-server-side-secret"
curl --request POST \
--url https://api.minimax.io/v1/chat/completions \
--header "Authorization: Bearer ${MINIMAX_API_KEY}" \
--header "Content-Type: application/json" \
--data '{
"model": "MiniMax-M2.5",
"messages": [
{
"role": "system",
"content": "You are a careful software engineering assistant."
},
{
"role": "user",
"content": "List the regression risks in this change plan."
}
],
"reasoning_split": true,
"max_completion_tokens": 800,
"temperature": 1.0,
"top_p": 0.9
}'The request uses values accepted by MiniMax’s OpenAI-compatible API. It is a connectivity example, not a universal parameter recommendation. The self-hosted M2.5 repository separately recommends temperature=1.0, top_p=0.95, and top_k=40 for its own deployment path; hosted OpenAI-compatible documentation gives M2.x a default top_p of 0.9. Preserve provider-specific settings instead of copying one configuration between runtimes.
For a durable endpoint map and authentication reference, see our MiniMax API reference. For backend architecture, retries, streaming, observability, and evaluation, use the production application tutorial.
Thinking output and multi-turn behavior
M2.5 is an M2.x reasoning model. MiniMax’s OpenAI SDK compatibility documentation states that M2.x thinking cannot be disabled. Sending thinking: {"type":"disabled"} is accepted, but thinking still runs.
- Without
reasoning_split, the native Chat Completions content can contain<think>...</think>material. - With
reasoning_split: true, thinking is separated into reasoning fields; the setting changes the output format rather than disabling reasoning. - Do not display internal reasoning fields automatically in a user interface or send them to unrestricted analytics.
- In multi-turn tool conversations, MiniMax instructs developers to append the complete assistant response, including tool-call and reasoning fields required for continuity.
- The deprecated
function_callparameter is unsupported; usetools.
If an existing application strips <think> text with a fragile regular expression, replace that behavior with the documented split format and a tested response parser before migration.
Tool calling with M2.5
M2.5 supports tool calls, but the model’s request is not permission to execute an operation. Validate the tool name and JSON arguments, apply user and tenant authorization, use least-privilege credentials, and require confirmation for destructive, financial, publishing, account, or person-directed actions.
For self-hosting, MiniMax’s M2.5 tool-calling guide recommends using supported vLLM or SGLang parsers rather than manually parsing the model’s XML-style raw format. If a runtime lacks an integrated parser, treat its custom parsing path as security-sensitive code and test malformed, duplicated, unknown, and oversized arguments.
MiniMax M2.5 API pricing
The official pay-as-you-go table places both M2.5 routes under Legacy Models. Prices verified on July 16, 2026 are:
| Model ID | Input per 1M tokens | Output per 1M tokens | Cache read per 1M | Cache write per 1M |
|---|---|---|---|---|
MiniMax-M2.5 | $0.30 | $1.20 | $0.03 | $0.375 |
MiniMax-M2.5-highspeed | $0.60 | $2.40 | $0.03 | $0.375 |
Documentation conflict: the PAYG table above lists M2.5-highspeed input at $0.60 per million tokens, while MiniMax’s separate Anthropic explicit prompt-caching page displayed $0.30 for the same input column when verified. Treat the PAYG figure as the source for this table, but confirm the charge shown for your protocol, key type, and account in the billing console before relying on it.
These are MiniMax platform figures, not universal prices for every host. Billing also depends on the actual token count, cache behavior, retries, tool loops, and failed work. Verify the billing console before a purchasing decision and use our MiniMax pricing guide for broader cross-modality context.
Open-weight access and self-hosting
MiniMax publishes M2.5 weights and model resources through the organization’s M2.5 Hugging Face repository. That makes self-managed inference possible, but M2.5 is not a consumer-device model.
| Item in MiniMax’s vLLM guide | Published figure or example | What it means |
|---|---|---|
| Operating system | Linux | The documented path assumes a Linux GPU server. |
| Python | 3.9–3.12 | Use a clean environment and pin tested dependencies. |
| Weights memory | 220 GB | Only one part of the total serving requirement. |
| KV cache estimate | 240 GB per 1M aggregate context tokens | Concurrency and context length materially affect memory. |
| Example configuration | Four 96 GB GPUs | Listed for 400K aggregate KV-cache capacity, not 400K per request. |
| Larger example | Eight 144 GB GPUs | Listed for up to 3M aggregate KV-cache capacity. |
| Per-sequence limit | 196K tokens | Remains separate from aggregate cache capacity. |
These are guide figures, not a guaranteed minimum or capacity promise for every quantization, runtime version, GPU, traffic pattern, or tool parser. Review the official vLLM deployment guide, verify hardware compatibility, and benchmark expected concurrency and context lengths.
Self-hosting does not automatically make a workflow private or compliant. Privacy depends on the complete runtime: hosting provider, network, telemetry, model server, plugins, tool calls, logs, databases, backups, access controls, retention, and incident response. The official command uses --trust-remote-code; security teams should inspect and pin the code revision rather than executing unreviewed remote code in a privileged environment.
MiniMax M2.5 licensing: weights and code are different
Calling M2.5 simply “modified MIT” is inaccurate. The official repository separates the terms:
| Material | Governing file | Important conditions to review |
|---|---|---|
| Model weights and related Model Materials | MiniMax Model License | Limited worldwide royalty-free rights; agreement and modification notices for covered distribution or services; required attribution; legal compliance; prohibited-use policy; termination provisions; no general trademark license. |
Software covered by LICENSE-CODE in the GitHub repository | Modified MIT code license | MIT-style software rights plus a requirement to display “MiniMax M2.5” prominently in the user interface when the software or derivatives are used for a commercial product or service. |
The Model License also contains prohibited-use restrictions, including military purpose, harming minors, harmful deception, unauthorized personal information, and fully automated decisions that adversely affect legal rights or create or modify binding obligations. Read the complete files; this summary is not legal advice and does not determine whether a particular product, derivative, redistribution, or hosted service complies.
Because LICENSE-MODEL defines Model Materials broadly enough to include certain code and scripts, do not assume that every code file in every M2.5 distribution is governed by LICENSE-CODE. Confirm the license attached to the specific artifact.
Recommended description: “MiniMax M2.5 is open-weight. The weights and related Model Materials are governed by the MiniMax Model License, while the repository code is governed separately by a modified MIT license.”
Should an existing integration stay on M2.5?
| Reason to keep it temporarily | Reason to migrate |
|---|---|
| A regulated change process requires regression evidence before replacing a model. | M2.5 is marked legacy and has no documented image or video input. |
| A reproducibility workflow depends on M2.5 outputs or an M2.5-specific self-hosted stack. | M2.7 appears outside the legacy section as a 204,800-token text/tool model with a highspeed variant. |
| The application has measured M2.5 behavior and has not completed replacement testing. | M3 adds a one-million-token hosted context window, supported image/video input, and controllable thinking. |
| A cost model depends on M2.5 cache-read pricing and the measured workload supports the choice. | Operating a legacy dependency increases change and availability risk even without an announced retirement date. |
“Legacy” does not mean “broken” or “immediately unavailable.” It means a fresh design should not choose M2.5 merely because an older tutorial used it. Review MiniMax M2.7 for text and tool workflows and MiniMax M3 for long-context and supported multimodal requirements.
Do not assume that M2.5 license rights carry over to M2.7 or M3. Review the hosted API terms and the weight license of each replacement separately.
Migration path from M2.5 to M2.7 or M3
| Behavior | M2.5 | M2.7 | M3 |
|---|---|---|---|
| Catalog status | Legacy | Listed outside the legacy section | Listed outside the legacy section |
| Hosted context | 204,800 | 204,800 | 1,000,000 |
| Image/video input through language API | No | No | Yes, using documented content parts |
| Thinking disabled option | No | No | Yes |
| Tool calls | Yes | Yes | Yes, including M3-specific interleaved-thinking guidance |
- Inventory: record every model ID, endpoint, protocol, parameter, prompt, parser, cache setting, tool schema, context policy, and fallback.
- Build a fixed evaluation set: include ordinary tasks, long prompts, tool calls, refusals, malformed input, prompt injection, timeouts, and cost-sensitive cases.
- Change only the model first: use a staging feature flag and preserve the M2.5 route as a rollback while comparing results.
- Test reasoning format: M2.7 still cannot disable thinking; M3 can. Verify
reasoning_split, streaming chunks, stored conversation state, and the user-visible answer. - Test tools: compare tool selection, argument validity, parallel calls, confirmation gates, maximum turns, and recovery from a failed tool.
- Recalculate context and cost: a larger window is not permission to send unbounded data. Re-estimate tokens, cache behavior, output, retries, and service-tier choices.
- Measure quality and operations: record task success, accepted code, groundedness, P50/P95 latency, error rate, retries, and cost per successful task.
- Canary: send a small authorized share of traffic to the replacement, watch failure and cost thresholds, then increase gradually.
- Remove the dependency: after the rollback window, remove M2.5-specific prompts, parsers, alerts, and secrets that are no longer needed.
Monitor the official API release notes for availability or behavior changes. Do not wait for a retirement notice before creating a tested migration path.
M2.5 evaluation checklist
- Task quality: Does it solve the application’s real coding, search, or office tasks?
- Tool reliability: Are names and arguments valid, authorized, and efficient?
- Grounding: Does it distinguish retrieved evidence from its own inference?
- Long context: What happens at median, P95, and maximum prompt sizes?
- Reasoning format: Are thinking fields preserved where required and hidden from inappropriate destinations?
- Latency: Compare standard and highspeed routes at realistic concurrency.
- Cost: Include input, output, caching, retries, tool loops, and failed tasks.
- Security: Test prompt injection, tool escalation, cross-tenant access, secret leakage, and malicious retrieved content.
- Migration risk: Confirm that M2.7 or M3 can replace the model without silent parser or prompt failures.
For coding-specific tests, our MiniMax code-generation guide defines the use-case boundaries. For provider failures, use the MiniMax API error guide.
MiniMax M2.5 limitations
- Legacy status: availability without a published shutdown date is not a long-term support guarantee.
- Text-focused hosted interface: M2.5 does not receive the image/video input documented for M3.
- Thinking cannot be disabled: applications must handle reasoning format and associated token use.
- Benchmark dependence: release scores used specified scaffolds and internal infrastructure.
- Large self-hosting footprint: weights, KV cache, concurrency, and redundancy require substantial GPU memory.
- Tool risk: a model can select the wrong tool or construct unsafe arguments; authorization belongs in application code.
- Hallucination and coding errors: generated facts, commands, patches, tests, and office deliverables require validation.
- License obligations: open-weight access is not permission to ignore notices, prohibited uses, attribution, or code-license conditions.
MiniMax M2.5 FAQ
Is MiniMax M2.5 still available through the MiniMax API?
It remains listed in the API model and pricing documentation reviewed on July 16, 2026, under Legacy Models. Check GET /v1/models and run an authorized test with the exact production credential. No first-party retirement date was found during this review.
What are the exact hosted model IDs?
Use MiniMax-M2.5 for the standard route and MiniMax-M2.5-highspeed for the faster route. A self-hosted repository commonly uses MiniMaxAI/MiniMax-M2.5 instead.
What is the MiniMax M2.5 API context window?
MiniMax lists 204,800 total input-and-output tokens for the hosted API. Its vLLM deployment guide lists a 196K maximum per individual self-hosted sequence. Use the figure for the serving path being tested.
Can thinking be turned off for M2.5?
No. MiniMax says thinking cannot be disabled for M2.x models. reasoning_split separates reasoning from answer content; it does not stop reasoning.
Is MiniMax M2.5 open source?
Describe it as open-weight. The weights and related Model Materials use the MiniMax Model License. Repository software uses a separate modified MIT code license. Review both before use, redistribution, modification, fine-tuning, or a commercial service.
Should a project use M2.5-highspeed?
Only after measuring the tradeoff. MiniMax lists the highspeed route at twice M2.5’s input and output token price, with the same cache-read and cache-write price in the verified table. Compare end-to-end task time and cost per successful task.
Can MiniMax M2.5 run on a consumer laptop?
Not through the full-precision deployment path described by MiniMax. The official vLLM guide discusses hundreds of gigabytes for weights and KV cache and uses multi-GPU server examples. Quantized or third-party options require their own accuracy, license, and security review.
Final assessment
MiniMax M2.5 remains useful as a historical model, an existing API dependency, a reproducibility target, or an open-weight self-hosting project. Its verified strengths are its coding-and-agent positioning, tool-call support, 204,800-token hosted context, two API speed routes, prompt-cache pricing, and published weights.
Its legacy status changes the decision for fresh development. Start by evaluating M2.7 for text and tool workflows or M3 for longer context and supported multimodal input. Keep M2.5 only when measured quality, compatibility, reproducibility, licensing, infrastructure, or cost evidence justifies the choice—and maintain a tested migration path.