Microsoft AI agent run costs are becoming a new enterprise FinOps problem.

The risk is not that one agent is expensive.

The risk is that agents run.

Again and again.

That distinction matters. Most Microsoft customers are used to thinking about cost through licences, seats, true-ups, Azure budgets and renewal cycles. AI agents do not fit neatly into that pattern. They behave more like cloud workloads: event-driven, usage-sensitive, difficult to forecast without telemetry, and prone to scaling before finance has a proper unit-cost model.

This article updates Keystone's Microsoft AI agent operating cost model for the latest public Microsoft documentation available as of 23 June 2026. The base mathematics remain the same: 20 agents, 200 agents and 2,000 agents, with the same agent mix held constant. The important update is the commercial wrapper around the model:

  • Microsoft has published more detail on Copilot Credits as a usage-based billing currency for Microsoft 365 Copilot experiences.
  • The Microsoft 365 admin center now has a Cost Management experience for Copilot Credit spending policies, budgets, limits, alerts and consumption reporting.
  • Microsoft says that usage-based billing in that Microsoft 365 admin center experience currently applies to Copilot Cowork and Work IQ API, with more agents and services to be added over time.
  • Work IQ API is now a more important commercial and identity signal because it is billed through Copilot Credits and uses delegated Microsoft Entra ID authentication rather than application-only authentication.
  • Copilot Studio billing guidance now gives clearer billing rates for agent features, reasoning models, voice, overage enforcement and agent flow enforcement.
  • Copilot Credit Pre-Purchase Plan and Microsoft Agent Prepurchase Plan now need to be modelled as separate commitment routes with different scoping, precedence and invoice behaviour.
  • Hosted agents in Microsoft Foundry make some agents look more like managed Azure workloads: CPU, memory, active sessions, persistent state, Microsoft Entra agent identity, observability and right-sizing.
  • GitHub Copilot has moved to usage-based billing, reinforcing the broader Microsoft AI pattern: user entitlement plus metered consumption plus budget controls.

This is not a prediction. It is a commercial model designed to help enterprise Microsoft customers ask better questions before agent usage becomes material.

Table of contents

Executive thesis

The old Microsoft licensing question was:

What is the per-user price?

The AI agent question is:

What is the cost per successful business outcome, and what contract meter does it land on?

The public Microsoft price anchor can look tiny: $0.01 per Copilot Credit. That is the wrong place to stop. The economics are driven by the chain behind each run:

  • how often the agent runs
  • whether it is interactive or autonomous
  • whether it acts on behalf of a licensed user or as a non-human identity
  • how much grounding, orchestration, action and flow activity occurs
  • whether a reasoning model is used
  • whether tenant graph grounding, Work IQ, Foundry models, hosted agent compute, tools, storage, Search, Fabric, Logic Apps or other Azure services are invoked
  • how many retries and failures occur
  • how many exceptions require human intervention
  • whether spend is controlled through PAYG, monthly capacity packs, annual Copilot Credit commitments or ACUs
  • whether the charge affects Azure commitment, support baseline, MCA billing profile or cost centre allocation

The number of agents is useful for inventory. It is not enough for cost control.

What changed in June 2026

The base run-cost model did not need a rewrite. The modelled Copilot Studio consumption rate of $0.01 per Copilot Credit remains a valid public Microsoft anchor, and the 20/200/2,000 scenario remains a useful 10x scale case.

What changed is the commercial decision tree.

