Agentic Data Plane

Set Up Budgets

Set budgets to cap LLM spend on an LLM provider, for one agent, for one person or service account, or for a team’s tagged agents. Cost reporting shows what you spent, and a budget enforces a limit. When spend reaches a budget’s limit, the AI Gateway rejects the LLM requests that budget covers until the period resets or you raise the limit.

After completing these steps, you will be able to:

  • Set a budget that caps LLM spend for an LLM provider, an agent, a person or service account, or a group of tagged agents

  • Identify what spending data the Agentic Data Plane records automatically

  • View spend breakdowns by agent, model, and provider

Set a budget

A budget caps LLM spend over a recurring period. When the spend a budget covers reaches its hard limit, AI Gateway rejects the next LLM request it covers. Requests pass again when the period resets. A separate warning threshold fires before the cap, so you can react before AI Gateway starts rejecting requests.

You manage budgets on the Budgets page. Each budget covers one scope:

  • Provider total: One limit for all calls to an LLM provider.

  • Per-principal limit: A limit on an LLM provider that each caller gets separately, so every agent and every person or service account calling it has its own pool. An override gives one agent, person, or service account a different amount. See [principals].

  • Agent budget: A limit on one agent’s calls on every provider.

  • Person or service account budget: A limit on one person’s or service account’s own direct calls on every provider.

  • Tag budget: One shared limit for the agents that carry a matching tag. See Tag budgets and provider totals.

A budget identifies an agent by its resource name in the form agents/<slug>, the same identity that appears as agent_name in spend data. It identifies a person or service account by email address.

Each call is charged to one principal. A call that an agent makes is charged to the agent, including a call the agent makes on a person’s behalf. Any other call, such as a person calling AI Gateway directly from Claude Code, is charged to the caller’s email address. On a provider with a per-principal limit, AI Gateway refuses a call that comes from neither an agent nor an identifiable user, with HTTP 403 and the error type budget_principal_required.

If AI Gateway can’t read the budgets or the current spend, it lets the request through. AI Gateway reads the budgets on each request it enforces, so a budget you create, change, or delete applies from the next request it checks.

A capped request gets HTTP 429 with an error body in the provider’s own rate-limit format, so client SDKs handle it like any other rate limit. The message names the budget, the spend against the cap, and when the period resets. For OpenAI-format providers, the error also carries the code budget_exceeded. Anthropic returns rate_limit_error, Google returns RESOURCE_EXHAUSTED, and Amazon Bedrock returns ThrottlingException.

Choose a budget type

Pick the budget that matches what you want to control:

  • Limit how much any one agent or person can spend on a provider: Set a per-principal limit on that LLM provider. Every agent and every person or service account that calls it gets the same limit, and each one’s spend counts only against its own. A per-principal limit doesn’t cap the total. A $100 monthly per-principal limit with 10 callers allows up to $1,000 a month. To cap the total, also set a provider total.

  • Give one agent, person, or service account more or less room on a provider: Add an override to the provider’s per-principal limit. It replaces the per-principal limit for that caller only.

  • Cap one agent across every provider: Create an agent budget.

  • Cap one person’s or service account’s direct calls across every provider: Create a person or service account budget.

  • Give a team one budget for all its agents: Tag the team’s agents, for example team=platform, and create a tag budget for that tag. All the team’s agents draw from the same limit, and an agent you tag later joins the budget without any change to it. To give the platform team $2,000 a month and the data team $500 a month, create two tag budgets, one per tag value.

  • Cap total spend on one LLM provider: Set a provider total. It covers every call to the provider, whether it comes from an agent or a person. It can’t tell teams apart, so if two teams use the same provider, use tag budgets to separate them.

Budgets combine. A request must fit within every budget that covers it:

  • The agent budget, for a call an agent makes.

  • The provider’s per-principal limit, or the caller’s override of it.

  • The person or service account budget, for a direct call.

  • The provider total.

  • Every tag budget that matches.

For example, take a $50 monthly per-principal limit on a provider and a $2,000 monthly budget for team=platform. On that provider, each platform agent stops at $50, and all platform agents together stop at $2,000. The first limit the spend reaches applies.

An agent without a matching tag isn’t covered by any tag budget. To make sure every agent and every person has a limit on a provider, set a per-principal limit on it.

How a budget works

Setting What it does

Limit

The hard cap on per-period spend, in dollars. When the spend the budget covers reaches this value for the period, the next LLM request it covers gets HTTP 429. Spend resets to zero at the start of each period.

