Benefits of GPT-6.1 Sol Prompt Caching on Amazon Bedrock

Your agent sends the same 20,000 tokens of instructions, tool definitions and reference docs on every call, and you pay full price each time. GPT-6.1 Sol prompt caching on Amazon Bedrock bills that repeated prefix at 5% of the normal input rate, the biggest single lever for cutting LLM input cost in agent workloads. Below: four benefits, a worked cost example, a request to copy, and when caching costs you money.

This article covers explicit caching, where you mark the end of the reusable prefix yourself.

How GPT-6.1 Sol prompt caching is priced on Amazon Bedrock

The Bedrock model card lists these Standard-tier prices per million tokens for Global CRIS (cross-Region inference), for requests up to 272K input tokens:

| Item | Rate per 1M tokens | | --- | --- | | Input | $2.00 | | Cache write (1.25x input) | $2.50 | | Cache read (0.05x input) | $0.10 | | Output | $10.00 |

US CRIS and regional bedrock-mantle in us-east-1 cost 10% more on every line, so the percentages below hold either way. A cacheable prefix needs at least 1,024 tokens, a request can create up to four cache writes, and 30m is the only supported TTL (time to live).

Four benefits of explicit caching for agents

1. Repeated context costs 95% less. Take an agent run of 20 calls, each with a 20,000-token static prefix, 500 new input tokens and 300 output tokens. My arithmetic from the card's rates; swap in your own numbers.

| | Input cost for the run | | --- | --- | | No caching | 410,000 tokens x $2.00/M = $0.82 | | Explicit caching | write $0.050 + 19 reads $0.038 + uncached $0.020 = $0.108 |

Input drops about 87%. Add $0.06 of output to both sides and the run falls from $0.88 to about $0.17, roughly 81% cheaper.

2. One reuse pays back the write premium. A write costs 0.25x more than normal input and each read saves 0.95x, so two calls with the same prefix cost 1.30 units of input instead of 2.00. Agent runs make dozens of calls.

3. Cached reads don't eat your rate limit. Per the Bedrock prompt caching docs, cached input tokens read through caching don't count against the input-tokens-per-minute quota, so a fleet sharing one big prefix gets throttled later.

4. You choose what is eligible, and the response shows what happened. Put system rules and tool definitions before the breakpoint and let everything after it change freely. The usage object reports cached_tokens and cache_write_tokens per request, so you check hits instead of trusting the config.

Turn on explicit caching with prompt_cache_options

This request goes to bedrock-mantle using the OpenAI SDK and the Responses API. Set OPENAI_API_KEY to a Bedrock API key and OPENAI_BASE_URL to https://bedrock-mantle.us-east-1.api.aws/openai/v1, as in the model card's sample code.

from openai import OpenAI

client = OpenAI()

STATIC_PREFIX = "<system rules, tool notes, reference docs: 1,024+ tokens>"

def ask(question: str) -> str:
    response = client.responses.create(
        model="openai.gpt-6.1-sol",
        extra_body={"prompt_cache_options": {"mode": "explicit", "ttl": "30m"}},
        input=[
            {
                "type": "message",
                "role": "developer",
                "content": [{
                    "type": "input_text",
                    "text": STATIC_PREFIX,
                    "prompt_cache_breakpoint": {"mode": "explicit"},
                }],
            },
            {
                "type": "message",
                "role": "user",
                "content": [{"type": "input_text", "text": question}],
            },
        ],
        max_output_tokens=512,
    )
    details = response.usage.model_dump()["input_tokens_details"]
    print("read:", details["cached_tokens"], "written:", details.get("cache_write_tokens"))
    return response.output_text

extra_body passes prompt_cache_options into the request JSON. The first call should report tokens written. Later calls inside the TTL should report tokens read and zero written.

In explicit mode only your breakpoints are used, while the default implicit mode also adds an automatic breakpoint on the latest message, which can use up write slots. For Chat Completions, put the same prompt_cache_breakpoint on a text content part.

When GPT-6.1 Sol prompt caching is not worth it

Caching is a bet on reuse, and losing the bet costs you:

• One-off prompts. A write that is never read costs 1.25x, a 25% surcharge on that prefix.
• Short prompts. Under 1,024 tokens nothing is cached, yet the request succeeds, so the miss is easy to overlook.
• Prefixes that change early. A timestamp or user name above the breakpoint means a miss and a fresh write on every call. Move dynamic content below it.
• Sparse traffic. Calls spaced further apart than the 30-minute TTL find an expired cache.

Three Bedrock gotchas as well. Converse supports only implicit caching for this model, and its native cachePoint field doesn't work for explicit caching. bedrock-mantle doesn't support invocation logs, so log the usage block in your own code. Over 272K input tokens, the whole request moves to long-context rates.

The AWS announcement pitches explicit caching at agentic workloads: if your agents re-send a long prefix more than once per half hour, it is one of the cheapest production changes you can ship, and the usage fields prove the saving.