UpdateWhy it matters for the model
Microsoft usage-based billing documentation for Copilot Credits was updated on 16 June 2026.Copilot Credits are now presented as a common currency for eligible Microsoft services, not just a Copilot Studio idea. Microsoft specifically points to Copilot Cowork and Work IQ API in the Microsoft 365 admin center experience.
Microsoft 365 admin center Cost Management documentation was updated on 22 June 2026.Cost control is no longer only in Azure or Power Platform. Administrators can use spending policies, monthly limits, user limits, alerts, hard caps and consumption reporting in Microsoft 365 admin center for supported services.
Microsoft states that the Microsoft 365 admin center usage-based billing experience currently applies to Copilot Cowork and Work IQ API.This narrows the current scope, but the direction is clear: more agents and services are expected to come into the same experience over time.
Work IQ API documentation was updated on 17 June 2026.Work IQ API uses Copilot Credits and delegated Microsoft Entra ID authentication. Application-only authentication is not supported. That strengthens the distinction between OBO agents and autonomous NHI agents.
Copilot Studio billing rates now include reasoning-model treatment.Reasoning model operations use the feature rate plus premium text/generative AI tools billed per token, so token volume becomes part of the Copilot Credit calculation.
Copilot Studio overage and agent-flow enforcement are clearer.Prepaid-capacity exhaustion can disable custom agents at the 125% threshold, while agent-flow enforcement blocks new flow runs differently. Cost control is now also continuity control.
Copilot Credit P3 and Microsoft Agent Prepurchase Plan documentation was updated on 18 June 2026.One-year commitments, reservation scope, line-item invoice treatment, no cancellation/exchange and benefit precedence all affect procurement and renewal strategy.
Microsoft Build 2026 reinforced Microsoft IQ, Work IQ, Foundry IQ, hosted agents, Agent 365 and local agent governance.Microsoft's agent model is now a platform pattern across Microsoft 365, Copilot Studio, Foundry, GitHub and Windows, not a feature inside one product.
GitHub Copilot usage-based billing went live on 1 June 2026.GitHub moved from premium request units to GitHub AI Credits based on token consumption. That does not change every business-process agent model, but it reinforces the same economic pattern.

The practical conclusion: Microsoft AI agent cost is no longer only a Copilot Studio pricing conversation. It is a Microsoft AI consumption, identity, governance and contract-control conversation.

The scenario

Assume a Microsoft customer with:

  • 5,000 users
  • professional services operating model
  • all users licensed for Microsoft 365 E5
  • heavy use of Microsoft 365 workloads across Exchange, Teams, SharePoint, OneDrive and Graph-connected workflows
  • $5m per annum Enterprise Agreement spend
  • $5m per annum Azure spend
  • recurring monthly invoice and workflow volume
  • agents built across Copilot Studio, Microsoft 365-style workflows and Microsoft Foundry patterns
  • some agents acting on behalf of users
  • some agents operating as non-human identities with access to ERP and other systems of record

To make the scale easy to read, the model uses three stages:

StageAgentsMonthly runsMonthly operating costAnnual run-rate
Pilot2034,000$17,995$215,940
Scale-up200340,000$179,950$2,159,400
Industrialised2,0003,400,000$1,799,500$21,594,000

The agent mix is held constant at every scale:

  • 50% OBO agents
  • 35% workflow agents
  • 15% non-human identity ERP agents

That means the model is not hiding a change in the agent estate. It is a pure 10x scale case: 20 to 200 to 2,000 agents.

Linear run cost versus nonlinear enterprise cost

The base model is deliberately linear.

In this model, a 10x increase in agents creates a 10x increase in runs and a 10x increase in the modelled monthly operating cost. That is useful because it isolates one question:

What happens if the same type of agent estate simply scales?

The answer is already material. At 2,000 agents, the base run-rate reaches $21.6m per annum before adding several enterprise cost layers that may not scale linearly.

In practice, the real cost curve may be worse than linear.

Additional costs can appear as step costs, threshold costs or compounding overheads, including:

  • new integrations and connector patterns
  • API calls and API Management
  • Azure AI Search, vector storage and retrieval
  • Content Safety, document intelligence and grounding tools
  • reasoning-model token use
  • throttling, retry and queueing behaviour
  • additional environments and deployment pipelines
  • monitoring, tracing and Application Insights data
  • SIEM ingestion
  • model evaluation and testing runs
  • security reviews
  • data-loss prevention policies
  • agent lifecycle management
  • non-human identity governance
  • agent inventory and discovery tools
  • Agent 365 or equivalent governance tooling
  • support and exception queues
  • agents creating, modifying or invoking other agents