Warning threshold

A spend level, lower than the limit, at which Agentic Data Plane warns: gateway responses carry a SpendLimit-Warning header and Agentic Data Plane records a warning metric. Requests still pass. Must be greater than zero and less than the limit.

Period

How often the spend pool resets: daily, weekly, or monthly. Periods are calendar-aligned in UTC: daily at 00:00 UTC, weekly at 00:00 UTC Monday, monthly at 00:00 UTC on the first of the month.

Scope

Which spend the budget covers: an LLM provider, an agent, a person or service account, or a tag. You can’t change a budget’s scope after you create it. To cover a different scope, create a new budget and delete the old one.

A new budget counts spend from the start of the hour you create it in. Spend earlier in the period doesn’t count against its limit. The exception is an override of a per-principal limit. It counts the caller’s spend from the start of the current period, so the spend the caller already made this period keeps counting, and a caller can’t get a fresh limit partway through a period.

Each scope can have only one budget of a kind. An agent, person, or service account can have one budget of its own, and one override per provider. A provider can have one total and one per-principal limit.

An agent budget and an override match on the agent’s resource name, so recreating an agent with the same name keeps its budgets pointed at it. The new instance counts as a continuation for budget purposes.

Default budgets no longer apply

A default budget that gave every agent the same limit across every provider no longer caps anything, and you can’t create or edit one. To give every agent and every person a limit, set a per-principal limit on each LLM provider. If your environment still has a default budget, delete it after you set the replacement limits. To find its name, run rpk ai budget list --pooling-mode per-agent. Every agent budget names its agent, and the retired default is the one that doesn’t. Then run rpk ai budget delete <name>.

Tag budgets and provider totals

A tag budget or a provider total gives one shared limit to all the spend in its scope. The agents or calls it covers draw down the same amount together.

  • Agent tags: The budget covers the agents whose tags match. For each tag key you name, an agent matches when its value for that key is one of the values you list. When you name several keys, an agent must match all of them. For example, a budget scoped to team = payments or billing covers every agent tagged team=payments and every agent tagged team=billing. The UI creates a tag budget for one key and one value. To list several keys or values, use rpk ai budget or the API.

  • Provider total: The budget covers every call to the provider, including calls that don’t come from an agent.

A budget takes agent tags or providers, not both. A tag budget never counts a call that doesn’t come from an agent, because that call carries no agent tags.

A tag budget counts spend by the tags an agent carried when it made each call, the same tags that cost reporting records. Retagging an agent doesn’t move the spend it already made into or out of a budget.

Set a budget in the UI

Open Budgets in the sidebar. A budget labeled Blocking is rejecting requests, and one labeled Warning has passed its warning threshold. To get the matching rpk ai budget commands for anything on the page, click Use with rpk ai. See Get a resource’s commands from the UI.

To create a budget:

  1. Click Create budget.

  2. Under What to limit, select LLM provider, Agent, Person, Service account, or Tag.

  3. Select the provider, agent, person, or service account. For a tag budget, select a tag key and a tag value.

  4. Set the limit:

    • For an LLM provider, under Apply limit as, select Total for all calls, Per-principal limit, or both. Enter an amount for each one you select, then select Day, Week, or Month. Both use the same period. To give one agent, person, or service account a different per-principal amount, click Add override, then select the caller and enter its amount.

    • For any other budget, enter a dollar amount and select Day, Week, or Month.

  5. Under Warning, set the warning threshold as a percentage of the limit (80 by default). Pick a threshold that leaves you time to react before requests start failing.

  6. Under Preview, confirm what the budget covers. For a per-principal limit, the preview shows how many of the provider’s top callers would already be over it. Those callers are blocked as soon as you save.

  7. Optionally, expand Advanced to set a Display name and to add tags that organize budgets and that access policies can read. These tags describe the budget itself. They don’t change which agents a tag budget covers.

  8. Click Create budget.

To check which agents a tag budget covers right now, open it and read its Agents in scope list. Use this after you retag agents, because a call counts against the budget only if the agent carried a matching tag when it made the call.

To see every budget that applies to one agent, person, or service account, and which one would block it first, click the Agents or Users tab on the Budgets page, then click the caller. An agent’s Cost and usage tab shows the same list. To change or delete a budget, open it from the Budgets page.

Read the spend projection

