Using MiniMax M2.5 on Chutes

MiniMax-M2.5 is MiniMax's open-weights coding and agent model, trained with reinforcement learning across hundreds of thousands of real-world environments and reporting 80.2% on SWE-Bench Verified. On Chutes it is served inside a Trusted Execution Environment (TEE) through the OpenAI-compatible gateway, so any OpenAI SDK works with a base URL change.

Overview

Released in February 2026 under a Modified MIT license, MiniMax-M2.5 is a Mixture-of-Experts transformer in the MiniMax-M2 family. The published FP8 safetensors weights total roughly 229B parameters: 62 layers, 256 experts with 8 active per token, hidden size 3072, 48 attention heads, and a 200,064-token vocabulary. The context window is 196,608 tokens.

M2.5's training emphasizes economically valuable agentic work. It was trained via RL in over 200,000 real-world coding environments spanning more than 10 languages (Go, C, C++, TypeScript, Rust, Kotlin, Python, Java, JavaScript, PHP, Lua, Dart, Ruby), covering the full development lifecycle from system design through code review, plus office-work scenarios (Word, PowerPoint, Excel financial modeling) built with domain experts in finance, law, and social sciences. A notable emergent behavior the card describes: before writing code, M2.5 decomposes and plans features, structure, and UI design like a software architect.

Card-reported results: 80.2% SWE-Bench Verified, 51.3% Multi-SWE-Bench, 76.3% BrowseComp (with context management), 86.3 AIME25, 85.2 GPQA-Diamond. On out-of-distribution harnesses it posts 79.7 (Droid) and 76.1 (OpenCode) on SWE-Bench Verified, edging the Claude Opus 4.6 numbers MiniMax cites. The card also reports a 37% end-to-end speedup over M2.1 on SWE-Bench Verified (22.8 vs 31.3 minutes per task).

Model specifications

Quick start

Authenticate with Authorization: Bearer $CHUTES_API_KEY. The model name is MiniMaxAI/MiniMax-M2.5-TEE on the shared gateway https://llm.chutes.ai/v1.

curl -X POST "https://llm.chutes.ai/v1/chat/completions" \
  -H "Authorization: Bearer $CHUTES_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "MiniMaxAI/MiniMax-M2.5-TEE",
  "messages": [{"role": "user", "content": "Design a REST API for a task queue, then implement it in Go."}],
  "stream": true,
  "max_tokens": 4096,
  "temperature": 1.0
}'

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://llm.chutes.ai/v1",
    api_key=os.environ["CHUTES_API_KEY"],
)

response = client.chat.completions.create(
    model="MiniMaxAI/MiniMax-M2.5-TEE",
    messages=[{"role": "user", "content": "Design a REST API for a task queue, then implement it in Go."}],
    max_tokens=4096,
    temperature=1.0,   # MiniMax-recommended
    top_p=0.95,
    extra_body={"top_k": 40},
)
print(response.choices[0].message.content)

const res = await fetch("https://llm.chutes.ai/v1/chat/completions", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.CHUTES_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "MiniMaxAI/MiniMax-M2.5-TEE",
    messages: [{ role: "user", content: "Design a REST API for a task queue, then implement it in Go." }],
    max_tokens: 4096,
    temperature: 1.0,
    top_p: 0.95,
    top_k: 40,
  }),
});
const data = await res.json();
console.log(data.choices[0].message.content);

Parameters and tuning

Chute defaults (from the live endpoint definition): temperature 0.7, max_tokens 1024, seed 42, streaming supported. The /v1/completions endpoint additionally exposes the vLLM sampling surface: top_p (default 1), top_k (default -1, disabled), min_p, presence_penalty, frequency_penalty, repetition_penalty, logprobs, and more.

MiniMax recommends temperature = 1.0, top_p = 0.95, top_k = 40 for best performance; these exactly match the repository's generation_config.json. The chute default temperature of 0.7 is more conservative, so pass the recommended values explicitly for reference behavior. For agentic coding runs, raise max_tokens well past the 1024 default: MiniMax's own SWE-Bench runs average millions of tokens per task across a trajectory.

