GitHub Copilot Computer Use: What It Is, How It Works

GitHub Copilot can now click, type, and scroll its way through desktop applications, not just code editors and terminals. The new "computer use" capability, announced on GitHub's official changelog on October 1, 2026, lets Copilot see a window's screen and accessibility tree and operate it the way a person would, with a mouse and keyboard, inside the GitHub Copilot app and GitHub Copilot CLI on macOS and Windows.

It's a public preview, it's off by default, and GitHub is explicit that it is built for the gap left by software that has no API, command line, or MCP server to talk to. Here's what Copilot Computer Use actually is, what it can and can't do yet, how to turn it on, and what GitHub itself says to watch out for.

What is GitHub Copilot Computer Use?

Computer use is a new way for Copilot to act on your machine. Instead of being limited to reading and writing files, running shell commands, or calling an MCP (Model Context Protocol) server, Copilot can now look at an application's window — using the operating system's accessibility tree, and screenshots when visual context is needed — and then drive it directly: clicking buttons and menus, typing and editing text, pressing keys, scrolling, dragging, and moving between windows and applications to carry out a multi-step task.

GitHub frames this as an extension of Copilot's existing agentic work, which already spans code, the command line, and GitHub.com itself. Computer use is aimed squarely at everything those surfaces can't reach: desktop software that has no API, no CLI, and no MCP integration to plug into. GitHub's own examples include summarizing notifications inside a browser window, updating content in a desktop presentation, entering or editing data in GUI-only line-of-business software, and moving information through a multi-step workflow that spans more than one application.

This is the same general idea the industry has started calling "computer use" or desktop agents elsewhere — Copilot's version is scoped to run through the Copilot CLI and the Copilot app rather than inside your code editor, and GitHub has built it with explicit, visible permission prompts rather than silent background control.

How Copilot Computer Use actually works

When computer use is enabled and Copilot decides a task needs it, Copilot requests permission to control a specific application. Once approved, Copilot reads the window's accessible content — the structured accessibility tree exposed by the OS, plus a screenshot when it needs visual context a11y data doesn't capture — and then issues the same kind of input a person would: clicking a control, typing into a field, pressing a key combination, scrolling a list, dragging an item, or switching windows to continue the task elsewhere.

Crucially, GitHub says Copilot works best here when you describe the outcome you want, the applications involved, and any constraints that matter, rather than issuing a literal step-by-step script. Copilot plans the sequence of clicks and keystrokes itself and adapts as the window's state changes — within the limits GitHub documents (see below).

What Copilot can do with desktop apps now

According to GitHub's changelog and documentation, computer use expands Copilot's reach into tasks like:

• Reading and summarizing information inside a desktop app or browser window that has no export or API
• Updating content inside a presentation or document application
• Entering, editing, or correcting data in legacy or GUI-only business software
• Carrying information through a multi-step workflow that spans several applications, one click and keystroke at a time

The common thread is software that was never designed to be automated — the line-of-business tools, legacy clients, and GUI-only utilities that engineering teams have historically had to operate by hand because there was no programmatic hook available.

How to enable Copilot Computer Use

Computer use ships off by default, and GitHub requires you to turn it on explicitly in whichever surface you're using.

In GitHub Copilot CLI

• Run /computer on to enable it
• Run /computer show to check whether it's currently on or off
• Run /computer off to disable it again

In the GitHub Copilot app

• Open Settings
• Select Computer Use
• Turn on Enable Computer Use