Where a budget’s page has a Spend projection card, use it to check whether spend is projected to reach the limit before the period resets. If it is, you can raise the limit or find what drives the spend before requests start failing.

The projection extends the average rate of the current period’s complete hours or days to the next reset, assuming usage and pricing don’t change. It doesn’t account for AI Gateway blocking requests at the limit, so treat it as an estimate.

Manage budgets through the API

BudgetService exposes standard create, read, update, and delete operations, plus two methods that resolve which budgets apply to a caller:

Method Use it to

CreateBudget

Create a budget of any scope on this page.

GetBudget, ListBudgets

Read one budget, or list budgets, each with current-period spend status. Filter ListBudgets by name, by agent, by user email, by provider, by agent tags, or by pooling mode.

UpdateBudget

Change the limit, warning threshold, or period. Send a field mask naming the fields you change.

DeleteBudget

Remove a budget. Deleting an override returns that caller to the provider’s per-principal limit.

ListEffectiveBudgets

List every budget that applies to up to 50 agents or users, and which one would block each first.

ListBudgetPrincipals

Page through agents or users with their spend over a recent window and the budgets that apply to them.

When you call CreateBudget, choose a pooling mode and a scope:

  • POOLING_MODE_PER_AGENT with filter_agent_name creates an agent budget.

  • POOLING_MODE_PER_PRINCIPAL with exactly one filter_provider_names entry creates a provider’s per-principal limit. Add filter_agent_name or filter_user_email, not both, to create an override for one agent, person, or service account.

  • POOLING_MODE_SHARED with filter_provider_names creates a provider total, and with filter_agent_tags a tag budget. Set one or the other, not both. Each entry in filter_agent_tags names one key and the values that satisfy it, so put all of a key’s values in one entry. With only filter_user_email, it creates a person or service account budget.

Check the provider names before you save a provider-scoped budget. AI Gateway accepts a name that matches no provider, and that budget then never caps anything. A provider you delete and recreate under the same name stays covered.

GetBudget and ListBudgets report the current spend of a POOLING_MODE_SHARED budget for its whole scope. The agent_name filter on ListBudgets returns that agent’s own budget and its overrides, not the per-principal limits, provider totals, or tag budgets that also cover it. To see every budget that applies to an agent or user, call ListEffectiveBudgets.

A service account needs the matching dataplane_adp_budget_* permission for each operation (create, get, list, update, or delete). See Budget permissions.

A budget scoped to an LLM provider is visible only to callers who can list that provider. If you can’t list a provider that a budget names, ListBudgets, ListEffectiveBudgets, and the Budgets page leave the budget out. GetBudget, UpdateBudget, and DeleteBudget return not found for it. The budget still caps the provider’s spend for everyone it covers.

You can manage the same budgets with the rpk ai budget commands. Enter amounts in dollars with --limit-usd and --warn-at-usd instead of converting to microcents yourself. Agentic Data Plane stores budget amounts in US dollar (USD) microcents (1 cent = 1,000,000 microcents). To check a change before it reaches the server, add --dry-run, which prints the request and exits.

For example, to set a provider total, a tag budget, a per-principal limit, and an override of it for one person:

rpk ai budget create openai-monthly --pooling-mode shared \
  --filter-provider-names openai \
  --period monthly --limit-usd 100 --warn-at-usd 80
rpk ai budget create team-monthly --pooling-mode shared \
  --filter-agent-tags '{"key":"team","values":["payments","billing"]}' \
  --period monthly --limit-usd 100 --warn-at-usd 80
rpk ai budget create anthropic-daily --pooling-mode per-principal \
  --filter-provider-names anthropic \
  --period daily --limit-usd 50 --warn-at-usd 40
rpk ai budget create anthropic-alice --pooling-mode per-principal \
  --filter-provider-names anthropic --filter-user-email alice@example.com \
  --period daily --limit-usd 100 --warn-at-usd 80

What Agentic Data Plane records automatically

Every LLM call routed through AI Gateway becomes a spending event. Each event captures:

  • Input tokens, output tokens, and cached tokens.

  • Total cost (in microcents).

  • Request count.

  • The provider, model, user, and organization context the call ran under.

No setup required: the gateway captures spending the moment your first agent runs through it.

Agentic Data Plane reports cost in microcents. 1 cent = 1,000,000 microcents, so $1 = 100,000,000 microcents. Divide the total cost in microcents by 100,000,000 to convert to dollars.

Per-request pricing variations

