# Do Bedrock and Azure AI calls burn your cloud commit?

URL: https://infro.io/blog/do-bedrock-and-azure-ai-calls-burn-your-cloud-commit
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: Cost and FinOps
Format: Analysis

> A call burns a cloud commit only if the cloud provider invoices it and the contract counts that line as eligible. Azure documents the rules for MACC [^azure-macc-benefit]; for AWS, get eligibility in writing. Compare paths by marginal cost, not list rate, and steer toward committed spend with static priority or weights that finance reviews against the forecast.

Key takeaways:
- A call counts toward a commit only when the cloud provider invoices it and the contract treats that line as eligible, so the same model can burn commit on one path and not on another.
- Microsoft documents that Azure services billed to you and Azure-benefit-eligible partner offers bought through the Azure portal count toward MACC; confirm each Foundry model's billing path before assuming it does.
- While you are forecast to miss a commit, the marginal cost of committed-path tokens is close to zero; once you are forecast to exceed it, the marginal cost is that path's rate.
- Failover to a direct provider crosses a price gap and may stop burning commit, so order targets deliberately and watch fallback share.
- Track burn on the cloud provider's own invoiced figure; a gateway estimate is a planning number.

## The question is who invoices the call

A commitment is a contract with a cloud provider to spend an amount over a term. A model call burns it only if two things hold: the cloud provider puts the charge on your invoice, and your contract counts that line as eligible. The model's name does not decide either. The same model can be a committed-spend line through one path and an unrelated invoice through another.

If you also pay providers directly on your own keys, you have at least two paths to the same model family. One lands on the cloud invoice. The other lands on the provider's invoice. Finance needs to know, per path, whether tokens retire commit, what they cost at the margin, and what happens when traffic spills from one to the other.

This piece separates what the vendors document from what you have to confirm in your own agreement. It then shows a way to compare paths and a way to route toward committed spend without breaking budgets or negotiated rates.

## What Microsoft documents for Azure

A Microsoft Azure Consumption Commitment (MACC) is a contractual agreement to spend a set amount on Azure over a defined period.[1] Three statements in Microsoft's documentation matter for AI spend:

- Azure services, as defined in the Microsoft Product Terms and billed to you through a Microsoft storefront deployment, contribute toward the commitment.[1]
- Eligible partner offers from the storefront count at 100% of the pretax purchase amount, and you identify them by the "Azure benefit eligible" badge.[1]
- To count, the purchase must be completed through the storefront inside the Azure portal on a subscription tied to your agreement; a card purchase made directly on the storefront website does not contribute.[1]

Now map that onto Foundry. Models sold by Azure are hosted and operated by Azure, billed through your Azure subscription, and covered by Azure service-level agreements.[2] That list includes all Azure OpenAI models plus selected models from other providers. Models from partners and community are different: they are Non-Microsoft Products under the Product Terms, and the model provider sets the price through the Azure partner storefront.[3] Claude in Foundry comes in two versions, hosted on Azure and hosted on Anthropic infrastructure, and not every model is available in both.[3]

What the pages do not say is which of those lines are MACC-eligible for your agreement. The badge and the portal checkout rule are the documented tests. Treat "Azure OpenAI counts" as likely and "partner model counts" as unverified until you see the badge or get it in writing. Also note that Azure-side tracking is only available to direct Microsoft Customer Agreement and direct Enterprise Agreement customers; an agreement signed through a partner does not get the portal view.[4]

## What to confirm for AWS

I could not read a primary AWS page that states which Bedrock charges count toward an AWS commitment, so none is asserted here. What the Bedrock pages do establish is the billing shape: on-demand Standard, Flex and Priority tiers, plus a Reserved tier where you reserve capacity for one or three months at a fixed price per 1K tokens-per-minute, billed monthly.[5] Batch inference on select models is priced 50% lower than on-demand.[6]

Ask your AWS account team to answer, in writing, for each line:

- Does on-demand Bedrock usage count toward the commitment, for first-party and third-party models alike?
- Does the Reserved tier count, and from the invoice date or the reservation date?
- Does a model bought through a partner listing count, and at what percentage?
- Do Flex, Priority and Batch lines count at billed amounts?

Put the answers in the same table you keep for Azure. An unanswered cell should be treated as "does not count" in forecasts.

## Comparing the effective cost of each path

