# GPT-6 Astra on Bedrock: the endpoint decides what you audit

GPT-6 Astra reached GA on Amazon Bedrock on September 8, 2026 with a 1,050,000-token context window and an architectural fork: the model is served by `bedrock-runtime` and by `bedrock-mantle`, and each endpoint withholds something the other gives. I break down what each path costs in money, in quota and in auditable trail — and why, for regulated workloads in Brazil, the conversation starts and ends at data residency.

- URL: https://fernando.moretes.com/blog/gpt-6-astra-no-bedrock-o-endpoint-decide-o-que-voce-audita-openai-gpt-6

- Markdown: https://fernando.moretes.com/blog/gpt-6-astra-no-bedrock-o-endpoint-decide-o-que-voce-audita-openai-gpt-6/article.md?lang=en

- Published: 2026-09-09T10:16:32.121Z

- Category: AI & Agents

- Tags: amazon-bedrock, openai, gpt-6-astra, finops, governanca, cross-region-inference, prompt-caching, lgpd

- Reading time: 7 min

- Source: [OpenAI GPT-6 Astra is now generally available on Amazon Bedrock](https://aws.amazon.com/about-aws/whats-new/2026/09/openai-gpt-6-astra-on-amazon-bedrock/)

---

GPT-6 Astra reached GA on Amazon Bedrock on September 8, 2026 with a number everyone repeated — a 1,050,000-token context window — and an architectural decision almost nobody mentioned: the model is served by two distinct endpoints, `bedrock-runtime` and `bedrock-mantle`, and they do not offer the same guarantees. Picking one is not an SDK preference. It is choosing, inside the same request, between explicit prompt caching and invocation logging — because the model card does not give you both on the same path.

## What GA actually shipped

The model card is more informative than the announcement. `openai.gpt-6-astra` has a 1,050,000-token input window, a 128,000-token output ceiling and an April 30, 2026 knowledge cutoff. Input accepts text and image; output is text only — anyone expecting image or audio generation from the same model ID will hit a wall. EOL no sooner than September 8, 2027, with a legacy period of at least 6 months: that is a one-year contractual floor for planning migration, and it is the kind of fact that belongs in your ADR, not in your slide.

**The API surface is smaller than it looks.** On `bedrock-runtime`, the model answers on Converse, Responses and Chat Completions — and **not** on `InvokeModel`. If your internal wrapper standardized everything on `InvokeModel` to get a single instrumentation point, it does not call Astra. On `bedrock-mantle`, only Responses and Chat Completions, served at `/openai/v1/responses` and `/openai/v1/chat/completions`.

**One service tier.** Standard only. Priority, Flex and Reserved are all listed as unsupported. There is no reserved throughput to hold peak latency, and no Flex tier to soften an overnight batch. Your whole workload shares the same pay-per-token queue, and your only control over tail latency is which Region you pick.

## One request, two endpoints, different guarantees

The same model ID crosses two control planes. The left column gives you Guardrails and invocation logs; the right one gives you explicit caching and server-side tools — and disappears from the log. The inference profile you name decides which Region stores the response.

### 🟧 AWS — bedrock-runtime (/openai/v1)

- Converse API única via com Guardrails (ai)
- Responses + Chat Completions sync only, background=400 (ai)
- Invocation logging S3/CW, 100 KB inline (storage)

### 🟧 AWS — bedrock-mantle (Astra: só us-west-2)

- Responses /v1 server-side tools, async (ai)
- Explicit prompt cache 1.024 tok, 4 breakpoints, TTL 30m (data)
- Fora do invocation log ação bedrock-mantle:CreateInference (security)

### 📡 Cross-Region Inference

- us.openai.gpt-6-astra 5 Regiões US/CA (network)
- global.openai.gpt-6-astra qualquer Região comercial (network)

### 🤖 Modelo e faixa de preço

- openai.gpt-6-astra 1.050.000 in / 128.000 out (ai)
- Faixa 272K acima disso: 2x input, 1,5x output (data)

### 🔐 Rastro e retenção

- store=true (default) input+output por 30 dias (storage)
- CloudTrail quem chamou, não o conteúdo (security)

### Flows

- app -> rt-converse: want Guardrails: only this way
- app -> rt-responses: OpenAI SDK, bedrock-runtime base URL
- app -> mt-responses: OpenAI SDK, bedrock-mantle base URL
- rt-converse -> geo: geographic profile
- rt-responses -> global: global profile
- geo -> astra: $11 in / $55 out per 1M
- global -> astra: $10 in / $50 out per 1M
- mt-responses -> astra: in-Region us-west-2
- mt-responses -> mt-cache: explicit prompt_cache_breakpoint
- mt-cache -> astra: read at $1.10 per 1M
- mt-responses -> mt-gap: never reaches the log
- astra -> tier: reprices the whole request
- rt-converse -> rt-log: request and response captured
- rt-responses -> rt-log: captured (sync)
- global -> store: stores in the Region that served it
- app -> trail: control plane

## The bill your routing writes

Astra's pricing is not a pair of numbers; it is a two-dimensional matrix, and both dimensions are architectural decisions.

**Dimension 1 — the inference profile.** Global CRIS costs US$ 10.00 per 1M input tokens and US$ 50.00 per 1M output. In-Region and Geo CRIS cost US$ 11.00 and US$ 55.00. You pay 10% more precisely to gain control over where inference happens. That is the explicit price of residency, and it is cheap next to a fine.

**Dimension 2 — the 272K cut.** Above 272,000 input tokens, the entire request reprices: US$ 20.00 input and US$ 75.00 output on global, US$ 22.00 and US$ 82.50 in-Region. It is not the overflow that changes tier — it is everything. A 280,000-token prompt on global costs US$ 5.60 of input; the same prompt trimmed to 270,000 costs US$ 2.70. A 3.7% difference in size becomes 107% on the invoice.

**And you do not get `CountTokens`.** The `bedrock-runtime` feature list marks `CountTokens` and structured outputs as unsupported for this model. So: there is a price cliff at 272,000 tokens and no official API to learn which side of it your payload landed on before you send. Counting has to happen in your code, with the right tokenizer and a safety margin — and the ceiling has to be a parameter, not a number buried inside a function.

**Quota is a third currency.** The burndown is 10x: 1 output token consumes 10 TPM units. A run that emits the full 128,000-token ceiling burns 1,280,000 units — 4.7 times what reading 272,000 input tokens costs you in quota. In an agent, output is the scarce resource, not context.

## Explicit caching and the 30-minute math

Prompt caching for OpenAI models on Bedrock is not the same mechanism as for Claude. There is no `cachePoint` in Converse: you mark `"prompt_cache_breakpoint": {"mode": "explicit"}` on a Responses API content block, with a 1,024-token minimum prefix and up to 4 breakpoints. `prompt_cache_options.mode` decides the behavior: `implicit` (the default) adds an automatic breakpoint on the latest message on top of yours; `explicit` disables the automatic one — and if you declare no breakpoint at all, the request simply does not use caching and incurs no write charge. Minimum 30-minute TTL, controlled by `prompt_cache_options.ttl`.

**The savings are aggressive and break-even is immediate.** A write costs 1.25x uncached input; a read costs 10% of it. Take a stable 40,000-token prefix — instructions, tool definitions, reference documents — running 30 calls inside the same 30-minute window on `bedrock-mantle`: without caching, 30 × 40,000 × US$ 11.00/1M = US$ 13.20. With caching, US$ 0.55 of write plus 29 reads at US$ 0.044 = US$ 1.83. An 86% drop, and the **second** call already paid for the write.

**One more detail changes capacity planning:** tokens read from cache do not count against the input-tokens-per-minute quota. Caching here is not only a discount — it is headroom.

The problem is where it lives. For Astra, the model card lists Implicit and Explicit Prompt Caching **only** on `bedrock-mantle`, through the Responses API. And `bedrock-mantle` for Astra exists only in `us-west-2`, with no geographic profile and no global profile.

> **The trade-off nobody put in the announcement:** The model invocation logging documentation is explicit: logging only covers calls made through the `bedrock-runtime` endpoint, and calls to the same APIs on `bedrock-mantle` are **not captured**. Combine that with the model card: Astra's explicit caching exists only on `bedrock-mantle`; Guardrails exist only on `bedrock-runtime`, and there only through the Converse API. The result is a three-way choice nobody gets whole — an 86% caching discount, a Guardrails filter, or prompt and response written down for audit. You pick two at most, and in a high-volume agent all three show up in the same requirement.

## bedrock-runtime vs bedrock-mantle for openai.gpt-6-astra
| Criterion | Dimension | bedrock-runtime | bedrock-mantle |
| --- | --- | --- | --- |
| APIs for this model | — | Converse, Responses, Chat Completions (no Invoke) | Responses and Chat Completions, at `/openai/v1` |
| Regions | — | No in-Region at all; Geo across 5 US/CA Regions; Global including sa-east-1 | Only `us-west-2`, in-Region, no Geo and no Global |
| Explicit prompt caching | — | Not listed on the model card | Implicit and Explicit, Responses API only |
| Guardrails | — | Yes, exclusively through the Converse API | Not listed |
| Invocation logging | — | Yes: metadata, input and output up to 100 KB inline | Not captured |
| Server-side tool use and async execution | — | No; `background=true` returns 400 | Yes, both |
| IAM action authorized | — | `bedrock:InvokeModel` on the target and on the default project | `bedrock-mantle:CreateInference` |
| Price per 1M (short / long context) | — | Global: 10/50 and 20/75. Geo: 11/55 and 22/82.50 | In-Region: 11/55 and 22/82.50 |

## Residency, retention, and the IAM that misses the other endpoint

Here the analysis stops being about cost. The Responses API is stateful by default: with `store` set to `true` — the default, to match the OpenAI specification — Bedrock retains the request and the response for 30 days so `previous_response_id` works. And the documentation is blunt about where: the response lives in the Region that served the request. With a global profile, that is any commercial Region the profile routed to.

**Translating for anyone operating under BACEN and LGPD:** in `sa-east-1`, Astra exists **only** through the global profile. No in-Region, no Geo. A team in São Paulo calling Astra is accepting worldwide routing and, by default, 30-day retention of input and output outside the country. The geographic path `us.openai.gpt-6-astra` covers five Regions — us-east-1, us-east-2, us-west-1, us-west-2 and ca-central-1 — and none of them is Brazil. There is no national residency path for this model today. The mitigation is `store` explicitly set to `false` on every request, or the account retention mode set to `none`, which rejects `store=true` outright. But zero retention costs you stateful multi-turn conversation — which is exactly why many teams moved to the Responses API.

**And there is an IAM trap.** The two endpoints authorize actions from different namespaces: `bedrock:InvokeModel` on one side, `bedrock-mantle:CreateInference` on the other. An SCP written as `"Action": "bedrock:*"` to restrict which models the organization may invoke simply does not match `bedrock-mantle:*`. Add the condition-key behavior: `bedrock:ModelArn` is valued at the profile the request named — never the destination models CRIS routed to. You cannot constrain the processing Region by policy on the target; you constrain it only by picking the right profile.

## Anti-patterns you can already predict

- **Treating `bedrock-mantle` as an alias for `bedrock-runtime`**: swapping the base URL looks harmless because the OpenAI SDK works against both, but it changes the IAM action, drops invocation logging and pins the workload to `us-west-2`. That is a control-plane migration disguised as an environment variable.
- **Writing the organizational guardrail only over `bedrock:*`**: the SCP that approves models by ARN today does not reach `bedrock-mantle:CreateInference`. The unapproved path stays open and never shows up in invocation logs — silent failure at both ends.
- **Sending the whole document because 1.05M fits it**: crossing 272,000 tokens doubles input price and multiplies output by 1.5 across the entire request. Retrieval and chunking did not become legacy with a big context window; they became cost control.
- **Leaving `store` at its default in a regulated workload**: `true` retains input and output for 30 days in the Region that served the request. With a global profile and no residency clause in your design, you just exported customer data without a single line of code saying so.
- **Porting OpenAI code without reading the differences**: on `bedrock-runtime`, `background=true` returns 400 and `model` is required on every request, including ones that pass `previous_response_id`. Both errors surface in production, not in the happy-path test.
- **Placing the cache breakpoint after variable content**: a prefix with any dynamic part invalidates the whole chain. The symptom is high `cache_write_tokens` with `cached_tokens` at zero, call after call — you pay 1.25x and never read.

## Well-Architected lens on this decision

- **security**: Guardrails only reach Astra through the Converse API on `bedrock-runtime`; every other path runs without a managed filter and you reimplement injection detection yourself. Cover both action namespaces in the SCP and treat `store=false` as a security control, not an optimization.
- **reliability**: Only the Standard tier exists: no Priority to hold peak latency and no Reserved for guaranteed capacity. Design timeouts, backoff retries and idempotency assuming throttling, and keep a fallback model with an identical output contract — not one you hope answers similarly.

> **What I would do:** I would start on `bedrock-runtime` with Converse and the geographic profile `us.openai.gpt-6-astra`, accepting the 10% premium and giving up explicit caching, because Guardrails and invocation logging are what I have to show in an audit — and the technical conversation about cache discounts ends fast when the auditor asks for the prompt behind one specific decision. I would keep `bedrock-mantle` for high-volume internal workloads in `us-west-2`, on data already classified as non-sensitive, with my own telemetry recording the call because Bedrock will not. For a Brazilian client under BACEN, I would not put Astra in the path of customer data while `sa-east-1` only offers the global profile: the lesson I learned the expensive way is that data residency is not negotiable in an architecture review — it is a prerequisite that kills the whole proposal when it shows up at the end. And I would write a one-page ADR about nothing but the endpoint choice, because in six months nobody will remember that the base URL changed the IAM action.

## References

- [AWS What's New — OpenAI GPT-6 Astra is now generally available on Amazon Bedrock](https://aws.amazon.com/about-aws/whats-new/2026/09/openai-gpt-6-astra-on-amazon-bedrock/)
- [AWS Machine Learning Blog — Take on your most ambitious work with GPT-6 Astra on Amazon Bedrock](https://aws.amazon.com/blogs/machine-learning/take-on-your-most-ambitious-work-with-gpt-6-astra-on-amazon-bedrock/)
- [Amazon Bedrock User Guide — Model card: GPT-6 Astra (quotas, preços, Regiões, endpoints)](https://docs.aws.amazon.com/bedrock/latest/userguide/model-card-openai-gpt-6-astra.html)
- [Amazon Bedrock User Guide — Responses API e o endpoint bedrock-mantle](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-mantle.html)
- [Amazon Bedrock User Guide — Prompt caching (breakpoints, TTL, cobrança)](https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html)
- [Amazon Bedrock User Guide — Monitor model invocation using CloudWatch Logs and Amazon S3](https://docs.aws.amazon.com/bedrock/latest/userguide/model-invocation-logging.html)
- [Amazon Bedrock User Guide — Models at a glance](https://docs.aws.amazon.com/bedrock/latest/userguide/model-cards.html)
- [Unite.AI — OpenAI's GPT-6 Astra Reaches General Availability on Amazon Bedrock](https://www.unite.ai/openais-gpt-6-astra-reaches-general-availability-on-amazon-bedrock/)

## Verdict

GPT-6 Astra on Bedrock is a real capability upgrade with an uneven governance surface, and the unevenness is what decides your architecture. Use `bedrock-runtime` with Converse and a geographic profile when the workload carries customer data, an audit requirement or a mandatory content filter — the extra 10% per token buys Guardrails, invocation logging and control over where inference happens. Use `bedrock-mantle` when volume is high, the prefix is stable, the data is non-sensitive and `us-west-2` is acceptable — there explicit caching cuts 86% off prefix cost and frees quota, but you own the audit trail yourself. Do not put Astra in the path of Brazilian regulated data while `sa-east-1` offers only the global profile: in that scenario the problem is neither price nor latency — it is that you cannot state where the data was processed, and that sentence ends any architecture review at a bank. Revisit the decision when a geographic profile with a Brazilian Region appears, when caching reaches `bedrock-runtime`, or when invocation logging starts covering `bedrock-mantle` — any one of the three dissolves the central trade-off in this piece.

**Rating:** Adote com endpoint escolhido por requisi