A few request- or response-time signals change the rate Agentic Data Plane applies to a single call. You don’t configure these; the spending pipeline picks them up from the upstream response or request and bills accordingly.

  • Anthropic fast mode: A fast-mode call costs more per token on the models that offer it. Agentic Data Plane bills it at the fast-mode rate.

  • Context-tier pricing: Some models charge more once a request’s context passes a threshold, such as Gemini Pro above 128K tokens. Agentic Data Plane bills those requests at the higher rate.

  • OpenAI service tier: Agentic Data Plane bills each call at the rate of the tier OpenAI reports it served. That tier isn’t always the one the request asked for, so a discount or a premium can show up in your spend. The spending event records it as service_tier, for example default, flex, or priority. A call with no reported tier bills at the standard rate.

Where to view your spend

The Budgets page shows each budget’s usage against its cap. For spend analysis, use these surfaces:

Surface Use it for

Cost and usage page (in the sidebar)

Spend, requests, and tokens for a time window against the period before it; a breakdown of spend by agent, model, provider, user, or tag; and a chart of any one of them against the gateway total, with CSV export. See Analyze Cost and Usage.

Breakdown queries

Aggregated spend by provider, model, user, agent, or provider type, available through GetSpendingBreakdown for programmatic access.

Agents list

Comparing agents' 30-day spend and budget usage side by side. See Read the columns.

Query spend programmatically

To pull spend into a script, a scheduled report, or a chargeback workflow, use the rpk ai spending commands. They take the same time range, filters, and breakdown dimensions described in this section as flags. For example, to break down one week of spend on a provider by user:

rpk ai spending breakdown --dimension user \
  --filter.start-time 2026-05-17T00:00:00Z \
  --filter.end-time 2026-05-24T00:00:00Z \
  --filter.provider-name prod-anthropic

Use rpk ai spending summary for totals over a time range and rpk ai spending time-series for spend over time. To list the tag keys you can break spend down by, use rpk ai spending tag-keys.

SpendingService.GetSpendingBreakdown is the canonical RPC for pulling spend out of Agentic Data Plane. Use it for chargeback reporting, scheduled emails, internal cost dashboards, or any workflow the built-in UI doesn’t cover.

Authenticate

SpendingService uses the same OIDC client-credentials grant as the rest of AI Gateway. Mint a service-account access token using the flow in Authenticate with OIDC client credentials, then pass the token in the Authorization: Bearer <token> header on every call. The service account needs dataplane_adp_spending_get, which grants read access to all spend in the tenant. See Spending permissions.

Request shape

GetSpendingBreakdown takes a SpendingFilter plus a dimension. The filter accepts:

Field Meaning

start_time, end_time

RFC 3339 timestamps bracketing the window. Required.

provider_name

Restrict to one LLM provider (matches the Name field on the provider’s detail page).

model_id

Restrict to one model identifier (claude-sonnet-4-6, gpt-5.2, and so on). The value resolves to the model’s whole family, so its aliases and its dated versions all match: gpt-4o covers gpt-4o-2024-08-06, and gpt-4o-2024-08-06 returns the same total. A name that differs by more than a trailing date stays separate, so gpt-4o-mini is its own model, as is each regional version of a model served through Amazon Bedrock. A model identifier that no provider catalog lists matches exactly.

user_email

Restrict to one identified user, matched on the caller’s email. Agentic Data Plane records the email from the caller’s authenticated identity, so you don’t set it up. The filter leaves out anonymous traffic.

agent_name

Restrict to one agent by its resource name (agents/<slug>), recorded on every call made by or on behalf of an agent. Leave it empty to match every row, including direct user calls; set it to scope spend to a single agent, summed across every instance that has used the name.

agent_uid

Restrict to one agent instance, identified by the immutable UUID minted at agent creation. Valid on its own; combine it with agent_name only as a label convenience (the two conditions are ANDed). Use it to exclude spend from a previously deleted agent that reused the same name.

organization_id

Restrict to one organization. Multi-tenant deployments only.

filter

AIP-160 expression that combines and negates dimensions in a single string (for example, provider_name="anthropic" AND model_id!="claude-sonnet-4-6"). Composes with the structured fields in this table; populate one or both. An equality or inequality test on model_id resolves the model family the same way the model_id field does, so the inequality in that example excludes every dated version of the model. Ordering and substring comparisons test the stored identifier instead.

