Config options live under `plugins.entries.amazon-bedrock.config.discovery`:

```json5
{
  plugins: {
    entries: {
      "amazon-bedrock": {
        config: {
          discovery: {
            enabled: true,
            region: "us-east-1",
            providerFilter: ["anthropic", "amazon"],
            refreshInterval: 3600,
            defaultContextWindow: 32000,
            defaultMaxTokens: 4096,
          },
        },
      },
    },
  },
}
```

| Option | Default | Description |
| ------ | ------- | ----------- |
| `enabled` | auto | In auto mode, Apus only enables the implicit Bedrock provider when it sees a supported AWS env marker. Set `true` to force discovery. |
| `region` | `AWS_REGION` / `AWS_DEFAULT_REGION` / `us-east-1` | AWS region used for discovery API calls. |
| `providerFilter` | (all) | Matches Bedrock provider names (for example `anthropic`, `amazon`). |
| `refreshInterval` | `3600` | Cache duration in seconds. Set to `0` to disable caching. |
| `defaultContextWindow` | `32000` | Context window used for discovered models with no known token limits (override if you know your model limits). |
| `defaultMaxTokens` | `4096` | Max output tokens used for discovered models with no known token limits (override if you know your model limits). |

The Bedrock `ListFoundationModels` and `GetFoundationModel` APIs return no
token-limit metadata, only model ID, name, modalities, and lifecycle
status. Apus ships a lookup table of known context windows and output
limits for popular Bedrock models (Claude, Nova, Llama, Mistral, DeepSeek,
and others) so session management, compaction thresholds, and
context-overflow detection work correctly for those models.

Discovered models not in the table fall back to `defaultContextWindow`
and `defaultMaxTokens`. If a model you use is missing accurate limits,
override it with an explicit
`models.providers["amazon-bedrock"].models` entry.

Apus discovers **regional and global inference profiles** alongside
foundation models. When a profile maps to a known foundation model, the
profile inherits that model's capabilities (context window, max tokens,
reasoning, vision) and the correct Bedrock request region is injected
automatically. This means cross-region Claude profiles work without manual
provider overrides. Global cross-region profiles (`global.*`) are listed
first in `apus models list` since they generally offer better capacity
and automatic failover.

Inference profile IDs look like `us.anthropic.claude-opus-4-6-v1` (regional)
or `anthropic.claude-opus-4-6-v1` (global). If the backing model is already
in the discovery results, the profile inherits its full capability set;
otherwise safe defaults apply.

No extra configuration is needed. As long as discovery is enabled and the IAM
principal has `bedrock:ListInferenceProfiles`, profiles appear alongside
foundation models in `apus models list`.

Some Bedrock models support a `service_tier` parameter to optimize for cost
or latency. The following tiers are available:

| Tier | Description |
|------|-------------|
| `default` | Standard Bedrock tier |
| `flex` | Discounted processing for workloads that can tolerate longer latency |
| `priority` | Prioritized processing for latency-sensitive workloads |
| `reserved` | Reserved capacity for steady-state workloads |

Set `serviceTier` (or `service_tier`) via `agents.defaults.params` for
Bedrock model requests, or per-model in
`agents.defaults.models["<model-key>"].params`:

```json5
{
  agents: {
    defaults: {
      params: {
        serviceTier: "flex", // applies to all models
      },
      models: {
        "amazon-bedrock/mistral.mistral-large-3-675b-instruct": {
          params: {
            serviceTier: "priority", // per-model override
          },
        },
      },
    },
  },
}
```

Valid values are `default`, `flex`, `priority`, and `reserved`. Claude
Fable 5, Opus 5, and Sonnet 5 only support the `default` tier; Apus warns and
ignores `flex`, `priority`, or `reserved` requested for those models. For
other models, not every model supports every tier -- an unsupported tier
returns a Bedrock validation error, and the error message can be
misleading (for example "The provided model identifier is invalid"
rather than naming the tier as the problem). If you see this error, check
whether the model supports the requested tier.

Bedrock rejects the `temperature` parameter for Claude Opus 5, Opus 4.8,
and Opus 4.7. Apus omits `temperature` automatically for any matching Bedrock
ref, including foundation model ids, named inference profiles, application
inference profiles whose underlying model resolves to Opus 5/4.8/4.7 via
`bedrock:GetInferenceProfile`, and dotted `opus-4.7`/`opus-4.8` variants
with optional region prefixes (`us.`, `eu.`, `ap.`, `apac.`, `au.`, `jp.`,
`global.`). No config knob is required, and the omission applies to both
the request options object and the `inferenceConfig` payload field.

Use `amazon-bedrock/anthropic.claude-opus-5` on the Messages-API Bedrock
endpoint, or a regional/global inference profile such as
`global.anthropic.claude-opus-5` when it appears in Bedrock discovery.
Apus applies the 1,000,000-token context window, 128,000-token output
limit, image input, prompt caching, refusal-safe streaming, and native
`xhigh`/`max` effort levels.

Adaptive thinking defaults to `high`. `/think off` disables thinking, while
`/think xhigh|max` keeps adaptive thinking enabled. Apus omits custom
sampling parameters and unsupported non-default service tiers.

