MiniMax-M3

MiniMax-M3

Four hundred and twenty-eight billion parameters, twenty-three active, and one attention operator that explains the whole design.

MiniMax Sparse Attention

The component this model is built around, and MiniMax published it as a project in its own right — a separate repository with its own technical report, rather than an architectural detail buried in a model card.

The measured results, against the previous generation at a million tokens:

Read where those are measured. At a million tokens — the length where attention cost dominates everything else, and where a speedup is worth reporting.

And the comparison MiniMax draw is against GQA, not against dense attention: MSA dramatically reduces the attention compute and memory footprint while preserving model quality.

That framing matters. Grouped-query attention is already the standard efficiency measure — most models in this catalogue use it. Beating it is a different claim from beating naive full attention.

Publishing the operator separately is worth noticing. A sparse attention kernel that works is useful beyond the model it was built for, and releasing it invites the kind of scrutiny a claim inside a model card does not receive.

Half a Million Tokens, Affordably

The window, and why MSA is what makes it reasonable rather than theoretical.

524,288 tokens.

On a conventional model, that length is where attention cost becomes the dominant term. Every token attends to every prior token; the cost grows quadratically, and a 428-billion-parameter model paying that cost at half a million tokens is not something most deployments configure.

MSA is the reason this one does. The operator's published figures are measured at a million tokens — twice this window — which means 524,288 sits comfortably inside the range it was built for rather than at its edge.

What that holds. A repository. A document archive. A long agent session with accumulated tool output. A book-length corpus with room for the analysis.

And the prefill figure is the one that applies to a large single prompt. Nine times faster on the pass that reads your input is what makes filling this window a decision rather than a compromise.

⚠️ Local Inference Loses the Speedup

The most consequential practical warning on this page, and it comes from an official quantised release.

MiniMax Sparse Attention is not supported in llama.cpp-based runtimes, and the note is explicit: inference falls back to dense attention.

Read what that means. The model loads. It runs. It produces correct output.

And the nine-times prefill, fifteen-times decode, and one-twentieth per-token compute are all gone — because the operator that produces them is not there.

You get a 428-billion-parameter model with dense attention at half a million tokens, which is the configuration MSA exists to avoid.

Through a serving stack that implements MSA this does not apply. It applies to anyone running a GGUF locally and wondering why the published figures do not reproduce.

The lesson generalises. On a model whose distinguishing feature is a custom operator, "does my runtime support the operator" is a different question from "does my runtime load the model" — and only the second one fails visibly.

Multimodal From the First Step

Mixed-modality training from the very first step, enabling deeper semantic fusion across text, image, and video.

The phrasing is specific and the distinction is real. Early fusion means text and vision tokens share a backbone. Mixed-modality training from step one means the model never existed as a text-only model that was later taught to see.

Which is a different claim, and it is the strongest version of the multimodality argument: there is no point in training at which the representations were text-only and had to accommodate images afterwards.

All three modalities are named — text, image, and video — and the model is classified as an image-text-to-text architecture with video among its tags.

Reasoning Modes

A thinking parameter controls deliberation, and the documented values include a mode worth knowing about:

adaptive is the interesting one. Most switchable models make you choose per request. This one can be handed the decision, judging per turn whether the problem warrants deliberation.

Where that helps. A mixed workload — an agent loop with fifty mechanical steps and three hard ones — does not need you to classify each step in advance. The model does it.

Where it does not. A path with a hard latency budget still needs the mode set explicitly, because adaptive means sometimes slow.

⚠️ Documentation varies on the mode set. MiniMax's own model card describes two modes — thinking and non-thinking — while derivative cards document three including adaptive. Confirm which your path accepts before building routing logic around a value.

Specifications

Just over five percent activation — 23 billion of 428.

The licence is custom, not Apache or MIT. Read it against your deployment rather than assuming permissive terms.

Published variants: an MXFP8 quantisation from MiniMax, community NVFP4 and GGUF builds, and a speculative-decoding variant from NVIDIA.

Capabilities

Using MiniMax-M3 on DEVUP AI

Base URL: https://api.devupai.com/v1 · Model ID: MiniMaxAI/MiniMax-M3

Python

import os
from openai import OpenAI

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

response = client.chat.completions.create(
    model="MiniMaxAI/MiniMax-M3",
    messages=[
        {"role": "user", "content": "Hello world!"}
    ],
    max_tokens=1024,
)

print(response.choices[0].message.content)

Node.js

import DevupAI from "devupai";

const client = new DevupAI({
  apiKey: process.env.DEVUP_API_KEY,
});

async function main() {
  const response = await client.chat.completions.create({
    model: "MiniMaxAI/MiniMax-M3",
    messages: [{ role: "user", content: "Hello world!" }],
    max_tokens: 1024,
  });

  console.log(response.choices[0].message.content);
}

main();

cURL