The dimension value chooses the breakdown dimension. Valid values are the BreakdownDimension enum: BREAKDOWN_DIMENSION_PROVIDER, BREAKDOWN_DIMENSION_MODEL, BREAKDOWN_DIMENSION_USER, BREAKDOWN_DIMENSION_AGENT, BREAKDOWN_DIMENSION_PROVIDER_TYPE, BREAKDOWN_DIMENSION_TAG, and BREAKDOWN_DIMENSION_AGENT_UID.

A breakdown on BREAKDOWN_DIMENSION_AGENT keys on the agent’s resource name (agents/<slug>) and excludes rows with no agent (direct user calls), the same way the other dimensions skip empty keys. Spend is summed across every instance that has used the name, so an agent that was deleted and recreated appears as a single entry. For history reads, use BREAKDOWN_DIMENSION_AGENT_UID: the name-keyed breakdown silently merges unrelated agents that reused the same name, so BREAKDOWN_DIMENSION_AGENT is deprecated for that use (it is still accepted, and its behavior is unchanged).

BREAKDOWN_DIMENSION_AGENT_UID keys on the agent’s immutable UUID instead, so each incarnation of a reused name appears as its own entry, with the agent’s name returned alongside as a label. Rows with no agent are excluded.

BREAKDOWN_DIMENSION_TAG groups spend by the value of a tag you set on your agents (for example, department) and takes an extra tag_key field. Spend rows without the tag collapse into a single empty-string key. Use it to attribute cost to a department, team, or environment. See Track Spend by Tag.

To discover which cost-allocation tag keys exist before breaking down by one, call GetSpendingTagKeys with a start and end time. It returns the distinct tag keys observed on spend within that window, sorted ascending, and returns an empty list when no tagged spend exists in the range.

cURL example

Pull per-user spend for the last 7 days against an Anthropic provider:

ACCESS_TOKEN="<oidc-access-token>"   # from the client_credentials flow
DATAPLANE_BASE="https://aigw.<cluster-id>.clusters.rdpa.co"

curl -s --request POST \
  --url "${DATAPLANE_BASE}/redpanda.api.adp.v1alpha1.SpendingService/GetSpendingBreakdown" \
  --header "Authorization: Bearer ${ACCESS_TOKEN}" \
  --header 'Content-Type: application/json' \
  --data '{
    "filter": {
      "start_time": "2026-05-17T00:00:00Z",
      "end_time":   "2026-05-24T00:00:00Z",
      "provider_name": "prod-anthropic"
    },
    "dimension": "BREAKDOWN_DIMENSION_USER"
  }' | jq

The response carries one entries row per user in the window. Each entry has a key (the user) and a stats object with totalCostMicrocents, totalRequests, totalTokens, and per-bucket input, output, and cached usage. Fields whose value is zero are left out of the response. Divide totalCostMicrocents by 100,000,000 to convert to dollars.

Python example

Generated client code lives in the proto bundle. If your project doesn’t already import those generated clients, drive SpendingService over plain HTTPS:

import os, requests
from datetime import datetime, timedelta, timezone

token = os.environ["ACCESS_TOKEN"]            # from the client_credentials flow
base  = os.environ["DATAPLANE_BASE"]          # https://aigw.<cluster-id>.clusters.rdpa.co
end   = datetime.now(timezone.utc)
start = end - timedelta(days=7)

body = {
    "filter": {
        "start_time": start.isoformat().replace("+00:00", "Z"),
        "end_time":   end.isoformat().replace("+00:00", "Z"),
        "filter": 'provider_name="prod-anthropic"',
    },
    "dimension": "BREAKDOWN_DIMENSION_USER",
}

r = requests.post(
    f"{base}/redpanda.api.adp.v1alpha1.SpendingService/GetSpendingBreakdown",
    headers={"Authorization": f"Bearer {token}", "Content-Type": "application/json"},
    json=body,
)
r.raise_for_status()
for entry in r.json().get("entries", []):
    stats = entry["stats"]
    dollars = int(stats.get("totalCostMicrocents", 0)) / 100_000_000
    print(f"{entry['key']}: ${dollars:,.2f}  ({stats.get('totalRequests', 0)} requests)")

The proto-generated client (Connect-Go or grpc-python) is the long-term recommendation; the cURL and requests examples are for quick scripting.