What it's best at

• Coding agents. 80.2% SWE-Bench Verified with strong generalization across harnesses (Droid, OpenCode, Claude Code scaffolds). Trained for the whole lifecycle: 0-to-1 system design, feature iteration, and code review, on full-stack projects across Web, Android, iOS, and Windows.
• Agentic search. 76.3% BrowseComp with context management, with about 20% fewer search rounds than M2.1 per the card.
• Office automation. Word, PowerPoint, and Excel financial modeling deliverables, trained with input from finance, law, and social-science professionals.
• High-volume agent fleets. Efficiency is the design goal: MiniMax positions the M2 series as cheap enough to run agents continuously without cost anxiety.

Less ideal: vision or audio input (text-only); deep frontier math and knowledge reasoning, where card-reported AIME25 (86.3) and HLE without tools (19.4) trail the largest frontier models; and strict-license environments where Modified MIT terms need review.

How Chutes serves this model

This chute runs M2.5 inside a Trusted Execution Environment: inference executes on attested confidential-compute hardware, so prompts and outputs are processed inside the enclave. TEE serving is a deployment property and does not change model behavior. The upstream weights are already FP8 (e4m3 block-quantized) as published by MiniMax.

Serving is vLLM-based on the shared OpenAI-compatible gateway, exposing streaming /v1/chat/completions and /v1/completions plus GET /v1/models. Billing follows Chutes' standard per-token LLM pricing. See the model page, the machine-readable llms.txt, and the callable OpenAPI spec.

FAQ

What context window does MiniMax M2.5 support?

196,608 tokens (192K), per max_position_embeddings in the upstream config. That is enough for repository-scale code context or long agent trajectories.

How good is MiniMax M2.5 at coding?

The model card reports 80.2% on SWE-Bench Verified, 51.3% on Multi-SWE-Bench, and strong cross-harness results (79.7 on Droid, 76.1 on OpenCode). It was trained on 200,000+ real-world coding environments across 10+ languages, covering the full development lifecycle rather than just bug fixing.

Does it support function calling and tool use?

Yes. Agentic tool use is a core training target: MiniMax reports 76.3% on BrowseComp with context management and publishes a dedicated tool-calling guide in the repository. Send OpenAI-style tools through the gateway's chat completions endpoint.

Can I use MiniMax M2.5 commercially?

The weights are released under a Modified MIT license (see the LICENSE file in the MiniMax-M2.5 GitHub repository). It is broadly permissive, but review the modifications before redistribution or large-scale commercial deployment.

What does the TEE suffix mean?

The chute runs inference inside a Trusted Execution Environment, i.e. attested confidential-compute hardware. Prompts and outputs are processed inside the enclave. It is a serving-level property and does not change model outputs.

How do I call it from the OpenAI SDK?

Point the client at base_url https://llm.chutes.ai/v1 with your Chutes API key and set model to MiniMaxAI/MiniMax-M2.5-TEE. Streaming is supported on chat and text completions.

What sampling settings should I use?

MiniMax recommends temperature 1.0, top_p 0.95, and top_k 40, which match the repo's generation_config. The chute default temperature is 0.7, so pass the recommended values explicitly for reference behavior.

Is M2.5 the same as M2.5-Lightning?

MiniMax describes M2.5 and M2.5-Lightning as identical in capability, differing only in serving speed and price on MiniMax's own platform. This chute serves the open-weights MiniMax-M2.5 release; throughput on Chutes is determined by Chutes' own serving infrastructure.

Sources

• MiniMaxAI/MiniMax-M2.5 on Hugging Face
• Upstream config.json
• Upstream generation_config.json
• MiniMax-M2.5 GitHub repository
• MiniMax-M2.5-TEE model page on Chutes
• Live llms.txt for this chute