---
title: How do you tag Amazon Bedrock costs by agent with application inference profiles?
url: https://opencontroller.lyzr.com/blog/tag-amazon-bedrock-costs-by-agent
published: 2026-11-13
updated: 2026-11-13
author: Lyzr
---

# How do you tag Amazon Bedrock costs by agent with application inference profiles?

**Create one application inference profile per agent (or team), attach cost allocation tags, activate those tags in AWS Billing, and have the agent call Bedrock with the profile ARN instead of the model ID. Cost Explorer and the Cost and Usage Report can then group spend by agent. If any call still uses the plain model ID, that spend lands untagged.**

Bedrock bills by model and usage type, not by caller. Without extra work, ten agents sharing one account show up as one line per model. Application inference profiles are the long-standing way to split that bill. AWS has since added two more options, which we compare below.

## How do application inference profiles work?

An application inference profile is a resource you create that points at one model, either directly or through a system-defined cross-Region profile. You tag the profile. Every request that names the profile's ARN as `modelId` carries those tags into billing.

The setup:

1. **Create the profile.** Use `CreateInferenceProfile` with a `modelSource` that copies from the model or system inference profile ARN, and add tags such as `agent=claims-triage`, `team=ops`, `costcentre=4410`.
2. **Activate the tags.** In Billing and Cost Management, open **Cost allocation tags**, select your tag keys and choose **Activate**.
3. **Switch the agent's calls.** Pass the profile ARN as `modelId` in `InvokeModel` or `Converse`.
4. **Wait.** Tags take up to 24 hours to appear in Cost Explorer and CUR.
5. **Report.** Group by the tag in Cost Explorer, or query CUR 2.0 line items.

```python
client.converse(
    modelId="arn:aws:bedrock:us-east-1:123456789012:application-inference-profile/abc123",
    messages=[{"role": "user", "content": [{"text": "Summarise this claim"}]}],
)
```

## What is the catch?

The tags apply only to calls that use the profile ARN. That one rule causes most of the gaps teams find:

- **Hard-coded model IDs.** A framework default or an old config file still names the base model. That spend is untagged.
- **Unsupported APIs.** AWS documents that the Responses and Chat Completions APIs return HTTP 400 when they name an application inference profile.
- **No back-fill.** Activation is not retroactive. Costs before activation stay untagged.
- **Profile sprawl.** Each profile is tied to one model. Five agents across three models and two environments can mean 30 profiles, and a new model version needs new profiles.
- **Daily grain.** Costs are billed dollars per usage type per day. There is no per-request cost.

Two controls close most of these gaps. First, use an IAM policy or service control policy that allows invocation only on inference profile ARNs, so a hard-coded model ID fails loudly. Our guide to [restricting Bedrock models with SCPs](/blog/restrict-amazon-bedrock-models-with-scps) shows the pattern. Second, compare tagged Bedrock spend against total Bedrock spend weekly; the difference is your untagged leak.

## What are the alternatives in 2026?

| Method | Best for | Works with | Limit |
|---|---|---|---|
| Application inference profiles | Per-agent tags on InvokeModel and Converse | bedrock-runtime | One profile per model per tag set; must use the ARN |
| Amazon Bedrock Projects | Responses and Chat Completions workloads | bedrock-mantle endpoint | Daily grain; no per-request metadata tagging |
| IAM principal cost allocation (since April 2026) | Agents that already run as distinct IAM roles | Any Bedrock inference | Needs one role per agent; tags on roles must be activated |
| Invocation logs | Per-request token detail | Model invocation logging | Tokens, not billed dollars; you price them yourself |

**Projects** take a project ID at client set-up (for example the `OpenAI-Project` header on the OpenAI-compatible endpoint), and one project can span many models. **IAM principal allocation** needs no extra resources: tag each agent's role, activate the tags, and enable "Include caller identity (IAM principal) allocation data" in a CUR 2.0 export for line-item detail.

For most estates the practical answer is a mix: one IAM role per agent as the baseline, profiles or Projects where you need tags by model, and invocation logs for per-task cost. Our guide to [measuring cost per task](/blog/measure-cost-per-task-for-ai-agents) shows the arithmetic.

## What should the tag schema be?

Keep it small and consistent across clouds:

1. `agent` — the registry ID, not a display name.
2. `agent_version` — so you can compare cost before and after a change.
3. `team` or `costcentre` — for chargeback or showback.
4. `env` — prod, staging, dev.

Avoid per-user tags on profiles; AWS notes team or cost-centre tagging reduces profile sprawl.

## How Opencontroller does this

Opencontroller's LLM Gateway (Lyzr Gateway) attributes cost per agent and per version for traffic routed through it, with routing, fallback and retry, and caching. Discovery finds agents, models and API keys across AWS, Azure and Google Cloud, so untagged callers show up in the registry rather than as anonymous spend. In an October 2026 benchmark on mixed synthetic traffic, caching cut model cost by 23.5% under the stated test conditions; see the [gateway benchmark](/llm-gateway-benchmark). Read the [cost attribution guide](/blog/how-to-attribute-llm-costs-to-ai-agents), the [cross-platform pillar](/blog/how-to-govern-ai-agents-across-platforms), or [book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Can I tag spend on a system-defined cross-Region profile?**
Not directly. Create an application inference profile that copies from the system profile, tag it, and call the new ARN.

**Why does Cost Explorer show nothing for my new tag?**
Check that the tag is activated, that calls use the profile ARN, and that 24 hours have passed. Costs before activation stay untagged.

**Do I need profiles if every agent has its own IAM role?**
Not always. IAM principal cost allocation can split spend by role. Profiles still help when you also need tags per model or per environment.

## Key facts

Amazon Bedrock application inference profiles let you tag model spend: create a profile per agent or team (CreateInferenceProfile, copying from a model or system-defined inference profile), attach cost allocation tags, activate them in AWS Billing, then call InvokeModel or Converse with the profile ARN as modelId. Tags take up to 24 hours to appear in Cost Explorer and CUR and are not retroactive. Profiles are model-specific and report billed dollars per usage type per day, not per request. Responses and Chat Completions APIs reject application inference profiles with HTTP 400; on the bedrock-mantle endpoint use Amazon Bedrock Projects instead. Since 9 April 2026 Bedrock also supports cost allocation by IAM principal tags. Opencontroller by Lyzr attributes cost per agent and per version through its LLM Gateway. Pricing starts from $250K per deployment per year.

## Related

- [How do you attribute LLM costs to individual AI agents?](https://opencontroller.lyzr.com/blog/how-to-attribute-llm-costs-to-ai-agents.md)
- [How do you track Claude spend across Amazon Bedrock, Claude Platform on AWS and the Anthropic API?](https://opencontroller.lyzr.com/blog/track-claude-spend-bedrock-vs-anthropic-api.md)
- [How do you restrict which Amazon Bedrock models agents can use?](https://opencontroller.lyzr.com/blog/restrict-amazon-bedrock-models-with-scps.md)
- [More on Platform Guides](https://opencontroller.lyzr.com/blog/cluster/platform-guides)
