Verdict: MiniMax M3 completed 298 of 300 strict tool-calling trials, a 99.33% pass rate, across 100 English prompts and 10 JSON Schema families. All 300 API requests returned successfully, but one response stopped at the output limit with truncated arguments and one returned ordinary assistant text instead of a tool call. The result is strong, but it is not permission to execute model-generated arguments without validation.
This is an original MiniMax-AI.chat experiment, not a summary of a vendor benchmark. We sent 300 paid requests to the public MiniMax OpenAI-compatible Chat Completions endpoint, retained every response, and scored the returned function name and arguments against deterministic ground truth. The complete dataset, request fixtures, raw JSONL, CSV results, and summary are available below so another developer can inspect or repeat the test.
Package maintenance — verified July 30, 2026: The repaired ZIP restores the generated dataset files required by the offline validator and adds a verified internal SHA-256 manifest. The published tool-calling result is unchanged. ZIP SHA-256: 192b9a116ff3ce20c20b5892e230bbaa6b78db63510e94369692899a6cb3d9b4.
MiniMax M3 tool calling results at a glance
| Metric | Observed result | What it means |
|---|---|---|
| Strict passes | 298 / 300 (99.33%) | One expected tool call, parseable JSON, schema-valid arguments, and exact ground-truth match |
| API-level success | 300 / 300 (100%) | Every request returned HTTP success with a successful MiniMax API status |
| Tool-call emission | 299 / 300 (99.67%) | One response returned assistant text without a tool_calls entry |
| Parseable arguments | 298 / 300 (99.33%) | One emitted call ended with incomplete JSON |
| Schema-valid arguments | 298 / 300 (99.33%) | Every parseable argument object passed its local JSON Schema check |
| Exact argument match | 298 / 300 (99.33%) | No parseable, schema-valid response contained a wrong value |
| Median total latency | 1.824 seconds | Non-streaming wall time for one request |
| Calculated API cost | $0.08608308 | About 8.6 cents, based on returned usage and published Standard-tier rates |
The distinction between API success and application success matters. A monitoring dashboard that counted only HTTP 200 responses would report 100%. A production dispatcher that required a usable, validated tool call would report 99.33%. The second number is the useful one.
How we tested MiniMax M3 function calling
We created 100 deterministic English test cases and divided them evenly among 10 schema families. Each case defined one uniquely named client-side function, a natural-language instruction containing all required values, a JSON Schema, and an expected argument object. Every case was sent three times, producing 300 requests. This design tests repeatability as well as one-shot success.
- Model:
MiniMax-M3 - Endpoint:
POST https://api.minimax.io/v1/chat/completions - Service tier: Standard
- Requests: 100 cases × 3 repetitions = 300
- Concurrency: 3
- Sampling: temperature 0.1; top-p 0.95
- Thinking: explicitly disabled
- Output limit: 256 completion tokens
- Tool selection:
auto; the prompt explicitly requested the named tool once - Run window: July 28, 2026, 13:04:46–13:08:37 UTC
The schemas exercised flat objects, required properties, nested objects, fixed-length arrays, arrays of objects, enums, numeric bounds, regex patterns, additionalProperties: false, unique items, Boolean fields, and nullable string fields. Before the live run, a deterministic local validator confirmed that all 100 expected argument objects satisfied their own schemas.
A strict pass required all of the following: the HTTP request and MiniMax API status succeeded; exactly one tool call appeared; its name matched the case; its function.arguments string parsed as JSON; the parsed value passed the case schema; and the serialized parsed object exactly matched the stored ground truth. The last check made property order part of this run’s exact-match rule. No failure was caused by key order, but future versions should canonicalize object keys before semantic comparison.
We did not use an LLM judge or a subjective quality score. A response either met the recorded contract or it did not. For background on building a multi-turn dispatcher, read our MiniMax function-calling guide. MiniMax documents the current request shape in its official Chat Completions reference and explains response preservation for agent loops in its Tool Use and Interleaved Thinking guide.
Results across all 10 JSON Schema families
| Schema family | Strict passes | Pass rate | Median latency |
|---|---|---|---|
| Flat required fields | 30 / 30 | 100% | 1.453 s |
| Fixed-length string arrays | 30 / 30 | 100% | 1.763 s |
| Three-level nested objects | 30 / 30 | 100% | 1.590 s |
| Arrays of nested objects | 30 / 30 | 100% | 2.559 s |
| Numeric and pattern constraints | 30 / 30 | 100% | 1.417 s |
| Nested schedule with attendee array | 29 / 30 | 96.67% | 1.740 s |
| Nested shipping manifest | 30 / 30 | 100% | 2.593 s |
| Enum arrays and Boolean flags | 30 / 30 | 100% | 1.728 s |
| Deep product catalog | 30 / 30 | 100% | 2.261 s |
| Nullable fields and nested window | 29 / 30 | 96.67% | 1.617 s |
Eight families were perfect. Most importantly, the arrays-of-nested-objects family passed all 30 trials. Those cases contained two or three groups, and every group contained an ordered array of two to four item IDs. M3 retained every group and item in the successful calls. The nested shipping family also passed 30 of 30 despite combining a two-line address with two or three package objects, numeric weights, and Boolean flags.
The two imperfect families did not fail because M3 selected a wrong enum, invented a property, dropped an array entry, confused a number with a string, or mishandled a nullable value. Their single failures occurred earlier in the response pipeline: one tool call was truncated before its arguments were complete, and one tool call was never emitted.
The two failures, examined
Failure 1: TC053 exhausted the output limit mid-JSON
TC053 asked schedule_meeting_053 to submit a nested meeting object and four attendee emails. The expected arguments contained a date, start time, 45-minute duration, and the four-item attendee array. Repetitions two and three passed exactly. Repetition one returned HTTP 200 and the expected tool name, but its finish reason was length. The returned argument string was only:
{"meeting": The JSON could not parse, so the call failed before schema validation. The response used all 256 allowed completion tokens. Its assistant text spent most of that budget discussing the schema and incorrectly stated that attendees was optional and that the top level did not reject extra properties. The actual schema required both meeting and attendees and set additionalProperties to false.
This is a useful failure because several superficial checks would have accepted it: the server returned 200, the API status was successful, the model selected the correct function, and the response contained a tool_calls array. Only checking the finish reason and parsing the entire arguments string exposed the broken call. A higher output cap may reduce this specific truncation risk, but this run did not use a post-hoc rerun in its headline score, so we do not claim that a larger cap fixes the case.
Failure 2: TC093 returned text instead of a tool call
TC093 described an order with a locker delivery method, a string pickup location, a nested delivery window, and a non-null discount code. Repetitions two and three produced exact calls. Repetition one again returned HTTP 200, this time with finish_reason: "stop", but tool_calls was absent. Its assistant content was:
{"error": "Tool result missing due to internal error"}That text resembles structured error output, but it is not an API error object and it is not a client-executable function call. A dispatcher must treat zero calls as a failed contract, even when the content looks like JSON. Because the other two repetitions passed unchanged, this appears intermittent within the tested conditions rather than a deterministic rejection of nullable fields.
Together, the failures support one operational rule: validate the envelope before validating the arguments. Confirm the API status, finish reason, number of calls, tool name, complete JSON parse, schema, and application authorization in that order. Never route arbitrary assistant text to a tool executor.
Latency, tokens, and cost
Across all 300 non-streaming calls, mean total latency was 2.311 seconds and median latency was 1.824 seconds. The 90th percentile was 3.097 seconds, the 95th was 5.379 seconds, and the 99th was 7.555 seconds. The fastest response completed in 0.917 seconds; the slowest took 20.462 seconds. That long tail means a production timeout should not be derived from the median alone.
| Usage or latency item | Observed value |
|---|---|
| Input tokens | 192,354 |
| Output tokens | 36,344 |
| Prompt-cache read tokens | 63,483 |
| Median / p95 / maximum latency | 1.824 s / 5.379 s / 20.462 s |
| Calculated total cost | $0.08608308 |
| Calculated mean cost per request | About $0.000287 |
The cost is calculated from the usage fields returned by the API and the published Standard-tier M3 rates for requests at or below 512K input tokens: $0.30 per million uncached input tokens, $1.20 per million output tokens, and $0.06 per million cache-read tokens. It is not a screenshot of a billing ledger and excludes tax or account-specific adjustments. Check our dated MiniMax pricing guide and the current official pay-as-you-go table before forecasting a production workload.
A safer Node.js validation pattern
The following condensed example shows the checks that separated 300 successful HTTP responses from 298 usable tool calls. Install a production JSON Schema validator such as Ajv, keep the API key in a server-side environment variable, and never execute a model-provided function name through eval or a shell.
import Ajv from "ajv";
const response = await fetch(
"https://api.minimax.io/v1/chat/completions",
{
method: "POST",
headers: {
Authorization: `Bearer ${process.env.MINIMAX_API_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
model: "MiniMax-M3",
service_tier: "standard",
thinking: { type: "disabled" },
max_completion_tokens: 256,
temperature: 0.1,
top_p: 0.95,
messages,
tools: [toolDefinition],
tool_choice: "auto",
}),
},
);
const body = await response.json();
if (!response.ok || body.base_resp?.status_code !== 0) {
throw new Error("MiniMax API request failed");
}
const choice = body.choices?.[0];
if (choice?.finish_reason === "length") {
throw new Error("Tool call was truncated");
}
const calls = choice?.message?.tool_calls ?? [];
if (calls.length !== 1) {
throw new Error(`Expected one tool call; received ${calls.length}`);
}
const call = calls[0];
if (call.function?.name !== "approved_tool_name") {
throw new Error("Tool is not allow-listed");
}
let args;
try {
args = JSON.parse(call.function.arguments);
} catch {
throw new Error("Tool arguments are not complete JSON");
}
const validate = new Ajv({ allErrors: true }).compile(jsonSchema);
if (!validate(args)) {
throw new Error(`Schema violation: ${JSON.stringify(validate.errors)}`);
}
// Apply authorization, idempotency, and business-rule checks here.
// Only then call the approved application function.For the wider SDK setup and endpoint differences, see our MiniMax OpenAI-compatible API guide and MiniMax M3 model guide.
Limitations
- This was one model snapshot, one public endpoint, one Standard-tier account, and one short run on July 28, 2026. Provider behavior can change.
- The 100 cases are original synthetic English fixtures. They cover meaningful schema structures but are not a random sample of every real production tool.
- Each prompt exposed only one function. The test did not measure selection among many similarly named tools, parallel calls, multi-turn tool results, or prompt injection.
tool_choiceremainedauto. The user prompt explicitly requested the tool, so the experiment measures compliance under a strong tool-use instruction.- The 256-token completion cap contributed directly to one failure. Longer agent turns can have different cost, latency, and truncation behavior.
- The exact-match implementation compared serialized parsed JSON, making property order part of the rule. None of the two failures involved order, but canonical comparison would be cleaner.
- The cost is reconstructed from returned token usage and posted rates, not reconciled to tax-inclusive account billing.
Frequently asked questions
How reliable was MiniMax M3 tool calling in this test?
MiniMax M3 achieved 298 strict passes from 300 live requests, or 99.33%. It emitted the expected single tool call in 299 requests, and all 298 parseable argument objects were schema-valid and exact matches.
Did M3 lose entries from arrays of objects?
Not in this dataset. The arrays-of-nested-objects family passed 30 of 30 trials, including cases with multiple groups and multiple item IDs per group. That result is limited to these schemas and does not prove that every array structure will work.
Is HTTP 200 enough to execute the function?
No. Both failed trials returned HTTP 200. One contained truncated JSON arguments; the other contained no tool call. Check the API status, finish reason, call count, allow-listed name, JSON parse, schema, authorization, and idempotency before execution.
Does MiniMax execute the tool for me?
Not for ordinary client-side function calling. The model proposes a name and arguments; your application validates them and invokes an approved function. MiniMax server tools are a separate feature.
How much did 300 MiniMax M3 tool calls cost?
The calculated token charge was $0.08608308, about 8.6 cents, using returned usage and the published Standard rates in effect for the test. Actual account billing can differ because of pricing changes, taxes, credits, or account terms.
Can I use these results as a production SLA?
No. This is an independent reproducible benchmark, not a service guarantee. Run the downloadable fixtures against your own schemas, traffic pattern, region, account tier, timeout, and application validation before deployment.
Independence notice: MiniMax-AI.chat is an independent informational website and is not affiliated with or endorsed by MiniMax. This experiment used the public paid API. MiniMax did not provide the dataset, select the scoring rules, supply the results, or review this article before publication. Official documentation and the account console remain the sources of record for current API behavior, pricing, access, and terms.