Computer-using agents go GA in Copilot Studio: cost vs RPA

Microsoft published a substantial Copilot Studio update yesterday, 26 May, and the headline item is one every team still babysitting a legacy system should read twice: computer-using agents are now generally available. These agents operate websites and desktop applications through the user interface, exactly the way a human does. The same post puts a redesigned visual workflows designer into early release environments, where existing agents drop into workflows as nodes. Real-time voice agents reach general availability in North America through Dynamics 365 Contact Center. Agent-to-agent (A2A) communication moves to GA as well, alongside support for remote MCP servers and a new orchestration layer that Microsoft says improves evaluation performance by roughly 20% while halving net token usage. For Azure-first teams in Sweden and the wider EU, the practical question is narrower than the announcement. You almost certainly have processes stuck behind systems with no API, and you may already pay for classic RPA to bridge them. As of yesterday there is a generally available alternative with a very different cost model.

What Microsoft shipped on 26 May

Computer-using agents: generally available, with enterprise plumbing

Computer-using agents (CUA) have been visible in preview for a while; what changed yesterday is the GA label and the operational features that make the label credible. Per Microsoft's post, the GA release lets you manage credentials more securely, choose models suited to different automation scenarios, and build automations that adapt to changing interfaces instead of breaking whenever a screen or webpage changes. That last point is the entire pitch. Classic RPA fails predictably: a vendor ships a UI refresh and your selectors stop matching, so a process that ran unattended for months starts throwing errors at 02:00. A computer-using agent looks at the screen the way a person does. It finds “the amount field” rather than input#txtAmount_v2, so a moved button or renamed element is an inconvenience, not an outage.

Microsoft positions CUA squarely at processes “that previously relied on brittle scripts or manual workarounds because the underlying systems lacked APIs”. One important nuance from the same post: embedding computer-using agents directly into multi-step workflows is only moving into preview. The agent itself is GA; the deep workflow integration is not yet. Plan accordingly.

The new workflows designer and agent nodes

The second significant piece is a redesigned workflows experience, now available in early release environments. You design workflows end-to-end on a unified canvas, with inline configuration and node-level testing. The interesting architectural move is agent nodes: you can add existing agents directly into a workflow as nodes, combining what Microsoft calls the “scalable reliability of workflows” with “AI intelligence when you need it”. That is the pattern we have been recommending for a year in custom builds: a deterministic backbone that sequences and retries every step and logs it, delegating to an adaptive agent only for the steps that genuinely need reasoning, such as classifying an unstructured email, reconciling a fuzzy match, or driving a UI. Having it as a first-class Copilot Studio construct rather than a hand-rolled orchestrator matters for maintainability and for governance reviews.

Real-time voice agents: GA, but North America only

Real-time voice agents are now generally available in North America through Dynamics 365 Contact Center, with speech-to-speech experiences and a new in-depth governance guide covering escalation, monitoring, security, compliance and operational readiness. The capability set is what a contact centre wants: identify callers, answer questions, take action mid-conversation, and hand off to a live agent with context preserved. The region qualifier is doing a lot of work in that sentence for European readers; we come back to it below.

A2A at GA, remote MCP servers, and a faster orchestrator

Three quieter items round out the release. Agent-to-agent (A2A) communication is now generally available, so agents can exchange information and delegate tasks to each other under a supported contract rather than through improvised glue. Support for remote Model Context Protocol (MCP) servers gives you a standardised way to connect agents to tools and enterprise resources. If you have been building MCP servers for your internal APIs, as we have been advocating all spring, Copilot Studio agents can now consume them directly. And a new orchestration layer, currently in early release environments where it applies automatically, improves evaluation performance by approximately 20% while decreasing net token usage by 50%, per Microsoft's figures.

Does halving tokens halve your bill? No. Copilot Studio's standard billing is per event (per answer, per agent action), not per token, so the 50% token reduction does not flow one-to-one into your Copilot Credits consumption. Where it does pay directly is latency and capacity headroom, plus any configuration where you pay for tokens yourself: Microsoft's billing documentation notes that bring-your-own-model setups, including Azure Foundry models, are billed separately. For everyone else it is a quality-and-speed upgrade, and a signal about where Microsoft's own margin pressure lies.

What a computer-using agent run actually costs

