I opened MiniMax Agent expecting a chatbot with some extra buttons. What I found instead was a genuinely full-featured hosted agent product — desktop app, mobile companion, multi-agent collaboration, its own credit-based subscription — that's iterated fast enough this year that a guide written six months ago would already be describing an out-of-date version of it. It's also, and this matters if you're a developer rather than just an end user, not something you can drop into your own application. That distinction is the actual useful thing to understand before deciding whether it's the tool you want.
What MiniMax Agent actually is right now
MiniMax Agent launched publicly in mid-2025 as a general-purpose agent aimed at long, multi-step tasks — things like full-stack web development, presentation creation, and in-depth research, built around what MiniMax describes as a hierarchical collaborative agent framework with long-range memory. It's moved fast since then: an M2-series model integration and mobile app in October 2025, a desktop app and an "Expert Agent" mode for building customized specialist assistants in January 2026, and then a bigger overhaul in May 2026 that gave the product a new name — Mavis, styled as "MiniMax as a Jarvis" — alongside a genuinely significant feature: Agent Teams, which lets you run multiple agents in parallel, each assigned a different role, collaborating on a task too large for a single agent to finish alone. That same release merged the separate token and agent subscription plans into one, so API usage and Agent usage now draw from a shared credit pool under one subscription rather than two separate billing relationships.
Most recently, MiniMax's M3 model shipped in August 2026 alongside an updated pairing agent product called MiniMax Code, tuned specifically to use M3's long-context and coding-agent capabilities, and a remote-control feature landed in early September letting you monitor and interact with a running desktop Agent session from your phone while the actual project files, terminal, and runtime stay on the desktop machine.
If you're evaluating this as a hosted tool for actually getting long-running tasks done — research reports, draft documents, coding sessions you can check in on from your phone — this is a legitimately capable and fast-moving product, and the Agent Teams feature specifically fills a real gap: a single agent producing its own final output is, as MiniMax's own release notes put it, both the judge and the contestant on its own work, and having separate role-assigned agents collaborate is a reasonable answer to that.
The catch: it's a product, not an API
Here's where it stops being relevant to "build something with it" the way an API model is. MiniMax Agent is a hosted application with its own UI, its own credit-based subscription, and its own workflow — there's no way to call "MiniMax Agent" as a component inside your own app the way you'd call a model endpoint. If what you actually want is agent-style behavior embedded in something you're building — a support tool, an internal automation, a feature in your own product — the Agent product itself isn't the thing to integrate. The thing to integrate is the underlying model, called directly through MiniMax's API, with your own agent loop built around it.
That's a meaningfully different task than using the hosted product, and it's worth being clear-eyed about the scope difference: MiniMax's hierarchical multi-agent framework, long-range memory system, and Agent Teams orchestration represent real engineering investment that a weekend project isn't going to replicate. What you can reasonably build is a scoped-down version — a single agent with a tool-calling loop suited to your specific task — using the same underlying model.
A minimal agent loop on the raw API
MiniMax's API is OpenAI-compatible, which means the same request shape you'd use for any chat completion applies, with tool-calling handled the standard way:
// minimax-agent-loop.js — a minimal single-agent tool-calling loop,
// not a replacement for MiniMax's own multi-agent framework, just a
// scoped starting point for embedding agent-style behavior in your own app
const TOOLS = [
{
type: "function",
function: {
name: "search_internal_docs",
description: "Search internal documentation for relevant context",
parameters: {
type: "object",
properties: { query: { type: "string" } },
required: ["query"],
},
},
},
];
async function callModel(baseURL, apiKey, messages) {
const response = await fetch(`${baseURL}/chat/completions`, {
method: "POST",
headers: {
"Content-Type": "application/json",
Authorization: `Bearer ${apiKey}`,
},
body: JSON.stringify({
model: "minimax-m2.7",
messages,
tools: TOOLS,
}),
});
return response.json();
}
async function runAgentLoop(baseURL, apiKey, task, { maxSteps = 5 } = {}) {
const messages = [{ role: "user", content: task }];
for (let step = 0; step < maxSteps; step++) {
const result = await callModel(baseURL, apiKey, messages);
const message = result.choices[0].message;
messages.push(message);
if (!message.tool_calls) {
return message.content; // model finished without needing another tool call
}
for (const call of message.tool_calls) {
const args = JSON.parse(call.function.arguments);
const toolResult = await executeTool(call.function.name, args);
messages.push({
role: "tool",
tool_call_id: call.id,
content: JSON.stringify(toolResult),
});
}
}
throw new Error(`Agent loop exceeded ${maxSteps} steps without finishing`);
}
async function executeTool(name, args) {
if (name === "search_internal_docs") {
// plug in your actual retrieval logic here
return { results: [`Stub result for query: ${args.query}`] };
}
throw new Error(`Unknown tool: ${name}`);
}
module.exports = { runAgentLoop };
This is intentionally the simplest version of the pattern — a linear loop, one model, a hard step cap so it can't run away. It's the right scope for a task like "look up context and answer a question," and the wrong scope for anything resembling what MiniMax's Agent Teams feature is built for — genuinely long, multi-role, parallel work. Knowing which of those two categories your actual task falls into is most of the decision between using the hosted product and building your own loop.
On the M3 benchmark numbers
Worth a specific note since MiniMax has published its own evaluation results for M3: in an internally run, fully autonomous benchmark covering math reasoning, tool calling, science knowledge, and code generation, MiniMax reported M3 scoring 0.37, against Opus 4.7 at 0.42 and GPT-5.5 at 0.39, describing M3 as ahead of other models in the comparison. That's a vendor's own self-reported number on a benchmark of their own design, run without independent verification in what I could find — worth treating the same way as any single-vendor benchmark claim: a data point suggesting the model is at least competitive, not a settled ranking, and worth checking against independent evals if the specific comparison matters for a real decision.
Where the API access piece fits
If you land on "I want the model, not the hosted Agent product," MiniMax's own API is the direct route, and it's also one of several ways to reach the same M2.5/M2.7/M3 model family — gateways like RouteAI list MiniMax's models alongside DeepSeek, Qwen, Kimi, and GLM, which is worth knowing if you're already routing calls to other providers through one key and would rather not open a separate MiniMax account and billing relationship just for this one model family.
The actual takeaway
MiniMax Agent (now Mavis) is a legitimately fast-moving, capable hosted agent product if what you want is a tool you interact with directly for long-running tasks — and the Agent Teams multi-role collaboration feature is a genuinely useful answer to the single-agent judge-and-contestant problem. If what you actually want is agent-style behavior inside your own application, that's a different build entirely: a scoped tool-calling loop against the raw model API, not an integration with the Agent product itself. Knowing which one you're actually asking for is the first question worth answering, before evaluating either.
TL;DR: MiniMax Agent (rebranded Mavis in May 2026) is a hosted, subscription-based agent product with a genuinely useful multi-agent "Teams" feature — but it's not embeddable in your own app. Developers who want agent-style behavior inside their own product need to build a scoped tool-calling loop against MiniMax's raw API instead, using the same underlying model.
Website: https://www.fastrouteai.com
Top comments (0)