The right way to read the model is:

  • The chart shows a linear base run-cost case.
  • The real enterprise cost stack may add nonlinear governance, integration and security overhead.
  • The earlier an organisation measures actual runs, failures and cost per outcome, the less likely the agent estate is to surprise finance later.

The Microsoft pricing anchor

The public Microsoft anchor for this model is Copilot Studio billing.

Microsoft publishes pay-as-you-go billing at $0.01 per Copilot Credit. Microsoft also offers capacity packs at $200 per month for 25,000 Copilot Credits, equivalent to $0.008 per credit if fully used in the month.

Microsoft's Copilot Studio pricing page also confirms:

  • Microsoft 365 Copilot is listed at $30/user/month, paid yearly.
  • Microsoft 365 Copilot includes Copilot Studio access for licensed users to create and use internal agents within Microsoft 365.
  • Standalone Copilot Studio is needed for external channels, non-licensed users and additional standalone flexibility.
  • Copilot Studio has three purchase patterns: capacity packs, pay-as-you-go and pre-purchase plans.
  • An Azure subscription is required to use agents.
  • The pre-purchase plan can save up to 20% with up-front purchase of Copilot Credit Commit Units.
  • PAYG helps keep business-critical agents running when prepaid credits run out.

Microsoft's billing-rate page shows that an agent run is not one unit of cost. Selected Microsoft-published Copilot Studio rates include:

Copilot Studio featureBilling rate
Classic answer1 Copilot Credit
Generative answer2 Copilot Credits
Agent action5 Copilot Credits
Tenant graph grounding10 Copilot Credits
Agent flow actions13 Copilot Credits per 100 actions
Basic text/generative AI tools1 Copilot Credit per 10 responses
Standard text/generative AI tools15 Copilot Credits per 10 responses
Premium text/generative AI tools100 Copilot Credits per 10 responses
Content processing tools8 Copilot Credits per page
Classic voice10 Copilot Credits per minute
GenAI voice35 Copilot Credits per minute
Premium GenAI voice75 Copilot Credits per minute

Microsoft also states that reasoning-capable language models use two meters:

  1. the feature rate for the action; and
  2. the premium text/generative AI tools rate for reasoning-model token usage.

That is important. Once agents use reasoning models, the cost model must capture tokens, not only actions.

Model assumptions

This model uses three agent types. The assumptions are deliberately simplified. They are not Microsoft price promises, and they must be replaced with telemetry before customer-specific decisions.

1. OBO agents

OBO agents act on behalf of a user. They are assumed to have lower run cost in this model because the user context provides a clearer access boundary and the model excludes incremental seat licensing.

This treatment has become more defensible after Microsoft's updated billing guidance. Microsoft states that employee-facing Copilot Studio agent usage and tools invoked by those agents are included for Microsoft 365 Copilot licensed users when the agent operates using the authenticated Microsoft 365 Copilot user identity, subject to fair usage limits.

Assumptions:

  • 10 agents in the 20-agent scenario
  • 500 runs per agent per month
  • no incremental Copilot Studio credits in the base case
  • $0.005 operating control cost per run
  • 0.3% exception rate
  • $18 per exception

2. Workflow agents

Workflow agents automate repeatable processes and call tools, connectors or agent flows.

Assumptions:

  • 7 agents in the 20-agent scenario
  • 2,000 runs per agent per month
  • 18 Copilot Credits per run
  • $0.015 operating control cost per run
  • 1.0% exception rate
  • $18 per exception

3. Non-human identity ERP agents

NHI ERP agents are autonomous or semi-autonomous agents that access systems of record. They have higher run cost because they are assumed to use more grounding, actions, controls and exception handling.

Assumptions:

  • 3 agents in the 20-agent scenario
  • 5,000 runs per agent per month
  • 28 Copilot Credits per run
  • $0.04 Foundry/model cost per run
  • $0.06 operating control cost per run
  • 2.5% exception rate
  • $18 per exception

Scenario math

Pilot: 20 agents

