# GovCloud AI failover: which fallbacks stay inside the boundary

URL: https://infro.io/blog/govcloud-ai-failover-which-fallbacks-stay-inside-the-boundary
Author: INFRO Editorial (https://infro.io/blog/editorial)
Publisher: INFRO
Published: 2026-11-10
Last modified: 2026-11-10
Last reviewed: 2026-11-10 (next review due 2026-12-10)
Topic: Routing and reliability
Format: Checklist

> Allow only fallbacks you have approved inside the GovCloud boundary: the same model in another GovCloud Region, or an approved model there. Treat `us.` and `global.` inference profiles, direct provider APIs and other clouds as out unless your authorization says otherwise, and fail closed when nothing in-boundary can answer.

Key takeaways:
- A `us.` inference profile means the US geography, not the GovCloud boundary: the Claude Fable 5.2 model card lists commercial US Regions as its destinations.
- Write the allowed fallback chain down as a policy, with fail closed as the last step, before you configure any route.
- Check the destination Regions of every profile you send with GetInferenceProfile, and confirm where requests ran from CloudTrail's inferenceRegion field.
- Drill failover with a mock upstream inside your own network and explicit deny policies as tripwires, so a mistaken fallback fails loudly instead of leaving.
- A refusal from Fable 5.2 is an HTTP 200 with stop_reason refusal, so it never triggers transport failover; decide separately what, if anything, may answer it.

## Start with the boundary, not the route

Failover is a data-movement decision. Every fallback target is a place your prompts and completions can go, and in a regulated US environment the list of acceptable places is short and written down somewhere else: your authorization package, your data classification, your contract. A route that keeps the feature up by sending controlled data to a Region outside that list has failed, however green the dashboard looks.

This checklist is for teams running GPT-5.6 and Claude Fable 5.2 on the `bedrock-runtime` endpoint in AWS GovCloud (US). It goes beyond the general case in [multi-region AI traffic](https://infro.io/blog/multi-region-llm-traffic) by treating the boundary as the constraint. AWS describes GovCloud (US) as two physically and logically isolated sovereign Regions, US-East and US-West, operated by U.S. citizens on U.S. soil[1]. Those two Regions are the whole in-boundary failover topology unless your authorization says more.

Two things I could not confirm from the pages read for this article, so you must check them yourself before building on them:

- Whether GPT-5.6 is offered in the GovCloud Regions. AWS lists GPT-5.6 Sol and GPT-5.6 Terra among the OpenAI models on Bedrock[2], but that page does not say which Regions serve them.
- Which Fable 5.2 inference options are enabled in the two GovCloud Regions. The model card's Region table lists `us-gov-east-1` and `us-gov-west-1`, but the options per Region did not come through as text[3].

Read each model's card in your own console and write the answer into the policy below.

## How inference profiles decide where data goes

On Bedrock the model id you send is the location control. A plain model id is In-Region. A geographic profile such as `us.` routes within a geography, and a global profile routes to any supported commercial Region[4]. For Fable 5.2 the card lists three ids: `anthropic.claude-fable-5-2`, `us.anthropic.claude-fable-5-2` and `global.anthropic.claude-fable-5-2`[3].

The trap is the word "US". Geographic profiles keep requests within the geography[5], but the Fable 5.2 card's US profile table shows source Regions such as us-east-1 and us-west-2 routing to destinations among us-east-1, us-east-2 and us-west-2, and the sources listed are commercial Regions[3]. That is the US geography, not the GovCloud boundary. Sending a `us.` id does not make a request GovCloud-safe.

Four further facts matter for a boundary review:

- Destinations depend on the source Region, and AWS tells you to call `GetInferenceProfile` from the source Region to read the current routing[3].
- Prompts and outputs might move outside your source Region during cross-Region inference, and where AWS stores data for abuse detection, it is stored in the destination Region[5].
- Fable 5.2 requires you to opt in to AWS review by setting the data retention mode to `aws_review`[3]. Put that setting in front of your reviewer; it is a retention decision, not a routing one.
- CloudTrail logs cross-Region requests in the source Region, and `additionalEventData.inferenceRegion` shows where each was processed[4].

```python
import boto3

# Run from the source Region your application actually calls.
bedrock = boto3.client("bedrock", region_name="us-gov-west-1")

profile = bedrock.get_inference_profile(
    inferenceProfileIdentifier="<profile id or ARN you intend to send>"
)
for model in profile["models"]:
    print(model["modelArn"])  # every Region here is a place data can go
```

Anything this prints that is not a GovCloud Region is a finding. Run it in CI so a profile change shows up as a failed check.

## The allowed-fallback policy

Write the chain as a table that a reviewer can sign. The rows below are a starting position for a workload holding data that must stay in GovCloud; loosen a row only with a written decision.

| Fallback target | Default | Condition to allow |
| --- | --- | --- |
| Same model, same GovCloud Region (bounded retry) | Allowed | Retries capped; counted in your quota |
| Same model, other GovCloud Region | Allowed | Model confirmed in both Regions; quota in both |
| Different model in GovCloud | Allowed by exception | Approved for this data class; tested for equivalence |
| `us.` profile from a commercial Region | Not allowed | Only if your authorization treats commercial US as in-boundary |
| `global.` profile | Not allowed | Routes to any supported commercial Region[4] |
| Direct OpenAI or Anthropic API | Not allowed | Outside the AWS boundary |
| Another cloud or self-hosted outside your boundary | Not allowed | Separate review |
| Return an error | Always the last step | Application handles it |

AWS's own guidance for availability on cross-Region profiles is to add bounded retries and multi-Region or multi-model fallback in your application[4]. In GovCloud that fallback is yours to build, and the table says where it may point.

Checklist for the policy:

- [ ] Every row has an owner and a date of last review.
- [ ] Model availability per GovCloud Region is recorded from each model card, not assumed.
- [ ] The "different model" row names exact ids, for example which Claude or GPT model may stand in for Fable 5.2 or GPT-5.6, and the tests that approved it ([fallback equivalence](https://infro.io/blog/is-your-fallback-model-good-enough-test-fallback-equivalence)).
- [ ] The last step is an error your application handles, not a silent drop to a looser target. See [fail open or fail closed](https://infro.io/blog/gateway-down-should-ai-traffic-fail-open-or-fail-closed) for the gateway side.

## Refusals are not failures

Fable 5.2 ships safety classifiers for high-risk cybersecurity and most research biology tasks. A blocked request returns HTTP 200 with `stop_reason: "refusal"` and a `stop_details` object, and AWS says customers should handle it as a primary response path[3]. Transport failover keys on timeouts and 5xx, so a refusal passes straight through a retry layer.

The card also describes a beta mechanism: a refusal can carry a token you redeem when retrying the same request on a fallback model, so the retry is billed for the cached prefix at cache-read rates. The valid fallback models listed are Claude Opus 5 and Claude Opus 4.8[3]. Using it is a routing decision with a boundary question attached: the retry model must be one your table allows and one that is served in GovCloud. Do not assume it is.

- [ ] Your client reads `stop_reason` and does not treat 200 as success.
- [ ] A refusal either returns to the user or goes to an approved in-boundary model, never to an unlisted one.
- [ ] If you use the refusal fallback token, the permitted retry models are in the allowed table.

## Enforce it in IAM and SCPs, not only in routing config

Routing configuration states intent. IAM enforces it. The geographic-profile documentation shows that Bedrock evaluates authorization for the profile, the model in the source Region and the model in each candidate destination Region, and that Region-deny SCPs must allow the destinations or carry an inference-profile exception using `bedrock:InferenceProfileArn`[5]. Use the same mechanism in reverse: deny what must never be called.

```json
{
  "Version": "2012-10-17",
  "Statement": [{
    "Sid": "NoGlobalInferenceProfiles",
    "Effect": "Deny",
    "Action": ["bedrock:InvokeModel", "bedrock:InvokeModelWithResponseStream"],
    "Resource": "arn:aws-us-gov:bedrock:*:*:inference-profile/global.*"
  }]
}
```

Adapt the pattern, then test it in a sandbox account; the ARN shapes and action names for your endpoint and API (Converse, Messages, Responses) are yours to confirm. The value is a tripwire: if a mapping drifts to a global id, the call fails with an access error and shows up in CloudTrail instead of succeeding somewhere unapproved.

- [ ] Application roles can invoke only the model and profile ARNs in your table.
- [ ] Region-deny policies are reviewed against every destination of every profile you do use.
- [ ] No role or connection exists for a commercial account that a fallback could reach by accident. The Regions are isolated[1], so a target outside them needs separate credentials, and a connection list is easy to audit.

## Where a gateway fits, and where it doesn't

A gateway adds a hop, and the hop has a location too. INFRO describes its own gateway as running on Cloudflare with a database in Frankfurt, a performance placement and not residency, and lists regional processing as roadmap[6]. If your boundary rules forbid controlled data transiting a service outside the AWS authorization boundary, a hosted gateway between the application and GovCloud Bedrock is out regardless of how well it routes. Settle that first. I could not confirm that INFRO accepts a GovCloud Bedrock Region on a connection, and its docs describe a Bedrock connection as one that wants a region[7].

Where a hosted gateway is permitted for the traffic in question, the mechanics that matter are these. A route is a stable name that resolves to ordered or weighted targets over your own connections, and a weighted target at weight 0 is a standby that never takes a first attempt[8]. Scope each connection and route to an environment so staging keys cannot reach production connections. Per-request records show which connection served and which attempts failed, which is the evidence you need to show no target outside the table was tried. Keep prompt logging off unless your logging policy says otherwise.

## Drill failure without leaving the boundary

A drill that proves failover by actually breaking a production Region, or by sending real prompts to a public endpoint, defeats its own purpose. The method in [failover drills](https://infro.io/blog/llm-failover-drills) fits: inject one fault at a time, with a written hypothesis and a stop condition, and read the request records rather than inferring success from the absence of errors[9].

Adapt it for the boundary:

1. Host the fault-injecting mock inside your GovCloud VPC or equivalent network, speaking the wire format your client uses. Nothing leaves, and the real client and gateway code run unchanged.
2. Make the mock the primary and a real in-boundary Bedrock target the standby, in a staging environment, with synthetic prompts only.
3. Inject 503, slow headers, headers then silence, a mid-stream drop, and every-target-down. Failover applies to a timeout or 5xx before the response starts[8]; mid-stream drops and total failure must be handled by the application.
4. Add the boundary drills: temporarily point the standby at a target your table forbids, such as a `global.` id, and confirm the deny policy turns it into a visible error.
5. After each run, read the CloudTrail `inferenceRegion` field for every Bedrock call and assert that each value is a GovCloud Region[4].
6. Restore the route and record what did not match the hypothesis.

> **Example: Illustrative drill assertion**
> Hypothesis: with the primary returning 503, the standby in the second GovCloud Region answers every request within the client deadline, the fallback share rises, and no request records a Region outside the two GovCloud Regions. The pass condition is the record check, not the lack of user-visible errors. This is an illustrative test design, not a measured result.

## Pre-launch checklist

- [ ] The boundary is defined in writing, and the two GovCloud Regions (or your narrower subset) are named.
- [ ] Availability of GPT-5.6 and Fable 5.2 per Region is confirmed from each model card.
- [ ] Every model id in every mapping is classified: In-Region, `us.`, or `global.`; destinations read with `GetInferenceProfile`.
- [ ] The allowed-fallback table is signed, and its last step is an error.
- [ ] `aws_review` retention and abuse-detection storage in destination Regions are in the review.
- [ ] Refusal handling is tested, and any refusal retry model is in the table.
- [ ] Deny policies and SCPs match the table and have been tested.
- [ ] The gateway hop, if any, is approved for this data class.
- [ ] A drill ran with an in-boundary mock, and the CloudTrail Region check passed.
- [ ] The drill repeats on a schedule, and again whenever a model, profile or Region mapping changes.

## Questions

### Does a us. inference profile keep data inside GovCloud?

Not on the evidence of the Claude Fable 5.2 model card. Its US geographic profile lists commercial source and destination Regions such as us-east-1, us-east-2 and us-west-2 [3]. AWS describes GovCloud (US) as two isolated Regions separate from those [1]. Call GetInferenceProfile from your own source Region and read the destinations before you rely on any profile.

### Is a refused Fable 5.2 request a failover event?

No. The model card says a classifier block returns a standard HTTP 200 with stop_reason refusal and tells customers to handle it as a primary response path [3]. A gateway that fails over on timeouts and 5xx will not see it, so your application or a rule must decide what happens next.

## Sources

1. AWS GovCloud (US) — Amazon Web Services. https://aws.amazon.com/govcloud-us/ (accessed 2026-11-10)
2. OpenAI frontier models on Amazon Bedrock — Amazon Web Services. https://aws.amazon.com/bedrock/openai/ (accessed 2026-11-10)
3. Claude Fable 5.2 - Amazon Bedrock model card — Amazon Web Services. https://docs.aws.amazon.com/bedrock/latest/userguide/model-card-anthropic-claude-fable-5-2.html (accessed 2026-11-10)
4. Route model inference requests across AWS Regions with cross-Region inference — Amazon Web Services. https://docs.aws.amazon.com/bedrock/latest/userguide/cross-region-inference.html (accessed 2026-11-10)
5. Geographic cross-Region inference — Amazon Web Services. https://docs.aws.amazon.com/bedrock/latest/userguide/geographic-cross-region-inference.html (accessed 2026-11-10)
6. Multi-region AI traffic: latency, quotas and data location — INFRO. https://infro.io/blog/multi-region-llm-traffic (accessed 2026-11-10)
7. Connect a provider — INFRO. https://infro.io/docs/providers (accessed 2026-11-10)
8. Routes — INFRO. https://infro.io/docs/routes (accessed 2026-11-10)
9. Failover drills: test LLM provider failure before it happens — INFRO. https://infro.io/blog/llm-failover-drills (accessed 2026-11-10)