List rate is the wrong number for this comparison. The useful number is the marginal cost of the next million tokens on each path, and it changes with where you are against the commit.

Three cases:

1. **Forecast to miss the commit.** Azure applies a shortfall charge for the remaining balance if the MACC or a milestone is missed at its end date.[4] You pay that money either way, so tokens on the committed path have a marginal cost near zero until the forecast closes.
2. **Forecast to land on the commit.** The committed path costs its negotiated rate at the margin, and the commit stops being a reason to prefer it.
3. **Forecast to exceed the commit.** Spend above it is billed at the same rates but earns nothing; the decision reverts to a plain rate comparison against the direct path.

There is one trap. Consumption charges covered by a shortfall payment do not accrue toward the MACC.[4] Meeting a commit with a shortfall payment does not count as consumption, so you cannot count the shortfall as a path.

> **Example: Illustrative figures, not real rates**
> Assume a quarterly commit of $300,000 on a cloud account, with $180,000 consumed and a forecast to end at $255,000. The $45,000 gap is a liability. Assume the committed path bills $4.00 per million output tokens at your negotiated rate, and the direct provider bills $3.60.
> 
> While the gap is open, marginal cost per million tokens is about $0 on the committed path (the money is owed regardless) against $3.60 direct. If the forecast moves to $305,000, marginal cost on the committed path is $4.00 against $3.60, and the direct path is the lower-cost one.

In code, the rule is short:

```python
def marginal_rate(rate: float, counts_toward_commit: bool,
                  forecast_spend: float, commit: float) -> float:
    """Cost of the next unit of spend on a path, in the same currency as rate.
    Near zero only while the commit is forecast to be missed and the
    path's line is eligible. Illustrative logic, not a contract reading."""
    if counts_toward_commit and forecast_spend < commit:
        return 0.0
    return rate
```