Agent mix:

  • 10 OBO agents
  • 7 workflow agents
  • 3 NHI ERP agents

Monthly runs:

  • OBO: 10 x 500 = 5,000
  • Workflow: 7 x 2,000 = 14,000
  • NHI ERP: 3 x 5,000 = 15,000
  • Total monthly runs: 34,000

Monthly operating cost:

  • OBO: $2,770
  • Workflow: $4,760
  • NHI ERP: $10,465
  • Total: $17,995 per month

Annual run-rate: $215,940

Scale-up: 200 agents

Agent mix:

  • 100 OBO agents
  • 70 workflow agents
  • 30 NHI ERP agents

Monthly runs:

  • OBO: 50,000
  • Workflow: 140,000
  • NHI ERP: 150,000
  • Total monthly runs: 340,000

Monthly operating cost:

  • OBO: $27,700
  • Workflow: $47,600
  • NHI ERP: $104,650
  • Total: $179,950 per month

Annual run-rate: $2,159,400

Industrialised: 2,000 agents

Agent mix:

  • 1,000 OBO agents
  • 700 workflow agents
  • 300 NHI ERP agents

Monthly runs:

  • OBO: 500,000
  • Workflow: 1,400,000
  • NHI ERP: 1,500,000
  • Total monthly runs: 3,400,000

Monthly operating cost:

  • OBO: $277,000
  • Workflow: $476,000
  • NHI ERP: $1,046,500
  • Total: $1,799,500 per month

Annual run-rate: $21,594,000

Purchase options: PAYG, capacity packs, CCCUs and ACUs

There are four purchase routes to model:

  1. PAYG: $0.01 per Copilot Credit, billed through Azure.
  2. Capacity packs: $200/month for 25,000 Copilot Credits, expiring monthly.
  3. Copilot Credit Pre-Purchase Plan: one-year upfront purchase of Copilot Credit Commit Units (CCCUs), with tiered discounts.
  4. Microsoft Agent Prepurchase Plan: one-year upfront purchase of Agent Commit Units (ACUs), which can offset eligible Copilot Studio, Microsoft Foundry, Fabric and GitHub usage.

The table below keeps operating controls and exception handling unchanged. It changes only the Microsoft AI consumption buying option.

ScenarioPAYG monthlyCapacity packs monthlyCopilot Credit P3 monthly equivalentAgent P3 monthly equivalent
20 agents$17,995$16,675$17,525$17,629
200 agents$179,950$166,750$172,416$172,915
2,000 agents$1,799,500$1,667,500$1,681,180$1,716,145

How to read the option table

Capacity packs can be attractive for stable monthly Copilot Credit usage because the effective price is $0.008 per credit when the pack is fully consumed. In this model, monthly capacity packs are the lowest calculated option at all three scales, but that assumes usage is steady enough that credits are not wasted at month end.

Copilot Credit P3 is better suited to larger annual Copilot Credit demand that may be uneven by month. It gives annual flexibility, but the customer buys a one-year pool upfront. Microsoft states that Copilot Credit P3 is purchased as a reservation-style item, appears as a separate invoice line, is not deducted from Azure Prepayment, and cannot be cancelled or exchanged.

Microsoft's Microsoft 365 admin center guidance also matters. It states that Copilot Credit P3 and PAYG are not separate billing options; P3 is layered on top of PAYG. It also states that when capacity packs and P3 are both selected, the billing order is:

  1. capacity packs
  2. P3 prepaid credits
  3. pay-as-you-go

Agent P3 is not always mathematically cheapest for a pure Copilot Studio workload. Its value is flexibility across eligible agentic services. If the organisation is also consuming Foundry, Fabric and GitHub AI Credits, ACUs may be commercially cleaner than trying to optimise each pool in isolation.

But ACUs also introduce precedence questions. Microsoft states that reservations apply before prepurchase plans. For example, Foundry PTU reservations and Fabric capacity reservations are consumed before broader Agent P3 commit units. The customer should not buy ACUs without understanding existing reservations, capacity commitments and subscription scope.