On macOS specifically, enabling computer use for the first time walks you through granting the operating system permissions Copilot needs to actually see and control other apps: Accessibility (to read and interact with on-screen controls) and Screen Recording (so Copilot can capture visual context when the accessibility tree alone isn't enough). Without those permissions, Copilot can't drive the window.

Every time Copilot wants to take control of a specific app, it asks for approval first. You can choose to approve a single action, or mark an app to "always allow," and GitHub says you can review or reset that always-allow list for any app at any time — organizations can also turn computer use off entirely through managed policy for Business and Enterprise accounts.

Which Copilot plans and platforms get it

GitHub's changelog post and its computer-use documentation describe this as a public preview of a capability inside the Copilot CLI and the Copilot app, available on macOS and Windows machines running local sessions — Linux is not listed as a supported platform for computer use itself, even though the Copilot app more broadly also runs on Linux for other features. GitHub's own materials don't spell out a separate per-plan paywall specifically for computer use; it's described as a capability of the CLI and app surfaces that are already available broadly across Copilot plans, rather than a distinct premium add-on. If you want the authoritative, current answer for your organization or plan, GitHub's own docs pages (linked below) are the place to check, since availability details on preview features can change during the preview period.

Organizations on Copilot Business and Enterprise can manage whether computer use is available to their users through Copilot's policy controls, the same way they manage other agent capabilities.

Limitations GitHub itself states

GitHub is upfront that this is a preview feature with real rough edges. Its documentation specifically calls out that computer use can struggle with:

• Interface changes between application versions
• Different window states (minimized, resized, behind other windows, multiple monitors)
• Non-standard or custom-drawn UI controls that don't expose clean accessibility data
• Long or complex multi-step workflows, where it may select the wrong control or place text in the wrong field

In practice, that means computer use is best treated as a capability you supervise rather than one you fully hand off, at least during this preview phase — which lines up with GitHub building approval prompts into the feature by default instead of letting Copilot act unattended on sensitive apps.

Safety notes and permission design

GitHub's own documentation includes a direct warning: ambiguous instructions or unexpected content appearing on screen "may cause unintended actions that affect your device, data, or connected accounts." Its explicit recommendation is to avoid granting "always allow" permission to applications that contain sensitive information, and to review your always-allow list periodically.

The permission model is built around a few concrete controls: computer use is disabled by default; Copilot asks before taking control of any given app; you can set approval requirements per Copilot surface; macOS requires you to explicitly grant Accessibility and Screen Recording permissions; and organizations can block the capability outright through managed Business/Enterprise policy. Together, GitHub positions this less as "autonomous desktop control" and more as a supervised assistant you explicitly let loose on one application at a time.

Why this matters

A huge amount of real-world work still happens in software that was never built with automation in mind — internal tools, legacy desktop clients, and one-off GUI utilities with no API, CLI, or MCP server behind them. Copilot's code-and-terminal agent work, and the broader push toward MCP-connected tools covered in Pandromeda's explainer on agent skills, has mostly assumed there's a programmatic door to walk through. Computer use is GitHub's answer for when there isn't one: it gives Copilot a way to act on anything with a screen, the same way a human operator would, click by click.

It also continues a broader pattern across the industry of AI assistants moving from "write code" toward "operate a computer" — a shift that echoes the on-device AI push behind Copilot+ PC hardware.

How it compares to Copilot's other agent modes

Computer use doesn't replace Copilot's existing agent behavior in VS Code or on GitHub.com — those remain focused on code, repositories, pull requests, and the terminal, an area Pandromeda covered in detail in its look at VS Code's Copilot coding harness update. Computer use is additive: it's a new tool available specifically inside the Copilot CLI and the standalone Copilot app, aimed at the desktop-application layer those other surfaces don't touch.

What's next

Computer use is explicitly a public preview, and GitHub's track record with Copilot previews has been to iterate quickly based on real usage before any feature moves to general availability. Expect the most visible near-term changes to be: expanded platform support (Linux is the obvious gap today), refinements to how reliably Copilot handles unusual UI states and version changes, and more detail from GitHub on exactly how availability maps to specific Copilot plans as the preview matures. For now, the most reliable way to confirm what's supported for your account is GitHub's own documentation, which it is actively keeping current during the preview.

If you want to try it, the fastest path is the GitHub Copilot CLI: install or open it, run /computer on, approve the permissions your OS asks for, and give Copilot a plain-language description of the desktop task you want handled.

Written byFelix Moreau

Felix Moreau writes Pandromeda's software coverage and how-to guides. He covers Windows, macOS and Linux updates, the apps people rely on, emulators and developer tools, and turns official documentation into clear, numbered steps that work on the current version.

More from Felix MoreauAll Software & Guides coverage