curl -X POST "https://api.devupai.com/v1/chat/completions" \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "MiniMaxAI/MiniMax-M3",
    "messages": [
      { "role": "user", "content": "Hello world!" }
    ],
    "max_tokens": 1024
  }'

Long-Horizon Agent Work

MiniMax name coding and cowork as the design target — frontier-level performance across long-horizon agentic benchmarks.

import json
import time

TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "read_file",
            "description": "Read a file relative to the repository root.",
            "parameters": {
                "type": "object",
                "properties": {"path": {"type": "string"}},
                "required": ["path"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "edit_file",
            "description": "Replace an exact string in a file. The old string must appear exactly once.",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {"type": "string"},
                    "old_str": {"type": "string"},
                    "new_str": {"type": "string"},
                },
                "required": ["path", "old_str", "new_str"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "run_tests",
            "description": "Run the test suite and return pass/fail counts with failure output.",
            "parameters": {"type": "object", "properties": {}},
        },
    },
]


def read_file(path: str) -> dict:
    """Replace with your real, sandboxed file access."""
    raise NotImplementedError


def edit_file(path: str, old_str: str, new_str: str) -> dict:
    """Replace with your real, sandboxed editor."""
    raise NotImplementedError


def run_tests() -> dict:
    """Replace with your real, sandboxed test runner."""
    raise NotImplementedError


HANDLERS = {"read_file": read_file, "edit_file": edit_file, "run_tests": run_tests}

session = [
    {
        "role": "system",
        "content": (
            "You are working inside a git repository. Make the smallest change that resolves the "
            "issue and run the tests after each edit. Finish the task rather than leaving a partial "
            "fix."
        ),
    },
    {"role": "user", "content": "The DZD invoice test fails on totals ending in .005. Find the cause and fix it."},
]

CEILING = 100
start = time.monotonic()

for step in range(CEILING):
    response = client.chat.completions.create(
        model="MiniMaxAI/MiniMax-M3",
        messages=session,
        tools=TOOLS,
        max_tokens=32768,
    )

    message = response.choices[0].message
    session.append(message)

    if not message.tool_calls:
        print(message.content)
        break

    for call in message.tool_calls:
        handler = HANDLERS.get(call.function.name)
        if handler is None:
            outcome = {"error": "unknown tool", "name": call.function.name}
        else:
            try:
                outcome = handler(**json.loads(call.function.arguments or "{}"))
            except Exception as exc:
                outcome = {"error": type(exc).__name__, "detail": str(exc)}

        session.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(outcome)})

    if step % 25 == 0:
        used = response.usage.prompt_tokens
        print(f"step {step:>3} · {(time.monotonic() - start) / 60:>5.1f} min · {used:>8,} tokens ({used / 524_288:.0%})")
else:
    print(f"Reached the {CEILING}-step ceiling.")

Track the percentage of window consumed, not the step count. A session with large file reads reaches 80% of half a million tokens in far fewer steps than one running short commands, and only that figure tells you which situation you are in.

Time the whole run. A fifteen-times decode speedup is a claim about tokens per second; whether a session finishes in twenty minutes or three hours is the measurement that decides whether the design works for you — and decode is where an agent loop spends most of its time.

Filling the Window

from pathlib import Path

REPO = Path("src")

sources = "\n\n".join(
    f"=== {path.relative_to(REPO.parent)} ===\n{path.read_text(encoding='utf-8')}"
    for path in sorted(REPO.rglob("*.py"))
)

response = client.chat.completions.create(
    model="MiniMaxAI/MiniMax-M3",
    messages=[
        {
            "role": "system",
            "content": (
                "You are auditing a codebase. Identify every path where a database write can occur "
                "outside a transaction. Name the file, the function, and the call chain that reaches "
                "it. Report nothing you cannot trace."
            ),
        },
        {"role": "user", "content": sources},
    ],
    max_tokens=32768,
)

print(f"input: {response.usage.prompt_tokens:,} of 524,288")

Prefill is where the nine-times figure applies, and a large single prompt is prefill-dominated — which makes whole-repository analysis the workload MSA was measured on.

Asking for the call chain rather than the line is what uses a very long window rather than a search.

Measure retrieval quality at your working length. A sparse attention operator attends to a subset by design; MiniMax state that quality is preserved, and whether it holds on your data is an empirical question with a cheap answer.

Images and Video

Native inputs, trained in from the first step.

import base64
from pathlib import Path

encoded = base64.b64encode(Path("dashboard.png").read_bytes()).decode("utf-8")

response = client.chat.completions.create(
    model="MiniMaxAI/MiniMax-M3",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{encoded}"}},
                {
                    "type": "text",
                    "text": (
                        "Read every figure with its label and unit. Separate values printed in the "
                        "image from values you read off an axis, and mark anything illegible as "
                        "unreadable rather than estimating it."
                    ),
                },
            ],
        }
    ],
    max_tokens=16384,
)