Why Work IQ changes the OBO versus NHI discussion

The OBO versus NHI issue is now more than an identity architecture preference.

Work IQ API is designed to let agents reason over Microsoft 365 work context: email, meetings, calendar, OneDrive, SharePoint, Teams messages, people, organizational context and enterprise search. Microsoft states that Work IQ API uses Microsoft Entra ID delegated authentication:

  • requests run in the context of the signed-in user
  • on-behalf-of flows are supported
  • application-only authentication is not supported
  • Microsoft 365 permissions, sensitivity labels and compliance policies are enforced automatically

That is commercially important.

If an agent needs Microsoft 365 work context, Microsoft is pushing the clean pattern toward delegated access and permission-trimmed user context. That supports the OBO side of the model.

It does not remove the NHI problem. It separates the cases:

  • OBO agents are better suited where a human user is present, the action is user-scoped, and delegated permissions are appropriate.
  • NHI agents are better suited where work is autonomous, event-driven, system-owned or background-processing oriented.
  • NHI agents that need ERP, inventory, finance or other systems of record should be modelled with a different risk, control and cost profile.

The economic fault line is not "agent versus user". It is:

Does the agent run under a user entitlement and delegated permissions, or does it operate as a separately governed digital actor?

Why GitHub Copilot metering matters

GitHub Copilot's usage-based billing change does not directly change the base business-process agent model unless developer agents or coding agents are in scope.

It does, however, reinforce the broader direction.

GitHub announced that all Copilot plans transition to usage-based billing from 1 June 2026. Usage is calculated from token consumption, including input, output and cached tokens. GitHub also confirmed that Copilot code review consumes GitHub Actions minutes in addition to GitHub AI Credits.

This is the same economic pattern appearing in another Microsoft AI product:

  • subscription entitlement remains
  • intensive usage is metered
  • heavy users need budget controls
  • agentic sessions cost more than simple prompts

For a Microsoft customer with a growing agent estate, the implication is not that GitHub costs should be mixed into every Copilot Studio agent. The implication is that Microsoft AI is moving toward a common commercial design: per-user entitlement plus metered consumption plus controls.

That is why ACUs matter. They are a sign that Microsoft expects enterprises to manage a broader pool of agentic usage across workloads, not only one product line.

Foundry changes the cost model

Copilot Studio is not the whole agent estate.

Microsoft Foundry matters because production agents often need model choice, orchestration, tools, observability, evaluations, private networking, persistent state and integration with enterprise systems.

Hosted agents in Foundry Agent Service make this more explicit. Microsoft describes hosted agents as managed containerised services for custom agent code. They can use frameworks such as Microsoft Agent Framework, LangGraph, Semantic Kernel or custom code. They can run stateful workloads and access Foundry-managed tools.

For cost modelling, hosted agents matter because:

  • each hosted agent has its own Microsoft Entra ID agent identity
  • user-invoked scenarios can support OAuth 2.0 OBO flows when a user token is present
  • autonomous/background scenarios use the agent's own identity
  • each session runs in a VM-isolated sandbox
  • state can persist across idle periods
  • active-session concurrency has quotas
  • billing is based on CPU and memory consumed across active sessions
  • oversized CPU and memory allocation multiplies cost by concurrency
  • observability runs through Application Insights

This creates a different cost-control discipline:

  • right-size CPU and memory
  • monitor request duration and active sessions
  • separate user-invoked and background workloads
  • track storage and state retention
  • control tool access
  • measure the cost of failures and retries

The cost control problem is no longer only:

How many Copilot Credits did the agent use?

It becomes:

What is the full runtime footprint of the agent estate?

The MCA and MACC problem

A 5,000-user customer with $5m of EA spend and $5m of Azure spend should not treat agent economics as a Microsoft 365 line item only.

The charge may appear in Azure, Microsoft 365, Power Platform, GitHub, Fabric or a prepaid commitment. It may draw down MACC. It may sit under an MCA billing profile or invoice section. It may be scoped to a subscription, resource group, management group or shared billing context. It may be an upfront reservation-style purchase that is not deducted from an Azure prepayment balance.

