GPT-5.6 프롬프트 가이드: 1.5배 및 10배 이상 청구되는 두 가지 기본값

Prompting GPT-5.6 well is mostly two request parameters, and both default to the expensive setting. Omitting reasoning_effort billed 1.5x as much as pinning it to "none" across our 50-call matrix, with identical answers; leaving a stable prefix unmarked bills it at 10x the cached read rate on every call. This guide is the request-shape playbook that falls out of the measurements in our GPT-5.6 cost guide: what a well-formed request looks like, how to set the effort dial per task, how to lay out a prompt so the cache does its work, and what breaks when you port prompts from GPT-5.5.

TL;DR

• Pin reasoning_effort on every GPT-5.6 request: omitting it billed 1.5x as much as "none" with identical answers on our 4-task matrix.
• Accepted efforts run none through xhigh; "max" returns a 400 on Sol and Terra alike.
• Mark stable prefixes with explicit cache breakpoints: cached reads bill at 10% of the input rate, writes at 1.25x, so mark what repeats, not what merely looks stable.
• prompt_cache_options and breakpoints return a 400 on GPT-5.5 and older; version-gate the rollout.

What should a GPT-5.6 request look like?

Start from this shape and delete what you do not need. It pins the two levers explicitly instead of inheriting the expensive defaults:

{
  "model": "gpt-5.6-terra",
  "reasoning_effort": "low",
  "prompt_cache_options": { "mode": "explicit", "ttl": "30m" },
  "prompt_cache_key": "tenant-42",
  "messages": [
    { "role": "system", "content": "…stable instructions…",
      "prompt_cache_breakpoint": { "mode": "explicit" } },
    { "role": "user", "content": "…the part that changes per request…" }
  ]
}

Enter fullscreen mode Exit fullscreen mode

The ordering rule behind it: everything stable goes before the breakpoint, everything per-request goes after, and anything dynamic (timestamps, user names, retrieved documents that differ per call) never sits inside the marked block, because one changed byte re-bills the block at the 1.25x write premium. The prompt_cache_key routes repeats to the same cache; use one stable key per tenant or session, and note the documented soft limit of about 15 requests per minute per key.

How should you set reasoning_effort?

Explicitly, always: the one setting to avoid is no setting. In our measurements, requests without reasoning_effort billed 1.5x as much as requests pinned to "none", and the answers were identical across the matrix. The accepted values run none, low, medium, high, xhigh; "max" is rejected with a 400 listing the valid range. What the dial bought on our one-line math check, on Luna:

reasoning_effort Reasoning tokens Answer Cost per call none 0 correct $0.000062 low 52 correct $0.000410 medium 85 correct $0.000608 high 74 correct $0.000542

GPT-5.6 was the only family in our token usage anatomy study that stayed correct with thinking fully off on that check, which makes none a defensible default for extraction, classification, formatting, and retrieval-shaped calls. When it does reason, the tokens are invisible and billed at the full output rate: 88% of the output charge on the default-setting math example was chain of thought you cannot read. Step up the dial when your evals say the task needs it, not because the default already spent it.

How do you lay out a prompt so the cache pays?

Layer the prompt in order of stability and mark the layers: system instructions first, then tool definitions, then reference documents, each ending at a breakpoint, with the volatile user turn after the last mark. You get four cache writes per request; in the default implicit mode an automatic breakpoint on the latest message consumes one of them, so explicit mode gives you the full four and, more importantly, caches only what you mark.

Partial reuse is the payoff, and it is measured. With a stable block A and a swapped tail B, the meter re-billed only the tail: 1,212 tokens read back at the cached rate, 1,210 written fresh at the premium, out of a 2,431-token prompt, reconciling against the rate card to the digit. Three budgeting rules follow:

• Reads bill at 10% of the input rate, so a warm layered prefix flattens the input side of the bill.
• Writes bill at 1.25x, so a marked block that never gets read again costs 25% more than not caching. Mark what repeats, not everything that looks stable.
• On full repeats the matched length can snap below the mark (1,897 cached of a 2,422-token write in one probe), so budget on the discount rate, not exact match counts; our cache minimums study has the per-family floors.

The ttl: "30m" floor is a guaranteed minimum, not a cap, and it is 6x Claude’s default 5 minutes; there is no 24-hour tier anymore, so daily-batch workloads that leaned on extended retention should re-run the break-even.

What breaks when you port prompts from GPT-5.5?

Two things break loudly and one silently. Loudly: prompt_cache_options and prompt_cache_breakpoint return a clean 400 on GPT-5.5 and older (prompt_cache_options is not supported on this model), so any shared prompt-builder needs a version gate. Also loudly: "max" effort, which some 5.5 configs carried, is rejected.

Silently, and more expensively: GPT-5.6 reasons by default where a 5.5 workload may have had reasoning off. A ported prompt that never sets reasoning_effort picks up the 1.5x omission tax at the same rate card. The cache migration runs the other way: 5.5’s automatic prefix detection needed no markup but could not be triggered or debugged; on 5.6 the same prompt does nothing until you mark it, and then reports every write in usage.prompt_tokens_details.cache_write_tokens, where a miss shows up as a zero in a field you created rather than as silence.

Which tier should run the prompt?

The same request shape runs on all three tiers, so tier choice is a price decision, not a prompting one: Sol at $5/$30 per million tokens, Terra at half, Luna at a fifth. Once the prefix is stable, keyed, and warm, the cached read discount flattens the input side on every tier, which makes output price the differentiator; step down as far as output-quality evals allow. The full tier arithmetic, including the write-premium break-even per tier, is in the cost guide.

FAQ

Does GPT-5.6 support reasoning_effort: “max”?

No. Requests with "max" return a 400 listing none through xhigh as the valid values, on Sol and Terra alike. Workloads that want the ceiling should send xhigh explicitly.

Do the cache breakpoints work on GPT-5.5?

No. GPT-5.5 and older reject prompt_cache_options and breakpoint markers with a 400. On those models you are back to automatic prefix detection, which cannot be triggered, keyed, or debugged; treat cache behavior as best-effort there and version-gate any prompt builder that emits the new fields.

How many breakpoints should a prompt actually use?

As many layers as genuinely repeat, up to the budget: four writes per request, one of which the implicit auto-breakpoint consumes unless you switch to explicit mode. A typical layered prompt needs two or three (instructions, tools, reference block), and a fifth marker is accepted without error but simply shares the write slots, since a later mark covers everything before it.

All numbers in this guide were measured through the Synthorai gateway on the day-one GPT-5.6 models and reconcile against the live usage.cost meter; methodology and raw probes are in the cost guide and the cache minimums study. Verify against your own usage records; rates and accepted values may change.