SpendingService exposes additional methods that follow the same SpendingFilter shape:

  • GetSpendingSummary: Total spend, tokens, and requests for the range, with no breakdown. Also returns the previous comparable period so you can show a trend.

  • GetSpendingTimeSeries: Spend bucketed over the time range (hourly or daily), for chart-style consumers.

  • GetSpendingTimeSeriesByDimension: Time-series buckets split by a breakdown dimension (top-N keys by cost), for stacked charts. Reports truncated_key_count when more keys matched than were returned.

Guardrail cost

Guardrail evaluation is not counted against budgets and does not appear in Agentic Data Plane cost reporting. When a guardrail delegates a policy to Amazon Bedrock, AWS bills that evaluation directly to the AWS account whose credentials the guardrail uses. For current rates, see Amazon Bedrock pricing.

For what each policy does, see How guardrails work and Guardrail policy reference.

Override per-model pricing

The Agentic Data Plane ships with default per-model pricing per provider, covering input, output, and cache-read prices for every model in the built-in catalog. Cost reporting uses these prices when it computes per-call spend, which is why every dollar value on the Cost and usage page and in SpendingService queries works without any setup.

If your organization negotiates non-standard pricing, or you want to track spend against an internal chargeback rate, override the rates as part of configuring an LLM provider. Overrides are scoped to a single provider, where you edit the rate per model. See Override per-model pricing.

Calls covered by a subscription

When an LLM provider has authorization passthrough turned on, each client authenticates to the upstream with its own credentials, so the upstream bills that client’s own account. For an Anthropic provider that points at api.anthropic.com, and for an OpenAI or OpenAI-compatible provider that points at chatgpt.com, Agentic Data Plane reads the plan state the vendor reports on each response and prices the call from it:

  • When the vendor reports that the caller’s own subscription plan covered the call, Agentic Data Plane records the call at $0. It still counts the request and its tokens, and the call adds nothing to the spend a budget counts against its limit.

  • When the call ran past the plan, on Anthropic extra usage or Codex credits, Agentic Data Plane prices it from the provider’s per-model pricing, the same way it prices an API-key call.

  • When Agentic Data Plane can’t establish the plan state, it prices the call from the provider’s per-model pricing. That covers a response that reports no plan state, and any provider that points at another host, such as a proxy or an aggregator, because another upstream can report the same plan state.

Every other provider type prices all calls from the provider’s per-model pricing. To turn authorization passthrough on, see Configure an LLM provider.

Check your understanding

Answer each question, then expand it to compare.

An LLM provider has a $100 monthly per-principal limit, and two agents call it. Do they share the $100?

No. A per-principal limit gives every agent and every person or service account its own independent pool of the limit per period. One agent reaching its cap doesn’t affect another. To give a group of agents one limit they share, create a tag budget for their tag.

An LLM provider has a $50 monthly per-principal limit, and a tag budget gives the platform team’s tagged agents $2,000 a month. When does AI Gateway reject a platform agent’s next request to that provider?

When the agent reaches its own $50 on that provider, or when all agents tagged team=platform together reach $2,000, whichever comes first.

A person calls AI Gateway directly, not through an agent. Which budgets can cap the call?

The provider total, the provider’s per-principal limit or the person’s override of it, and the person’s own budget. Agent budgets and tag budgets count only calls that agents make.

An LLM provider has a per-principal limit, and a call to it comes from neither an agent nor an identifiable user. What happens?

AI Gateway refuses the call with HTTP 403 and the error type budget_principal_required, because it has no principal to charge the call to. Send the call as an agent, or authenticate as a person or service account.

An agent reaches its cap partway through the month. What does its next LLM request get, and when does the agent recover?

The gateway rejects the request with HTTP 429. Requests pass again when the period resets, which for a monthly budget is 00:00 UTC on the first of the month.

On the 20th of the month you add an override to a provider’s per-principal limit for an agent that has already spent $60 on that provider. Does its usage reset?

No. An override counts the caller’s spend from the start of the current period, so the $60 already accrued counts toward the override’s cap.

An agent’s spend crosses its warning threshold. Does anything stop?

No. Requests still pass. Gateway responses carry a SpendLimit-Warning header and Agentic Data Plane records a warning metric. Only reaching the hard limit blocks the agent’s next LLM request.

Do guardrail evaluations count against an agent’s budget?

No. Guardrail evaluation isn’t counted against budgets and doesn’t appear in Agentic Data Plane cost reporting. When a guardrail delegates a policy to Amazon Bedrock, AWS bills that evaluation to the AWS account whose credentials the guardrail uses.