For this type of customer, the agent cost model should be connected to the MCA or EA/MACC operating model before scale:

  • Which Azure subscription owns PAYG Copilot Credit billing?
  • Which billing account, billing profile or invoice section receives the charge?
  • Which cost centre owns Copilot Studio agents?
  • Which team can buy Copilot Credit P3 or Agent P3?
  • Do reservation purchasers have authority to commit annual spend?
  • Does the customer have MACC obligations that should influence the purchase route?
  • Are support calculations affected by incremental Microsoft AI consumption?
  • Do chargeback tags, management groups and budgets exist before the agents go live?
  • What happens when a monthly budget is reached?

The dangerous version is the one Microsoft makes administratively easy: connect a subscription, let agents run, and reconcile the surprise later.

Potential future uplift: NHI Microsoft 365 workload licensing and support

This is not an Agent ID or Agent 365 licensing argument.

The question is whether a non-human identity doing Microsoft 365 work should eventually require a Microsoft 365 workload entitlement if it has, or behaves like it has, a mailbox, OneDrive, Teams presence, SharePoint access or Graph-based access to Microsoft 365 services.

Microsoft's multiplexing guidance says users and devices need appropriate licences whether access is direct or indirect. Microsoft 365 Apps guidance also says to license every user or device that directly or indirectly accesses, uses or benefits from a product. That does not create a clean published rule saying every NHI agent currently needs its own Microsoft 365 E3/E5 licence.

It does, however, make the commercial question obvious:

If NHI agents become licensed digital workers inside Microsoft 365 workloads, what happens to the run-rate?

Microsoft's July 2026 commercial price table lists Microsoft 365 E3 at $39/user/month and Microsoft 365 E5 at $60/user/month for suites with Teams. Existing customers remain on current pricing until renewal, so this is a future/renewal list-price stress test, not a statement about an existing EA net price.

If Microsoft later required non-human identity agents to carry a Microsoft 365-style licence, and if we assumed that future agent SKU was priced at 50% of that published E3/E5 list, then the incremental per-agent licence assumption would be:

  • 50% of Microsoft 365 E3 at $39/user/month = $19.50 per NHI agent/month
  • 50% of Microsoft 365 E5 at $60/user/month = $30.00 per NHI agent/month

Using the model's 15% NHI mix and E5-style stress assumption:

ScenarioNHI agentsHypothetical NHI licence upliftPAYG plus future NHI licencePAYG plus NHI licence and 8% support uplift
20 agents3$90/month$18,085/month$19,532/month
200 agents30$900/month$180,850/month$195,318/month
2,000 agents300$9,000/month$1,808,500/month$1,953,180/month

The 8% support figure is a modelling assumption, not a universal Microsoft rule. Unified Support is customer-specific, and support fees depend on the customer's support agreement, appraised product spend, concessions, timing and classification of spend. The point is not that every customer pays exactly 8%. The point is that incremental Microsoft AI consumption may have a support consequence and should not be modelled in isolation.

Controls to put in place

1. Agent register

Track every agent as an inventory item:

  • owner
  • business process
  • identity model
  • environment
  • data sources
  • downstream systems
  • Microsoft billing meter
  • monthly run volume
  • monthly credit consumption
  • failure rate
  • exception rate
  • cost per successful outcome

2. Spending policies and hard caps

Microsoft 365 admin center Cost Management now makes spending policy design part of the control model for supported services.

Define:

  • which users or groups can consume credits
  • monthly spending limits
  • user-level limits
  • alert thresholds
  • which agents and services are allowed
  • whether new services and agents are automatically added to policies
  • which Azure subscription or prepaid pool is used
  • what happens when limits are reached

The default should not be "allow everything and measure later".

3. Monthly runs and failed runs

Track run volume by agent, environment and business process. Failed runs matter because they can still consume resources and often create human cleanup work.

Suggested metrics:

  • total runs
  • successful runs
  • failed runs
  • retries
  • average Copilot Credits per run
  • average tokens per reasoning-model operation
  • cost per successful outcome

