# Computer-Using Agents Are Now GA in Copilot Studio — Here's Why That's a Big Deal
May 27, 2026 | Jeff's Journal
Let's be honest for a second: we all have that one application. You know the one. It runs a critical business process. It's been around since before "the cloud" was a thing. It has no API. It has no webhook. It has no modern integration points whatsoever. And yet, every single day, someone on your team opens it up, clicks through the same fifteen screens, and keys in the same data that already exists somewhere else.
Until now, automating that application meant either replacing it entirely (a multi-year, multi-million-dollar project) or building a house of cards out of brittle screen-scraping scripts that break the moment the vendor changes a button color.
This month, Microsoft changed the calculus on that problem. Computer-using agents in Microsoft Copilot Studio are now generally available.
This is not "RPA with a chatbot wrapper." This is a fundamentally different approach to UI automation — one that reasons about what it sees on screen, adapts when interfaces change, and can be embedded directly into multi-step workflows alongside API-based actions, approvals, and business logic.
Let me walk you through what this actually means, why it's different from what came before, and how one global company is already running it in production.
What Is a Computer-Using Agent, Exactly?
A computer-using agent is an AI-powered agent that interacts with websites and desktop applications through the user interface — the same way a human would. It sees buttons, text fields, dropdowns, and tables. It clicks. It types. It reads what's on screen. And it makes decisions based on what it finds.
The key difference from traditional RPA is reasoning. Traditional robotic process automation follows a script. If the script says "click the button at coordinates (400, 300)" and the button has moved to (410, 310) because someone added a banner, the automation fails. A computer-using agent, by contrast, understands the _intent_ — "find and click the Submit button" — and can locate it even when the UI shifts around.
Here's what ships with the general availability release:
- •**Secure credential management** so agents can log into applications without hardcoding passwords
- •**Model selection** to choose the best AI model for different automation scenarios
- •**Resilient execution** that adapts to changing interfaces instead of breaking
- •**Workflow integration** (now in preview) to embed computer-using steps directly into multi-step business processes
That last one is particularly powerful. You can now have a workflow that calls an API, waits for an approval, invokes a computer-using agent to interact with a legacy system, evaluates the result with AI reasoning, and then routes the outcome — all on a single visual canvas.
The Real-World Test: Graebel's Service Order Agent
Theory is nice, but what does this look like in production? Let me share a story that Microsoft published alongside the GA announcement.
[Graebel](https://www.graebel.com/), a global leader in talent mobility, processes thousands of employee relocation requests every year. Each request arrives as an unstructured email — unique instructions, attachments, edge cases, the works. The data from each request needs to flow into Graebel's proprietary Global Connect platform, which handles more than 30 different relocation service categories.
The problem? Global Connect had no API. Earlier automation attempts were too rigid. They broke on variability. The team was stuck with manual data entry and handoffs.
Working with GET AI and Microsoft, Graebel built the Graebel Service Order Agent in Copilot Studio. The agent can:
1. Read and interpret incoming relocation request emails 2. Validate requests against business rules 3. Operate Global Connect directly through the UI — navigating screens, filling fields, submitting records 4. Escalate exceptions through workflows when it encounters something it can't handle
The results so far: meaningful reduction in manual effort, faster service-order turnaround, more consistent data quality, and a repeatable blueprint for bringing intelligent automation to the rest of their operations.
"We've moved beyond traditional automation to a more intelligent, scalable operating model," said Matt Brownlee, Chief Revenue Officer at Graebel.
That's not vendor marketing speak. That's a real company solving a real problem that every enterprise faces: the gap between modern AI capabilities and the legacy systems that still run the business.
Why This Matters for the Microsoft Ecosystem
If you've been following the agent space, you know there's been an explosion of frameworks, platforms, and approaches. What makes Copilot Studio's computer-using agents worth paying attention to isn't just the technology — it's how it fits into the broader Microsoft ecosystem.
It's governed. These agents run within your Microsoft 365 tenant. They respect your data loss prevention policies, your conditional access rules, and your compliance framework. You're not shipping credentials to a third-party desktop automation service.
It's connected. The agent isn't an island. It plugs into Power Platform data sources, Dataverse, SharePoint, Teams, Outlook, and hundreds of connectors. A computer-using agent in Copilot Studio can read an email in Outlook, extract data from a PDF in SharePoint, interact with a legacy ERP through the UI, and write the result back to Dataverse — in one workflow.
It's built for teams. The new visual workflow designer, available now in early release environments, lets you compose these automations on a unified canvas. You drop in an agent node where you need AI reasoning. You use traditional actions where you need deterministic logic. You can test individual nodes without running the entire workflow.
This isn't a developer-only tool. It's designed for the "fusion team" model that Microsoft has been championing — where pro developers, citizen developers, and business analysts collaborate on the same platform.
Getting Started: Your First Computer-Using Agent
If you have access to Copilot Studio (included in many Microsoft 365 licenses), here's a practical path to your first computer-using agent:
1. Pick the Right Process
The sweet spot is a process that: - Runs against a web application or desktop app without a modern API - Has variable inputs that require some interpretation - Is repetitive enough to be worth automating but complex enough that traditional RPA struggles
Invoice processing into a legacy ERP. Customer data lookups in an old portal. Order entry into a supplier's website. These are perfect candidates.
2. Define the Agent's Instructions
In Copilot Studio, you create a new agent and write natural-language instructions. For example:
"You are an invoice processing agent. When you receive an invoice, log into the ACME ERP system at portal.acme.com, navigate to the Accounts Payable module, create a new invoice record, and populate all fields from the invoice data provided to you. If you encounter an error or a field you cannot map, escalate to a human through the workflow."
You don't describe screen coordinates. You describe intent.
3. Configure Credentials Securely
Use Copilot Studio's credential management to store the login for the target application. The agent retrieves credentials at runtime — no secrets in your instructions, no hardcoded passwords.
4. Embed in a Workflow
Build a workflow that triggers the agent (e.g., when an email arrives in a shared mailbox), passes the data to the agent, handles the agent's response, and routes exceptions. The new visual designer makes this drag-and-drop simple.
5. Test and Iterate
Run the agent in test mode. Watch it navigate the application. If it struggles with a particular screen, refine your instructions. The beauty of intent-based automation is that you're describing what to do, not pixel-by-pixel how to do it.
What's Next: Workflows + Agents = Smarter Automation
The GA of computer-using agents is happening alongside a broader redesign of workflows in Copilot Studio. The new workflow experience, now rolling out to early release environments, introduces:
- •**Agent nodes** — drop an existing agent directly into a workflow
- •**AI-powered actions** — classification, content generation, and decision support as native workflow building blocks
- •**Inline configuration and node-level testing** — validate behavior earlier, iterate faster
The combination is compelling. You can build workflows where deterministic logic handles the predictable parts (data validation, routing, approvals) and AI agents handle the fuzzy parts (reading unstructured emails, navigating legacy UIs, making judgment calls).
The Bigger Picture
There's a pattern I keep seeing across the Microsoft ecosystem this year: the line between "automation" and "intelligence" is disappearing.
Between Visual Studio's new Plan agent helping developers think through architecture before writing code, the Power Apps MCP server adding closed-loop learning so agents improve from user corrections, and Copilot Studio's computer-using agents bringing legacy applications into the AI era — the tools are converging on a vision where AI doesn't just answer questions. It does work.
Computer-using agents are a milestone in that journey. They solve one of the hardest and most common problems in enterprise automation: the last mile where no API exists. And they solve it in a way that's governed, connected, and accessible to teams that don't have armies of RPA developers.
If you've been waiting for the right moment to try Copilot Studio's agent capabilities, the GA of computer-using agents is a pretty good reason to jump in.
*Have you experimented with computer-using agents in Copilot Studio? I'd love to hear what you're building. Reach out and let me know — and as always, happy automating!*
Tags: #MicrosoftCopilot #CopilotStudio #AIAgents #PowerPlatform #IntelligentAutomation #ComputerUse #RPA