MiniMax M1, also written as MiniMax-M1, is an open-weight reasoning LLM from MiniMax. It is built for long-context reasoning, software engineering, mathematical reasoning, and agent-style tasks that require large inputs and multi-step analysis. The main reasons people search for MiniMax M1 are its 1 million token context window, hybrid-attention architecture, Mixture-of-Experts design, reported benchmark results, and developer access through model repositories, serving frameworks, and API providers. MiniMax’s technical materials describe MiniMax-M1 as a hybrid Mixture-of-Experts reasoning model with Lightning Attention, 456B total parameters, and 45.9B active parameters per token.
Last updated: June 2026. MiniMax M1 remains useful as an open-weight long-context reasoning model, but MiniMax’s current API documentation now lists MiniMax-M3 as the latest M-series model and lists M2.7, M2.5, M2.1, M2, and M2-her for supported API workflows rather than MiniMax-M1. Treat M1 API availability and pricing as route-specific or historical unless the provider you use currently lists it.
Quick answer
- What it is: An open-weight reasoning large language model.
- Who created it: MiniMax AI.
- Main architecture: Hybrid Mixture-of-Experts with Lightning Attention.
- Context window: 1 million tokens.
- Model variants: MiniMax-M1-40k and MiniMax-M1-80k.
- Best-fit workloads: Long-document analysis, code reasoning, math, research synthesis, and agent workflows.
- Main caution: Performance, context limits, latency, pricing, tool support, and current API availability depend on the provider or deployment stack; MiniMax’s current API docs emphasize M3 and M2-series routes rather than M1.
What Is MiniMax M1?
MiniMax M1 is a reasoning-focused LLM designed to process large inputs and produce extended, structured answers. In simple terms, it is a model built for tasks where the user may need the model to read a long document, inspect a large codebase, follow a chain of instructions, use tools, or solve complex math and engineering problems.
In most discussions, “MiniMax M1” and “MiniMax-M1” refer to the same model family/name. The hyphenated version is common in technical repositories and model cards, while the space-separated version is common in search queries, articles, and API listings.
The model is especially relevant because it combines several design choices: a 1M context window, Mixture-of-Experts routing, Lightning Attention, reinforcement learning, and two thinking-budget variants. MiniMax’s arXiv report says MiniMax-M1 is trained with large-scale reinforcement learning across tasks that include mathematical reasoning and real-world software engineering environments.
MiniMax M1 Key Specifications
| Specification | MiniMax M1 Details |
|---|---|
| Developer | MiniMax |
| Model type | Open-weight reasoning LLM |
| Architecture | Hybrid Mixture-of-Experts + Lightning Attention |
| Total parameters | 456B |
| Active parameters per token | 45.9B |
| Context window | 1 million tokens |
| Current MiniMax API docs status | MiniMax’s current Model Invocation docs list MiniMax-M3 as the latest M-series model and list M2.7, M2.5, M2.1, M2, and M2-her as supported text routes; MiniMax-M1 is best treated as an open-weight or historical M1 route unless a selected provider currently exposes it. |
| Variants | MiniMax-M1-40k and MiniMax-M1-80k |
| Training method | Large-scale reinforcement learning with CISPO |
| Typical focus | Long-context reasoning, software engineering, math, tool and agent workflows |
Provider-specific limits, pricing, API features, tool-calling behavior, and deployment requirements may vary. For example, OpenRouter currently lists MiniMax M1 as a hosted model with a 1M context window and provider-based routing, while MiniMax’s current Model Invocation docs no longer present M1 in the main supported-model table and instead emphasize MiniMax-M3 and M2-series models. The official GitHub and Hugging Face materials remain the best sources for M1 weights, architecture, benchmarks, function-calling notes, and deployment guidance.
How MiniMax M1 Works
MiniMax M1 is easiest to understand as a model that tries to balance scale, long-context processing, and reasoning efficiency.
Hybrid-attention means the model does not rely on one attention pattern alone. Traditional attention is powerful, but expensive for very long sequences because compute grows rapidly as the input becomes longer. MiniMax-M1 uses a hybrid design that combines attention approaches to make long-context processing more practical.
Mixture-of-Experts, or MoE, means the model has many expert subnetworks but only activates a subset for a given token. This allows the model to have a very large total parameter count while using fewer active parameters per token. According to the official repository, MiniMax-M1 has 456B total parameters and 45.9B active parameters per token.
Lightning Attention is the mechanism that supports efficient long-context and long-output reasoning. MiniMax reports that Lightning Attention enables more efficient scaling of test-time compute, especially when the model generates long reasoning outputs. The arXiv report describes this as a key reason MiniMax-M1 is suitable for long inputs and extended thinking.
Test-time compute refers to the compute used while the model is answering, not only while it is trained. A reasoning model can use more generated tokens internally or externally to work through hard tasks. MiniMax-M1’s 40K and 80K thinking-budget variants are part of this design.
CISPO, or Clipped IS-weight Policy Optimization, is MiniMax’s reinforcement learning method for improving training efficiency. MiniMax’s technical report says CISPO clips importance sampling weights rather than token updates, and the official announcement describes it as a faster reinforcement learning algorithm for the M1 training setup.
A simple analogy: if a standard dense model is like asking one huge team to work on every request, MoE is like routing each request to the specialists most relevant to the task. Lightning Attention is the system that helps the team handle very large files without spending all its effort just keeping track of the file.
MiniMax-M1-40k vs MiniMax-M1-80k
MiniMax provides two main thinking-budget variants: MiniMax-M1-40k and MiniMax-M1-80k. The difference is not just a naming detail. It reflects the amount of reasoning budget associated with each model variant.
The 80K variant is designed for a larger thinking budget. The 40K variant represents a smaller reasoning budget and, according to the arXiv abstract, an intermediate phase of the 80K training.
| Variant | Thinking Budget | Expected Reasoning Depth | Typical Use Cases | Cost/Latency Considerations | When to Choose It |
|---|---|---|---|---|---|
| MiniMax-M1-40k | 40K | Extended reasoning, but with a smaller budget | Long document Q&A, code review, research summaries, structured analysis | May be more practical when the full 80K reasoning budget is unnecessary | Choose it for balanced reasoning, latency, and cost |
| MiniMax-M1-80k | 80K | Deeper extended reasoning | Hard math, complex coding tasks, software engineering workflows, multi-step tool use | Can require more output budget and may increase latency or cost depending on the provider | Choose it when task difficulty justifies more reasoning budget |
The 80K version reports higher results than the 40K version on many benchmarks, but that does not mean it is always the better choice. The official table also shows the 40K variant ahead on some long-context and TAU-bench rows, so production choice should depend on task difficulty, context size, expected output length, latency requirements, and budget.
Why the 1 Million Token Context Window Matters
A 1 million token context window means MiniMax M1 can accept very large inputs compared with many LLM workflows. In practice, this can be useful for:
| Workload | Why the 1M Context Helps |
|---|---|
| Large documents | The model can inspect long reports, manuals, research papers, or policy files in fewer chunks. |
| Long codebases | Developers can include more files, architecture notes, stack traces, and tests in one request. |
| Multi-file repositories | The model can reason across related files rather than treating each file as isolated. |
| Legal or technical research | Long context helps when arguments, clauses, definitions, and exceptions are spread across many pages. |
| Long conversations | A larger context can preserve more prior instructions, decisions, and constraints. |
| RAG workflows | Retrieval systems can pass larger evidence sets to the model for synthesis. |
Long context does not automatically guarantee perfect recall, perfect reasoning, or perfect citation behavior. Large inputs still need structure. The user should label sections, filenames, document titles, dates, and task goals clearly. For critical workflows, outputs should be checked against source material.
MiniMax M1 Benchmarks and Reported Performance
MiniMax reports MiniMax-M1 results across categories such as competition math, coding, software engineering, reasoning and knowledge, long-context tasks, agentic tool use, factuality, and general assistant evaluation. The official GitHub table includes benchmarks such as AIME, MATH-500, LiveCodeBench, SWE-bench Verified, GPQA Diamond, OpenAI-MRCR, TAU-bench, and SimpleQA. These are reported benchmark results from MiniMax’s technical materials, not universal guarantees for private workloads.
| Benchmark | MiniMax-M1-80k | MiniMax-M1-40k |
|---|---|---|
| AIME 2024 | 86.0 | 83.3 |
| AIME 2025 | 76.9 | 74.6 |
| MATH-500 | 96.8 | 96.0 |
| LiveCodeBench | 65.0 | 62.3 |
| GPQA Diamond | 70.0 | 69.2 |
| SWE-bench Verified | 56.0 | 55.6 |
| OpenAI-MRCR 128k | 73.4 | 76.1 |
| OpenAI-MRCR 1M | 56.2 | 58.6 |
| TAU-bench airline | 62.0 | 60.0 |
| TAU-bench retail | 63.5 | 67.8 |
| SimpleQA | 18.5 | 17.9 |
These scores suggest that MiniMax M1 is especially relevant for long-context reasoning, software engineering, and tool-use scenarios. However, benchmark tables are only one part of model selection. A team should also test the model on its own data, prompts, latency targets, and evaluation criteria.
MiniMax M1 vs DeepSeek R1 and Other Reasoning Models
A useful MiniMax M1 comparison should avoid declaring one universal winner. Reasoning models differ by context length, cost, latency, deployment route, tool support, license terms, and benchmark mix.
MiniMax M1’s strongest positioning is long-context reasoning with efficient long-output design. MiniMax reports a native 1M context window and states that Lightning Attention helps reduce compute for long generation. The official repository also compares MiniMax-M1 against models such as DeepSeek-R1, DeepSeek-R1-0528, Qwen3-235B-A22B, Claude 4 Opus, Gemini 2.5 Pro, and OpenAI-o3 across multiple tasks.
DeepSeek R1 and DeepSeek-R1-0528 may score higher in some benchmark categories. Qwen3-235B is another strong open-weight comparison point. Closed models can also outperform MiniMax M1 on certain tasks, depending on the benchmark and workload.
Within the MiniMax family, also compare M1 with newer MiniMax models before choosing a production route. MiniMax’s current docs list MiniMax-M3 as the latest M-series model with a 1M-token context window and multimodal input, while M2.7 and other M2-series routes remain available for existing workflows.
For developers and AI teams, the decision should come down to practical requirements:
| Decision Factor | Why It Matters |
|---|---|
| Context length | MiniMax M1 is attractive when inputs are extremely long. |
| Reasoning depth | 40K and 80K thinking budgets allow different reasoning profiles. |
| Hosting route | Teams may choose self-hosting, hosted API, or aggregator access. |
| Latency | Long context and long reasoning can increase response time. |
| Cost | Pricing varies by provider and usage pattern. |
| Tool/API needs | Function calling, JSON mode, and integration features differ by platform. |
| Evaluation fit | Private task evaluation is more important than one public leaderboard score. |
How to Use MiniMax M1
Developers can approach MiniMax M1 in several ways.
Official MiniMax M1 launch resources are the best starting point for the model’s original positioning, announcement claims, launch-time API notes, and public model resources. For current MiniMax API model availability, check the live Model Invocation docs, because the current supported-model table focuses on MiniMax-M3 and M2-series models rather than MiniMax-M1.
GitHub is useful for technical references, repository files, license review, benchmark tables, model usage notes, function-calling references, and deployment pointers. The official repository lists an Apache-2.0 license and includes benchmark and deployment sections.
Hugging Face provides the model collection and model cards for MiniMax-M1-40k and MiniMax-M1-80k. The Hugging Face collection lists the 40k and 80k model entries, along with related resources.
vLLM is a common route for serving large LLMs. The vLLM article on MiniMax-M1 discusses deployment, model download, Docker serving, MoE, Lightning Attention, and inference support.
SGLang is another serving route mentioned in the Hugging Face model card, which includes SGLang server examples and OpenAI-compatible request examples.
API providers can make hosted access easier. OpenRouter, for example, currently lists MiniMax M1 with the model slug minimax/minimax-m1, a 1M context listing, and an OpenAI-compatible API access pattern. Treat this as provider-specific hosted access, not proof that MiniMax-M1 is still listed in MiniMax’s current first-party API model table. Pricing, rate limits, context handling, routing, availability, and provider behavior should be checked on the selected provider’s page before production use.
Do not assume every provider exposes the same feature set. Function calling, JSON mode, context caps, rate limits, safety settings, logging, uptime, and deployment requirements can differ.
Best Use Cases for MiniMax M1
Long document analysis: MiniMax M1 is a strong fit when a task requires reading large documents, comparing sections, or producing structured summaries from long files.
Repository-scale code review: The 1M context window can help developers include more source files, tests, logs, and architectural notes in one prompt. This is relevant for refactoring, bug investigation, migration planning, and codebase Q&A.
Software engineering reasoning: MiniMax reports SWE-bench Verified results and emphasizes software engineering tasks in its evaluation materials, making coding workflows a natural category to test.
Mathematical problem solving: AIME and MATH-500 results make MiniMax M1 relevant for math-heavy tasks, although math outputs should still be checked carefully.
Research synthesis: The model can help synthesize long papers, technical reports, market documents, or policy materials, especially when the prompt asks for evidence-based summaries.
Agentic workflows: MiniMax M1 is positioned for tool-use and agent-style tasks. TAU-bench results and function-calling references make this an important category for evaluation.
Enterprise knowledge workflows: Teams with large internal knowledge bases can test MiniMax M1 for policy lookup, support knowledge retrieval, compliance analysis, and internal documentation Q&A.
RAG over large corpora: In retrieval-augmented generation, a larger context window can allow more retrieved passages, more source diversity, and better multi-document synthesis.
Limitations and Things to Check Before Using It
MiniMax M1 has significant strengths, but it is not a simple plug-in answer for every workflow.
First, self-hosting can require serious infrastructure. The model has 456B total parameters, even though only 45.9B are active per token. Storage, GPU memory, tensor parallelism, quantization, throughput, and serving architecture all matter.
Second, provider features vary. A hosted API may expose different limits than a self-hosted vLLM or SGLang deployment. Check context length, output length, streaming, function calling, JSON handling, rate limits, uptime, logging, data retention, and billing.
Third, long context can be expensive or slow. Even when a model supports a 1M context window, sending large prompts can increase latency and cost.
Fourth, benchmark results do not guarantee performance on private tasks. A team should create its own evaluation set using real documents, code, tools, and expected output formats.
Fifth, factuality still matters. SimpleQA results in the official benchmark table show that factuality is a separate concern from math, coding, or long-context reasoning.
Sixth, modality support should be checked per provider. MiniMax M1 is mainly discussed as a text and reasoning LLM in official model materials and model cards, so image, audio, video, or multimodal features should not be assumed.
MiniMax M1 Prompting Tips
MiniMax M1 is designed for complex reasoning, but prompt quality still matters.
- State the task objective clearly. Tell the model whether you want a summary, diagnosis, comparison, implementation plan, code patch, legal-style analysis, or research synthesis.
- Structure long inputs. Use headings, filenames, document titles, section numbers, and delimiters. Long context works better when the model can identify where each piece of evidence came from.
- Ask for citations to sections or filenames. For document and code analysis, request references such as “cite the filename and function name” or “cite the section heading.”
- Use staged reasoning instructions without asking for hidden chain-of-thought. Ask for a concise explanation of the checks performed, assumptions made, and final recommendation.
- Request concise final answers after analysis. For long tasks, tell the model to analyze fully but present the answer in a clean structure.
- Break long-context workflows into sections. Even with 1M context, complex work benefits from staged prompts: first map the content, then identify issues, then produce the final answer.
Example prompts:
You are reviewing a large repository. Use the file paths and code sections provided below. Identify the most likely source of the bug, explain the evidence, and suggest a minimal patch. Cite filenames and function names.Analyze the following technical report and produce an executive summary, a risk table, and a list of claims that need verification. Refer to section headings when supporting each point.Compare these product requirements with the implementation notes. Identify gaps, contradictions, and missing acceptance criteria. Return a prioritized action plan.MiniMax M1 FAQ
1. What is MiniMax M1?
MiniMax M1 is an open-weight reasoning LLM from MiniMax. It uses a hybrid Mixture-of-Experts architecture, Lightning Attention, reinforcement learning, and a 1 million token context window for long-context reasoning, software engineering, math, and agent workflows.
2. Is MiniMax M1 open source or open weight?
MiniMax describes MiniMax-M1 as an open-weight model, and the official GitHub repository lists an Apache-2.0 license. Users should still review the repository, model card, and provider terms before using it in commercial or regulated environments.
3. How large is the MiniMax M1 context window?
MiniMax M1 supports a native context length of 1 million tokens, according to MiniMax’s official repository and arXiv report.
4. What is the difference between MiniMax-M1-40k and MiniMax-M1-80k?
MiniMax-M1-40k and MiniMax-M1-80k are two thinking-budget variants. The 40K version uses a smaller reasoning budget, while the 80K version is designed for a larger reasoning budget. The better choice depends on task difficulty, latency, and cost.
5. Is MiniMax M1 good for coding?
MiniMax M1 is relevant for coding and software engineering tasks. MiniMax reports 56.0 for MiniMax-M1-80k and 55.6 for MiniMax-M1-40k on SWE-bench Verified, along with LiveCodeBench results in its official benchmark table.
6. Can MiniMax M1 be self-hosted?
Yes, the model weights and deployment materials are available through official repositories and model cards. Self-hosting is infrastructure-heavy because the model has 456B total parameters, so teams should evaluate GPU memory, tensor parallelism, quantization, serving stack, and throughput needs.
7. Does MiniMax M1 support function calling?
The official GitHub repository includes a function-calling section and states that MiniMax-M1 supports function-calling capabilities. Provider-level support may differ, so developers should check the API or serving stack they plan to use.
8. How does MiniMax M1 compare with DeepSeek R1?
MiniMax M1’s main advantage is its long-context and efficient long-output reasoning design. DeepSeek R1 and DeepSeek-R1-0528 may perform better on some benchmarks, while MiniMax M1 is especially relevant for 1M context, software engineering, and tool-use workflows. Model choice should depend on workload, hosting route, latency, cost, and required API features.
Conclusion
MiniMax M1 is important because it combines hybrid-attention, Mixture-of-Experts routing, Lightning Attention, CISPO reinforcement learning, 1M context, and long-context reasoning in an open-weight model family. It is especially relevant for developers and teams handling large documents, codebases, technical research, complex reasoning workflows, and agentic tasks.
The best choice depends on workload fit, hosting route, latency, cost, context requirements, current provider availability, and API features. For teams comparing open-weight reasoning models, MiniMax M1 deserves evaluation when long context and structured reasoning are central to the use case, but teams choosing a current MiniMax production route should also compare MiniMax M3 and M2.7 before standardizing on M1.