Use `amazon-bedrock/anthropic.claude-fable-5` in `us-east-1`, or the
regional inference ids such as `us.anthropic.claude-fable-5`.
Apus applies Fable's 1M context window, 128K output limit, always-on
adaptive thinking, and supported effort mapping. Fable 5 and 5.1 default
to `medium` effort; explicit effort settings take precedence. `/think off` and
`/think minimal` map to `low`; temperature and forced tool choice controls
are omitted, matching the Opus 4.7/4.8 route. Streaming output is held
until Bedrock returns a terminal status so mid-stream refusals do not
expose partial text.

AWS requires an explicit `provider_data_share` data-retention opt-in before
Fable is available. Prompts and completions are shared with Anthropic and
retained for up to 30 days for trust and safety. Review and configure
[Bedrock data retention](https://docs.aws.amazon.com/bedrock/latest/userguide/data-retention.html)
before enabling the model.

Claude Mythos 5 is available through Bedrock only for accounts with the
required limited-access approval. Apus recognizes the foundation model
`anthropic.claude-mythos-5` and regional or global inference profiles such
as `us.anthropic.claude-mythos-5`.

Apus applies the 1,000,000-token context window, 128,000-token output
limit, image input, prompt caching, refusal-safe streaming, and native
effort levels. Adaptive thinking is always enabled: `/think off` and
`/think minimal` map to `low`, while `xhigh` and `max` remain available.
Custom sampling and forced tool choice values are omitted.

AWS documents Sonnet 5 for both the
[`bedrock-runtime` and `bedrock-mantle` endpoints](https://docs.aws.amazon.com/bedrock/latest/userguide/model-card-anthropic-claude-sonnet-5.html).
Apus recognizes the Bedrock foundation model
`anthropic.claude-sonnet-5` and regional or global inference profiles such
as `us.anthropic.claude-sonnet-5`. It applies the 1,000,000-token context
window, 128,000-token output limit, image input, native effort levels,
prompt caching, and refusal-safe streaming.

Bedrock keeps adaptive thinking enabled for Sonnet 5. Apus defaults to
`high`; `/think off` and `/think minimal` map to `low` because this route
cannot disable thinking. Custom temperature and forced tool choice values
are omitted while adaptive thinking is active.

You can apply [Amazon Bedrock Guardrails](https://docs.aws.amazon.com/bedrock/latest/userguide/guardrails.html)
to all Bedrock model invocations by adding a `guardrail` object to the
`amazon-bedrock` plugin config. Guardrails let you enforce content filtering,
topic denial, word filters, sensitive information filters, and contextual
grounding checks.

```json5
{
  plugins: {
    entries: {
      "amazon-bedrock": {
        config: {
          guardrail: {
            guardrailIdentifier: "abc123", // guardrail ID or full ARN
            guardrailVersion: "1", // version number or "DRAFT"
            streamProcessingMode: "sync", // optional: "sync" or "async"
            trace: "enabled", // optional: "enabled", "disabled", or "enabled_full"
          },
        },
      },
    },
  },
}
```

`guardrailIdentifier` and `guardrailVersion` are required.

| Option | Description |
| ------ | ----------- |
| `guardrailIdentifier` | Guardrail ID (e.g. `abc123`) or full ARN (e.g. `arn:aws:bedrock:us-east-1:123456789012:guardrail/abc123`). |
| `guardrailVersion` | Published version number, or `"DRAFT"` for the working draft. |
| `streamProcessingMode` | `"sync"` or `"async"` for guardrail evaluation during streaming. If omitted, Bedrock uses its default. |
| `trace` | `"enabled"` or `"enabled_full"` for debugging; omit or set `"disabled"` for production. |

The IAM principal used by the gateway must have the `bedrock:ApplyGuardrail` permission in addition to the standard invoke permissions.

Bedrock can also serve as the embedding provider for
[memory search](/concepts/memory-search). This is configured separately from the
inference provider -- set `memory.search.provider` to `"bedrock"`:

```json5
{
  memory: {
    search: {
      provider: "bedrock",
      model: "amazon.titan-embed-text-v2:0", // default
    },
  },
}
```

Bedrock embeddings use the same AWS SDK credential chain as inference (instance
roles, SSO, access keys, shared config, and web identity). No API key is
needed.

Supported embedding models include Amazon Titan Embed (v1, v2), Amazon Nova
Embed, Cohere Embed (v3, v4), and TwelveLabs Marengo. See
[Memory configuration reference -- Bedrock](/reference/memory-config#bedrock-embedding-config)
for the full model list and dimension options.

- Bedrock requires **model access** enabled in your AWS account/region.
- Automatic discovery needs the `bedrock:ListFoundationModels` and
  `bedrock:ListInferenceProfiles` permissions.
- If you rely on auto mode, set one of the supported AWS auth env markers on the
  gateway host. If you prefer IMDS/shared-config auth without env markers, set
  `plugins.entries.amazon-bedrock.config.discovery.enabled: true`.
- Apus surfaces the credential source in this order: `AWS_BEARER_TOKEN_BEDROCK`,
  then `AWS_ACCESS_KEY_ID` + `AWS_SECRET_ACCESS_KEY`, then `AWS_PROFILE`, then the
  default AWS SDK chain.
- Reasoning support depends on the model; check the Bedrock model card for
  current capabilities.
- If you prefer a managed key flow, you can also place an OpenAI-compatible
  proxy in front of Bedrock and configure it as an OpenAI provider instead.