Kimi K3.1 Pro Answers Up to a Million Tokens — but the Default Stops at 131,072

Kimi K3.1 Pro Answers Up to a Million Tokens — but the Default Stops at 131,072

Kimi K3.1 Pro’s context window is 1,048,576 tokens and its output ceiling can be set as high as 1,048,576 as well, which is unusual: on most 1M-context models the answer is capped far below the input. But the field that controls it, `max_completion_tokens`, defaults to 131,072 [VENDOR — Kimi platform documentation, 26 October]. If you set nothing, you get an eighth of the ceiling, and a long generation stops early without an error you are likely to notice. OrcaRouter‘s Kimi K3.1 Pro API card lists the serving-side cap at 943,718 output tokens, which is the number that matters when you call it through our route rather than through the vendor’s own endpoint.

Two numbers, three ceilings, one default — and a class of silent failure that shows up as “the model stopped mid-document” rather than as an exception.

The three ceilings

LimitValueSource
Context window1,048,576Vendor + our card
`max_completion_tokens` default131,072Vendor
`max_completion_tokens` maximum1,048,576Vendor
Output cap on our route943,718Our card

The gap between the vendor’s 1,048,576 and our serving cap of 943,718 is a routing-layer limit, and it is the honest number to design against if you call us: about 90% of the context window can come back as one answer. On any provider, the practical maximum is the smaller of the model’s ceiling and the serving stack’s cap, and only one of those is on the vendor’s page.

Why a 1M output ceiling is not a gimmick

Most 1M-context models are built to read a lot and write a little: a 64K or 128K output cap covers summarisation and code generation comfortably, and the asymmetry is deliberate. Kimi K3.1 Pro’s ceiling is set near the context window, which is a statement about the workload it expects — long-horizon writing and agentic work that emits large artifacts.

Concretely, the things this unlocks:

Whole-file rewrites of large codebases. A 300,000-token module rewritten in place needs an output budget most models cannot offer. The failure mode on a 128K-capped model is a truncated file that still parses as a diff, which is worse than an error.

Long documents drafted in one pass. A 200,000-token report written from a 700,000-token source corpus fits inside one request rather than a chunk-and-splice pipeline, and the model keeps one spine across the whole document instead of stitching.

Agent transcripts that never lose the tail. An agent that must return the full modified state of a large artifact at every step is bounded by output, not by context.

Structured output at scale. A single JSON payload of 100,000 tokens — an entire dataset transformation, one object graph — is inside the ceiling.

A fifth use is less obvious and more common: recovering from a bad turn. When an agent’s context is nearly full and it has to return the modified state of a large artifact to continue, it needs one long message rather than a summary. Models capped at 32K or 64K output handle that by summarising, which loses detail exactly where the agent needed it — and the loss shows up three steps later as a wrong edit rather than immediately as an error.

None of those are free. Output bills at $10.00 per million, so a full 943,718-token answer costs about $9.44 on its own, before input. A long-output workload is a budget line, not a rounding error, and the 131,072 default is the vendor’s implicit suggestion about the typical case.

See also: Complete Guide to Managed UK WordPress hosting for Business Growth

The silent-failure shape

Truncation at the default does not raise. The response ends, `finish_reason` reports a length stop rather than a natural one, and the JSON you asked for is a prefix of the JSON you wanted. In production this presents as:

• a parser error several steps downstream, with a document that looks structurally fine for the first 100,000 tokens;

• an agent that “forgot” the last section of a report it was asked to reproduce;

• a diff that applies cleanly and deletes the tail of a file.

The fix is one line — set `max_completion_tokens` explicitly on every request — and the discipline worth adopting is to set it from the task, not from the model. A routing-classification call needs 200 tokens, not 131,072 and certainly not a million; an unbounded value is a way to turn a runaway generation into a $9.44 invoice.

Sizing the field per task

TaskSensible `max_completion_tokens`
Classification, routing, extraction200–2,000
Short answer with reasoning16,000–32,000
Code generation, single file32,000–64,000
Long report or multi-file patch128,000–256,000
Whole-corpus rewrite, agent state dump400,000–900,000

Two notes on the middle rows. First, reasoning tokens count against the completion budget, and on this model reasoning is roughly 63% of output [INDEPENDENT — Artificial Analysis]. A 64,000-token cap on a hard task may spend 40,000 of it thinking and give you a shorter answer than you expected. Budget for thinking explicitly. Second, the model’s effort default is `max` [VENDOR], so the first request you send is the one most likely to hit whatever ceiling you set.

What this means for the 1M-context pitch

A 1M context window is only useful if you can act on what you read. The pairing here — 1M in, up to ~0.94M out through a routing layer like ours — is more useful than either number alone, and it is the specific reason long-horizon work is plausible on this model rather than aspirational.

The pair also explains the cost profile the independent evaluators measured: about two million input tokens and 55,000 output tokens per task [INDEPENDENT]. Most teams run this model far on the read side of its envelope and nowhere near the write side. That is fine, and it means the output ceiling is mostly an insurance policy: you will not hit it, and you will be glad it is there the day a task needs a 200,000-token answer in one shot.

Set the ceiling per request. Keep the default in mind as a trap rather than a recommendation. And if a long generation ends early with no error, check `finish_reason` before you check the model.

Sourcing note: context window, the 1,048,576 output maximum, the 131,072 default and the reasoning-effort default are from Moonshot’s Kimi platform documentation, fetched 26 October 2026. The 943,718 serving cap is OrcaRouter’s own published card for this model and reflects our routing layer, not the vendor’s ceiling. The reasoning share of output and the per-task token counts are Artificial Analysis on index v4.3.2 of the same date. Task-level sizing recommendations are ours and are illustrative rather than published.