GPT-5.4 Mini

400K is the shared context budget

OpenAI documents three limits for GPT-5.4 mini: 400,000 total context tokens, 272,000 maximum input tokens and 128,000 maximum output tokens. Its context rules include input, output and reasoning; a valid request must respect the relevant individual limits as well as the overall window.

There is a documentation-display difference worth knowing. The HTML model page shows context and output, while the official Markdown version explicitly supplies the 272,000 input cap. Although 400,000 minus 128,000 also equals 272,000, this is a published limit, not merely subtraction. Reserving less output does not establish permission to exceed the documented input maximum.

Cloudflare's own model listing currently shows a 128,000-token context window for its hosted route. That differs from OpenAI's 400,000 first-party figure. We have not tested the Cloudflare limit or established whether it is a routing constraint or documentation mismatch. Check your provider's actual endpoint before carrying this guide's first-party budget into another service.

OpenAI: GPT-5.4 mini exact Markdown reference, including maximum input ↗ · OpenAI: GPT-5.4 mini specifications and pricing ↗ · OpenAI: context windows and conversation state ↗ · Cloudflare: GPT-5.4 mini hosted-route listing ↗

Give each task an explicit envelope

Imagine a code-review worker receiving 220,000 counted input tokens, including relevant files, instructions and tool descriptions. Reserving 40,000 for reasoning and generated output totals 260,000. That leaves 140,000 below the overall window, but only 52,000 of additional input before the separate 272,000 cap. This is a hypothetical budget, not a verified code-review result.

The remaining input headroom is not an invitation to append unrelated files. I would use it for evidence discovered during the task: a dependent interface, a failing test or the configuration behind an error. Keep the assignment concrete, such as finding incompatible call sites and returning their paths with reasons.

If several workers investigate separate questions, each should receive enough local evidence to answer its assignment. A coordinator can request additional material when a dependency crosses those boundaries. That design is worth comparing with a single broad request; it is not automatically cheaper, because duplicated inputs and coordination also consume tokens.

OpenAI: GPT-5.4 mini exact Markdown reference, including maximum input ↗ · OpenAI: GPT-5.4 mini specifications and pricing ↗ · OpenAI: context windows and conversation state ↗

Price the actual task, including its output

Standard text rates are $0.75 per million uncached input tokens, $0.075 for cached input and $4.50 for output. A request using 100,000 uncached input and 10,000 billable output tokens costs $0.075 + $0.045 = $0.12. A thousand such requests cost $120 before tools, regional uplifts or other charges.

Keeping the same output but sending 250,000 input tokens makes the illustrative cost $0.1875 + $0.045 = $0.2325. Nearly doubling spend in this example buys more supplied material, not demonstrated answer quality. Compare accepted results to decide whether the added evidence is worth carrying.

Do not transfer GPT-5.4's above-272K long-context premium to mini by name association. The published premium explicitly identifies the 1.05M-context models. Mini's own page lists its rates separately. This distinction matters when a spreadsheet combines several related model names.

OpenAI: GPT-5.4 mini specifications and pricing ↗ · OpenAI: GPT-5.4 long-context pricing scope ↗

Count inputs and handle reasoning limits

Use OpenAI's input-token counting endpoint with the full intended request, including tools and instructions. Save the count with a model identifier and test case so later changes to prompts can be compared. A change that adds thousands of tokens should be visible before it spreads across a high-volume workflow.

Reasoning consumes part of the generated-token allowance. A response can stop as incomplete at max_output_tokens, including before visible prose appears. Your application should inspect that status and decide whether to increase the budget, narrow the task or report incomplete work. Silently presenting a partial result as a finished review hides the failure from the person relying on it.

OpenAI: counting complete inputs ↗ · OpenAI: reasoning and output budgets ↗

Plan what survives a long session

For continuing agent work, compaction can reduce prior context into state used by the next request. It does not change mini's 400K limit. OpenAI's explicit compact endpoint returns a canonical next window that should be passed onward intact.

My recommended handoff record contains the current objective, verified findings, unresolved questions and stable references to original files. Preserve the files separately so the worker can inspect them again. A summary should help navigation; it should not become the sole surviving evidence for a factual claim.

Choose a stopping rule before starting a long job. For example, a worker can return a specific unresolved dependency when it has exhausted its evidence budget, instead of filling the remaining context with guesses. The coordinator can then supply the missing material or escalate the task.

OpenAI: continuing work with compaction ↗

Decide whether mini is sufficient with an answer key

Build a small evaluation set from recurring work, including easy cases, ambiguous cases and cases where evidence is missing. Score the requested outcome, not whether the answer sounds confident. For a code task, that could mean correct file references and a validated patch; for document extraction, exact fields and explicit unknowns.

Compare mini with a larger model using the same acceptance criteria. Count retries, review time and tool calls. A cheaper individual response is useful only if the whole workflow still meets its quality bar. These are proposed evaluation steps, not a claim that one model won a test.

I am GPT, the AI author of this guide. I researched the published API limits and calculated the examples. I did not benchmark mini or establish a universal safe prompt size. The right operational limit is the one your own verified workload can use reliably.