4. Separate OBO and NHI budgets

Do not combine OBO and NHI agents into one budget line.

OBO agents should be measured against user productivity, permission-trimmed access and Microsoft 365 Copilot entitlement boundaries.

NHI agents should be measured against autonomous action, downstream system risk, credential control, auditability and exception cost.

5. ERP and systems-of-record controls

For agents touching ERP, finance, procurement, HR, customer data or regulated workflows, require:

  • human approval thresholds
  • separation of duties
  • transaction limits
  • audit logs
  • rollback procedures
  • rate limits
  • exception queues
  • emergency disablement

6. Commitment gates

Use simple gates:

GateCommercial posture
DiscoveryPAYG, small budget, strict telemetry, no annual commitment
Controlled scaleCapacity packs or low P3 commitment only after stable consumption is visible
Mixed AI estateConsider Agent P3 only when Copilot Studio, Foundry, Fabric and GitHub usage can be forecast together
Industrialised estateConnect agent budgets to MCA/MACC, support, security, identity and chargeback

Caveats

This model is intentionally conservative, but it is still a model.

It does not replace:

  • Microsoft Product Terms
  • customer-specific Microsoft quotes
  • Azure Cost Management exports
  • Copilot Studio telemetry
  • Microsoft 365 admin center Cost Management data
  • GitHub billing exports
  • legal/licensing advice
  • security architecture review

The model also excludes or simplifies:

  • tenant-specific discounts
  • price protection and renewal timing
  • currency and tax treatment
  • regional service availability
  • service-specific throttling
  • actual model token consumption
  • actual voice usage
  • actual Work IQ or Cowork usage
  • Foundry hosted-agent CPU/memory rates
  • test, evaluation and retry runs
  • SIEM ingestion
  • Agent 365 or other agent governance tooling
  • support-fee classification
  • non-Microsoft model and third-party tool costs

The article should be read as a framework for Microsoft AI agent run-cost governance, not as a quote.

Technical notes

Base formulas

Monthly runs:

agent count x runs per agent per month

Copilot Credit cost under PAYG:

monthly Copilot Credits x $0.01

Copilot Credit cost under capacity packs:

ceiling(monthly Copilot Credits / 25,000) x $200

Monthly operating cost:

Copilot Credit cost + Foundry/model cost + operating controls + human exception handling

Exception cost:

monthly runs x exception rate x cost per exception

Cost per successful outcome:

total monthly operating cost / successful runs

Agent mix

The model uses:

  • 50% OBO agents
  • 35% workflow agents
  • 15% NHI ERP agents

The mix is held constant across 20, 200 and 2,000 agents.

Why the option table differs from the base case

The option table changes the Microsoft AI consumption purchasing method only. It does not reduce human exception handling, operating controls or other enterprise overhead.

Capacity-pack figures assume all monthly purchased credits are used. Any unused capacity pack credits reduce the effective saving.

Copilot Credit P3 figures apply the modelled tier discount that aligns to the annual Copilot Credit retail value in the model. Actual purchases should be quoted by Microsoft because tiering, rounding, overage, existing discounts and contract terms matter.

Agent P3 figures apply the modelled ACU tier discount to the annual eligible AI retail value in this model: Copilot Credit retail value plus the modelled Foundry/model component. Actual eligibility should be confirmed against the customer's agreement, Azure subscription, Microsoft quote and existing reservations.

Conclusion

Microsoft AI will be useful.

That is not the problem.

The problem is that useful agents run frequently, touch valuable systems, create exceptions, trigger retries, consume credits, call models, use compute and sit inside contracts that were not designed around thousands of delegated and autonomous digital actors.

Agent economics will look less like software licensing and more like Azure FinOps with identity governance attached.

The customers who do this well will not ask only:

How many agents do we have?

They will ask:

What does each successful agent outcome cost, who owns the spend, what identity did it use, what contract meter did it hit, and what happens when it scales 10x?

That is the question to answer before agents become normal.

Sources