Two cautions on this arithmetic. First, "forecast" is a straight-line guess, so the zero is soft; if a launch lifts committed-path traffic early, you can overshoot. Second, the committed path may not serve the identical model snapshot, tier or context limit as the direct one, so a rate comparison is valid only after an equivalence check. Rates also drift from list once negotiated terms apply; see [negotiated rates vs list price](https://infro.io/blog/negotiated-rates-list-price-drift) for entering the real figures.

## Routing committed spend first

Routing can express "prefer the committed path" with the controls that exist today: ordered or weighted targets over your own connections. A priority route tries enabled targets in configured order; a weighted route picks the first target by weight and then tries the others if it fails.[7] Put the cloud-billed connection first and the direct connection second, or weight them to match how much commit you still need to retire.

What this does not do is notice that the commit is used up. INFRO's commitments feature forecasts and may suggest pointing a route at the committed provider, but it never reroutes traffic on its own.[8] So the weights are a decision someone owns, reviewed against the forecast, not a self-adjusting control. Routing rules, which send requests matching metadata, project, prompt size, streaming or time of day to their own targets, let you commit specific workloads to the cloud path (batch-like background jobs are a natural fit) while latency-sensitive traffic keeps its own order.

Failover is where the price gap bites. Any upstream failure before the response starts, including a 429, moves to the next target, and a route can retry the same target up to three times first.[7] If the committed path is the one throttling, the overflow lands on the direct provider at its own rate, and that traffic no longer retires commit. Once a stream has started, it is not restarted elsewhere.[7] Watch the fallback share per day. A rising share means your committed path is not absorbing the volume you forecast. The mechanics are covered in [what failover does to your bill](https://infro.io/blog/what-does-failover-do-to-your-bill-price-gaps-and-cold-caches).

Reserved capacity changes the picture again, since a fixed monthly charge is paid whether or not tokens flow. That calculation is in [provisioned throughput vs pay-as-you-go](https://infro.io/blog/provisioned-throughput-vs-pay-as-you-go-when-reserved-capacity-pays).

## Keeping rates and budgets honest

Preferring a path must not corrupt the numbers finance reads.

- **Rates per path.** Enter the rates each contract carries, per model and per provider, so the estimated cost of a committed-path request uses the cloud rate and a direct request uses the direct rate. A single list-rate figure hides the gap the routing is meant to exploit.
- **Budgets.** Budget caps per organization, project, member and key are checked before the provider call. A cap should reflect total spend across both paths, because a committed path that has burned its commit still bills at its rate. Do not set a cap that treats committed spend as free.
- **Attribution.** Tag requests by project so a team's committed-path usage and direct-path usage can be read separately. Usage and cost per request, exported in FOCUS format, can sit in your FinOps platform beside the cloud invoice.
- **Provider routing limits.** Restrict which providers a request may use where a policy requires a model to stay on one path; the restriction narrows what a key allows and never widens it.[7]

## Tracking burn against the real figure

Burn must be measured on the number the cloud provider will hold you to. For Azure, that is the MACC balance in Cost Management or the Billing and Consumption APIs, where each event is an invoiced settlement that decrements the balance.[4] Because it moves on invoices, expect it to lag the day's traffic. Microsoft emails billing account admins at 90, 60 and 30 days before expiry if the target is not on track.[4]

INFRO's commitments feature records a committed-spend agreement by hand, measures burn on reported cost when you have a billing credential for that provider, and otherwise falls back to its own estimate with a warning. Its forecast is consumed spend plus the trailing 28-day daily mean times the days remaining.[8] The page I read names OpenAI and Anthropic as example providers, and daily reconciliation against provider cost APIs is described for those two. For a Bedrock or Azure commitment, check that the provider kind exists and expect the estimate fallback, which uses list rates unless you entered your own and can miss traffic that bypasses the gateway. Treat it as a planning figure and the cloud invoice as the record.

## A checklist before you change a route

- [ ] Eligibility of each line (on-demand, Reserved, partner offer, partner model) confirmed in writing for AWS and Azure.
- [ ] For Foundry, each model's hosting version and billing path recorded, with the "Azure benefit eligible" badge noted where it applies.
- [ ] Forecast against the commit reviewed this week, with the gap in dollars.
- [ ] Negotiated rates entered per path so estimates use them.
- [ ] Fallback share and 429 rate on the committed path watched daily.
- [ ] Budgets set on total spend across both paths.
- [ ] A named owner for re-weighting routes when the forecast crosses the commit.

INFRO connects to provider accounts you already hold and bills 0% of model spend, so the cloud and direct invoices stay with your providers; the subscription covers routes, rates, commitments tracking, budgets and exports described above. None of it reads your contract, so the eligibility table remains yours to build.

## Questions

### If a call goes through a gateway, does it still count toward my cloud commit?

Eligibility follows who invoices the call, not how it was routed. A request that reaches Bedrock or an Azure deployment on your own cloud account is billed by the cloud provider exactly as a direct call would be. A request routed to a direct provider on a BYOK key is billed by that provider and does not touch the cloud commitment unless your contract says otherwise.

### Can a gateway tell me how much commit is left?

Only from what it can read. INFRO's commitments feature measures burn on the provider's reported cost when you have a billing credential for that provider, and otherwise falls back to its own estimate with a warning [8]. For an Azure MACC, the authoritative remaining balance is in Cost Management and the Billing and Consumption APIs [4].

## Sources

1. Azure Consumption Commitment Benefit — Microsoft Learn. https://learn.microsoft.com/en-us/marketplace/azure-consumption-commitment-benefit (accessed 2026-11-10)
2. Foundry Models sold by Azure — Microsoft Learn. https://learn.microsoft.com/en-us/azure/foundry/foundry-models/concepts/models-sold-directly-by-azure (accessed 2026-11-10)
3. Foundry Models from partners and community — Microsoft Learn. https://learn.microsoft.com/en-us/azure/foundry/foundry-models/concepts/models-from-partners (accessed 2026-11-10)
4. Track your Microsoft Azure Consumption Commitment (MACC) — Microsoft Learn. https://learn.microsoft.com/en-us/azure/cost-management-billing/benefits/macc/track-consumption-commitment (accessed 2026-11-10)
5. Amazon Bedrock service tiers — Amazon Web Services. https://aws.amazon.com/bedrock/service-tiers/ (accessed 2026-11-10)
6. Amazon Bedrock pricing — Amazon Web Services. https://aws.amazon.com/bedrock/pricing/ (accessed 2026-11-10)
7. Smart routing — INFRO Docs. https://infro.io/docs/features/routing (accessed 2026-11-10)
8. Commitments — INFRO Docs. https://infro.io/docs/cost/commitments (accessed 2026-11-10)