Copilot Studio meters usage in Copilot Credits, pooled at tenant level. You buy them as packs ($200 per month for a 25,000-credit pack on Microsoft's pricing page, which works out to $0.008 per credit), or you attach a pay-as-you-go meter to an Azure subscription at $0.01 per credit with no upfront commitment. The rates that matter for this discussion, from Microsoft's billing documentation:

Classic answer: 1 credit
Generative answer: 2 credits
Agent action: 5 credits. Per the same documentation, computer-using agents are billed at the agent action rate
Tenant graph grounding: 10 credits per message
Agent flow actions: 13 credits per 100 actions
Voice: 10–75 credits per minute depending on tier, with core agent activity included

So the cost of a CUA run is essentially the number of billable agent actions it takes, times 5 credits. Actions per run depend entirely on your process: how many steps, how much reasoning, how many systems. The only reliable way to cost it is to build the automation and measure it, running against the test harness and reading the consumption off the activity map and the Power Platform admin centre. Illustrative arithmetic still shows the shape of the economics:

Illustrative example (your action counts will differ - measure them):

A CUA automation that books an order into a legacy ERP
Assume the run consumes 8 billable agent actions

Per run:      8 actions x 5 credits             = 40 credits
              40 credits x $0.008 (prepaid)     = ~$0.32 / run
              40 credits x $0.01  (pay-as-you-go) = ~$0.40 / run

At 2,000 runs/month:  80,000 credits  = 3.2 packs = ~$640/month
At 200 runs/month:     8,000 credits  = under one $200 pack

Two billing behaviours deserve a place in your budget memo. First, overage enforcement: under the prepaid capacity model, when a tenant reaches 125% of prepaid capacity, custom agents are disabled. Ongoing conversations finish, and new invocations are rejected until capacity is added. You can reallocate capacity between environments or buy more packs, and attaching pay-as-you-go absorbs overage automatically. If a CUA automation sits in a business-critical path, treat the pay-as-you-go meter as mandatory insurance, not an option. Second, Microsoft 365 Copilot licence inclusion: employee-facing usage of Copilot Studio agents is included at no charge for users with a Microsoft 365 Copilot licence, within fair-use limits. Whether and how that inclusion applies to computer-using agent consumption in your scenario is exactly the kind of question to confirm against the current licensing guide before you build a business case on it. The inclusion rules are scenario-specific, and Microsoft revises them as usage patterns emerge.

CUA versus classic RPA: a decision guide

The comparison that matters is not CUA versus doing nothing; it is CUA versus the RPA estate you already run or were about to buy. On the Microsoft side, classic RPA means Power Automate desktop flows: $15 per user per month for attended automation (Premium), $150 per bot per month for unattended (Process), or $215 per bot per month for a Microsoft-hosted VM (Hosted Process), per Microsoft's current price list. The structural difference is that RPA is a flat per-bot cost with effectively unlimited runs up to the bot's throughput, while CUA is a pure consumption cost that scales with volume.

Rule zero: an API beats both

Before comparing UI automation options, exhaust the alternatives that do not involve driving a UI at all. A REST API, an OData endpoint, a database view, a file drop, a connector — any of these will be faster and cheaper than either CUA or RPA, and more reliable too. UI automation of any flavour is the last resort, chosen because the system genuinely offers no other integration surface. That has been true for fifteen years of RPA, and GA does not change it.

When the computer-using agent wins

The UI changes often. If your RPA maintenance log is full of “selector updated after vendor release”, adaptive UI understanding attacks your largest cost, which is usually people, not licences.
Volume is low to moderate. At hundreds or a few thousand runs a month, consumption pricing beats paying $150–215 per month per bot for capacity you barely use.
The process has judgment in it. Steps like “pick the matching invoice line even though the reference is formatted oddly” are where deterministic RPA needs brittle rule trees and an agent can simply reason.
You have no RPA estate and want one automation, not a platform. A Copilot Studio agent avoids the VM, the orchestrator and the RPA centre of excellence.

When classic RPA still wins

High, steady volume. Flat per-bot pricing amortises. At $0.008 per credit, a $215 hosted bot equals roughly 26,900 credits per month, or about 5,400 agent actions. Beyond that, every additional run makes the bot cheaper on licence cost alone (using our illustrative action counts; measure your own).
The process must be exactly reproducible. Deterministic scripts do the same thing every time, which auditors and regulated processes love. An adaptive agent's flexibility is a liability where you need bit-for-bit replayable behaviour.
Throughput and latency are tight. A scripted click sequence is fast; a model reasoning about screenshots is not. Batch windows measured in minutes favour RPA.
The UI is stable and the automation already works. Ripping out a functioning, paid-for desktop flow to adopt a newer technology is a cost, not a strategy. Migrate on breakage or on renewal, not on announcement.

Six questions before you commit either way: (1) Is there truly no API, connector or file-based interface, confirmed by the vendor rather than by folklore? (2) How many runs per month, and what does that volume cost under 5-credits-per-action consumption versus a flat bot licence? (3) How often has this UI changed in the past two years, and who paid for the fixes? (4) Does the process need judgment, or is it purely mechanical? (5) What happens at 125% credit overage: is pay-as-you-go attached, and who watches consumption in the admin centre? (6) Can a human review or reverse what the automation does, and is every run logged for audit? If question 1 fails, stop and integrate properly instead.

The most interesting long-term answer is not either/or but the agent-node pattern the new workflows designer enables: a deterministic workflow as the backbone, classic automation for the stable mechanical steps, and an agent node only where a step needs adaptivity. Once the workflow integration leaves preview, that node can be a computer-using agent. The pattern keeps consumption billing confined to the steps that earn it.

The Swedish and EU angle

The legacy-system reality. The organisations with the most to gain here are the ones Microsoft's “systems that lack APIs” phrasing describes: municipalities and public agencies running case-management and records systems procured a decade or more ago, and manufacturers with MES, quality and supplier portals that expose nothing but a browser login. In our work with Swedish organisations, these API-less islands are routinely the blocker that stalls an otherwise sound automation roadmap. A GA, supported, UI-driving agent inside the Power Platform your organisation already licenses is a materially lower-friction answer than procuring a separate RPA platform. The difference is sharpest in public-sector settings, where adding an entirely new vendor means a new procurement exercise while extending an existing Microsoft agreement often does not.

Voice: wait for the EU date. Real-time voice agents are GA in North America only. If you run Dynamics 365 Contact Center in Sweden, this release gives you a governance guide to study and a capability to demo, not something to put customer-facing launch dates against. Ask your Microsoft account team for the European availability roadmap in writing before any 2026 commitment, and use the waiting time to work through the voice governance guidance, because a Swedish-language voice agent will face all the governance questions in that guide plus GDPR call-recording obligations.

Data protection homework for CUA specifically. A computer-using agent works by observing application screens, and screens in real business systems contain personal data (names, personnummer, salaries, health information) whether or not the task concerns them. Before production use on regulated workloads, get concrete answers: where is the screen content processed and by which models, how long is any of it retained, and how does the processing sit within your EU data residency commitments? Use the GA credential-management features rather than shared service accounts, so every automated session is attributable. Your auditors and your DPO will want the same thing, and increasingly your AI Act documentation will too: a log of which agent did what, where, as whom. Put the DPIA on the critical path rather than after it.

Budget scrutiny. EU IT budgets are examining AI line items hard this year, and consumption billing has a habit of surprising finance in month three. The disciplines are boring and effective: pilot with measured action counts before projecting annual cost, allocate credit capacity per environment in the Power Platform admin centre so one team's runaway agent cannot exhaust the tenant pool, attach pay-as-you-go to business-critical environments, and review consumption monthly. Treat Microsoft's 20%-better, 50%-fewer-tokens orchestration claim as an engineering improvement to verify in your own evaluations, not as a discount; per-event credit pricing means it is not one.

Conclusion

Computer-using agents at GA make UI automation a real decision for any team maintaining brittle scripts or manual workarounds around API-less systems. The decision stays conditional. Consumption-billed adaptive agents win on frequently changing UIs and modest volumes. Flat-priced deterministic RPA keeps winning at high, steady volume and wherever behaviour must be exactly reproducible. An actual API beats both every time one exists. The workflows designer with agent nodes shows where this converges: deterministic orchestration, with adaptivity purchased only where it pays. A2A and remote MCP support at GA make Copilot Studio agents easier to wire into a wider architecture than they were a month ago. For Swedish teams the next step is a single pilot: pick one API-less process that hurts, build the CUA automation against test data, measure actions per run, and let the arithmetic — not the announcement — make the call.