⚠️ The number of images per prompt may be capped at serving time. One community serving configuration limits it to four. Verify your path's limit before building a batch path around a larger number.

Video consumes input tokens rapidly. Measure one short clip before processing anything longer — 524,288 tokens fills faster than a minute count suggests once video enters the window.

Setting the Reasoning Mode

def ask(prompt: str, *, mode: str = "adaptive", max_tokens: int = 16384) -> str:
    """Send a request at an explicit reasoning mode."""
    response = client.chat.completions.create(
        model="MiniMaxAI/MiniMax-M3",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=max_tokens,
        extra_body={"thinking": mode},
    )

    choice = response.choices[0]

    if choice.finish_reason == "length":
        raise ValueError(f"hit the ceiling at {response.usage.completion_tokens:,} tokens")

    return choice.message.content

Adaptive is the right default on a mixed workload — the model judges each turn, which is a decision you would otherwise have to make in code without knowing what the turn contains.

Set it explicitly on a latency-bound path. Adaptive means sometimes slow, and a path with a budget needs the mode chosen rather than delegated.

Check finish_reason regardless. Reasoning shares the output budget, and a truncated response can contain a full trace and no answer at all.

⚠️ Confirm the parameter name and accepted values on your path before building routing around them — documentation varies between the base card and its derivatives.

Self-Hosting

Three things decide whether it works, and one of them is not obvious.

Does your runtime implement MSA?

The single most important question, and it is separate from whether the model loads.

llama.cpp-based runtimes fall back to dense attention. The model works; the speedups do not exist.

MSA is published as a standalone operator with its own repository and technical report, which means a serving stack can implement it — and whether yours has is worth confirming rather than assuming.

Hardware

A community NVFP4 build is 259 GB, running on four 96 GB GPUs at four-way tensor parallelism with headroom for the KV cache.

MXFP8 is published by MiniMax directly, alongside community NVFP4 and GGUF builds.

Version pinning

Community serving images pin transformers==5.10.2 and ship a known-good stack rather than leaving assembly to the deployer — an indication that the architecture is new enough for version drift to break it.

A cautionary note on quantisation

One published NVFP4 build documents a calibration bug openly: an over-broad exclusion pattern intended for the MoE router silently disabled quantisers for every module with "gate" in its name — including the routed experts' projections — producing an export that was nominally quantised while carrying hundreds of gigabytes of unquantised weights.

The lesson, if you quantise this model yourself: on an MoE architecture, an exclusion glob matching "gate" matches far more than the router. Verify what was actually quantised rather than trusting the output size.

Where It Fits

Long-horizon agentic work — coding and cowork, named as the design target, and where MSA's decode speedup compounds across steps.

Repository and archive-scale analysis at 524,288 tokens, where the nine-times prefill figure applies to large single prompts.

Multimodal work across text, image, and video, with mixed-modality training from the first step.

High-throughput serving, where 23 billion active parameters and a sparse attention operator together decide the economics.

Self-hosted deployment on a serving stack that implements MSA — and only on one that does.

Not for local llama.cpp deployment if the speedups are why you chose it.

Not for output beyond text. Three input modalities, one output modality.

Practical Notes

Confirm your serving path implements MSA, not merely that it loads the model.

Track context consumption as a percentage of 524,288 on long sessions.

Verify the images-per-prompt limit before building a batch path.

Use adaptive reasoning on mixed workloads; set the mode explicitly where latency is bounded.

Confirm the thinking parameter's accepted values — documentation varies between cards.

Check finish_reason on every reasoning request.

Time whole agent sessions rather than single requests.

Measure retrieval quality at your working context length.

If quantising: an exclusion pattern matching "gate" catches more than the router.

Read the MiniMax Community License against your deployment.

Limitations

MSA is not universally supported. Runtimes without it fall back to dense attention, losing every speedup the model was built around — and the fallback is documented rather than silent, which is the only reason it is discoverable.

Twenty-three billion active parameters is the compute ceiling per token, whatever the 428 billion total suggests.

428 billion parameters must be loaded. The MoE saving is in compute, not memory, and self-hosting is a multi-GPU proposition.

524,288-token window. Generous, and less than the million the operator was benchmarked at — the published speedup figures describe a longer context than this deployment serves.

Images per prompt may be capped at serving time rather than by the model.

Text output only. Three input modalities, one output modality.

Reasoning-mode documentation is inconsistent between the base card and its derivatives. Verify before building routing logic.

A custom licence, not Apache or MIT.

Sparse attention attends to a subset by design. MiniMax state that quality is preserved; that is a claim worth testing at your working length rather than accepting.

A new architecture. Version pinning matters, framework support is uneven, and the quantisation toolchain has already produced at least one documented failure on it.

Speedup figures are measured against the previous generation at a million tokens. Your context length and your shape will produce different numbers.