gloss

GPT-6.2 No Longer Caches the instructions Field

GPT-6.2 Astra and Sol, released 17 November, place the Responses API's top-level instructions field after the conversation, so it never reaches the prompt cache.

Two hands move a red network cable toward an empty socket in a patch panel filled with black cables, with a blurred office window behind.
  • GPT-6.2 Astra and Sol, released 17 November, place the top-level instructions field after the conversation. My 4,340-token system prompt in that field got 0 cached tokens on every call.
  • The same eight-turn conversation cost $0.0176 on the input side with GPT-6.1 Sol and $0.0795 with GPT-6.2 Sol. With the prompt moved to a developer message, GPT-6.2 Sol came to $0.0168.
  • Both OpenAI Agents SDKs still send an agent's instructions in that field. LangChain and the Vercel AI SDK don't, and Codex stopped on 5 October.

GPT-6.2 Sol has the same price list as GPT-6.1 Sol: $2 per million input tokens, $0.10 for a cache read, $2.50 for a cache write, $10 for output. So a migration looks free. Change the model name and you're done.

One line in the release notes changes the bill anyway. From GPT-6.2 on, the Responses API puts the top-level instructions field after input when it builds the prompt, where it used to go in front.

OpenAI's prompt cache matches from the first token. Text at the very end of a prompt sits behind everything that changes, so it is never part of a reusable prefix. The caching guide says these tokens are billed at the full input rate "even if you repeat identical instructions".

For many apps, that field is where the system prompt lives.

What I ran

A made-up support policy of 60 rules, about 4,340 tokens, as the system prompt. Responses API, store: false, low reasoning effort, gpt-6.1-sol and gpt-6.2-sol. Each run got a fresh reference number in the first line so no run could read another run's cache.

I sent the prompt two ways: in the instructions field, and as a developer message that is the first item in input. In total 69 requests, about $0.35.

The same request, sent three times

One short question, three identical calls a few seconds apart. Cached tokens on the second call:

Where the prompt sits GPT-6.1 Sol GPT-6.2 Sol
instructions field 4,360 of 4,363 0 of 4,365
First developer message 4,358 of 4,361 4,361 of 4,364

The third call matched the second in all four cases. On GPT-6.2 Sol with the instructions field, the usage block also showed 0 tokens written to the cache. The only thing in front of the instructions was a 20-word question, and a prefix needs 1,024 tokens before it can be cached.

Eight turns

Then a conversation: eight support questions in a row, each request carrying the full history, the way an agent loop does. Input side only.

Setup Cached Full price Input cost
GPT-6.1 Sol, instructions 34,926 24 $0.0176
GPT-6.2 Sol, instructions 0 38,399 $0.0795
GPT-6.2 Sol, developer message 33,826 24 $0.0168

That is 4.5 times the input cost for the same conversation. The rest of each row is cache writes, at 1.25 times the input rate.

On GPT-6.2 Sol with the instructions field, nothing was read from or written to the cache for seven turns. The conversation without the system prompt only passed 1,024 tokens on turn eight, and that is when the first 1,090 tokens were written. A short chat with a long system prompt never gets there.

Per call, the prompt itself goes from $0.0004 as a cache read to $0.0087 at full price. At 10,000 conversations like mine a day, the input bill goes from $176 to $795.

What the field is for now

OpenAI did this on purpose, and it gives you something. The docs now describe instructions as guidance for the current request only.

I tested that. System prompt in a developer message, a one-line note in instructions, and on turns three and four I changed the note. GPT-6.1 Sol dropped to 0 cached tokens on both turns and wrote the whole prefix again, 4,782 and 4,917 tokens. GPT-6.2 Sol kept 4,529 of 4,684 tokens cached on turn three and 4,665 of 4,832 on turn four. Its turn-three answer ended with the line my note asked for.

So on GPT-6.2 you can change a per-turn instruction without paying for the conversation again. On GPT-6.1 that same change was a full cache miss.

Who sends the prompt in that field

I read the current source of seven libraries on 19 November.

  • OpenAI Agents SDK. Python 0.25.0, published within a day of the models, passes an agent's instructions as top-level instructions. So does the JavaScript package, 0.22.0. I found no mention of GPT-6.2 in the Python repository.
  • LiteLLM. On the main branch, the bridge that turns a Chat Completions call into a Responses call joins the leading system messages into instructions for OpenAI and Azure, unless you set store to false. GPT-6.2 only does tool calling through the Responses API, so more traffic will take that bridge.
  • Pydantic AI. On the main branch, an agent's instructions go top-level by default. A setting named openai_cache_instructions moves them into the input.
  • LangChain and the Vercel AI SDK. langchain-openai 1.8.3 and @ai-sdk/openai 4.0.121 keep system messages in input. A system role message as the first item cached fine in my test, 4,398 of 4,401 tokens.
  • Codex. A commit on 5 October moved its base instructions from the field into a developer message, six weeks before the models shipped.

I could not install packages in this run, so the SDK part is source reading. My requests had the shape those libraries build, but I didn't run the libraries themselves.

Two more changes in the same release

Edited history now costs you reasoning. I asked a puzzle, then sent the conversation back with one sentence removed from my earlier question. GPT-6.2 Sol answered with a 200, and a field named input_transformations listed the reasoning item as removed with the reason prefix_mismatch. Editing the developer message did the same. With the history untouched the list was empty, and GPT-6.1 Sol returned an empty list for all three.

Anthropic's Fable 5.2 returns a 400 for this kind of edit. OpenAI answers, and tells you in a field you have to read.

Flex is gone for these models. A request with service_tier: flex came back as a 400 that points to background mode. The replacement is a completion window of two hours at 30% off or eight hours at 40% off. Flex on GPT-6.1 Sol is half price, and so is Batch on both. I didn't test the windows.

What I'd do

Move the stable system prompt into a developer message as the first item in input. Leave instructions for the things that belong to one turn.

After the switch, read usage.input_tokens_details.cached_tokens on the second request. If it is 0 and your prompt is over 1,024 tokens, something still sends it at the end. If a framework builds the request for you, log one raw request body and look where the prompt went.

Log input_transformations too. An agent that trims old tool output will see it fill up.

I didn't test GPT-6.2 Astra, Chat Completions, previous_response_id, requests with tools, or Azure. The docs describe the same behaviour for Astra, where input costs $8 per million tokens and a cache read $0.40.

Check where your system prompt lands before you change the model name.