TL;DR
- GitHub released Copilot Computer Use in public preview on October 28 at GitHub Universe. Available on macOS and Windows via GitHub Copilot CLI, the GitHub Copilot app, and VS Code. Copilot can read app content (via accessibility tree or screenshots), click controls, enter and edit text, press keys, scroll, drag, and navigate workflows across applications — including apps with no API, command-line interface, or MCP integration. Works in the background; asks for approval before controlling each app; organizations can disable it via managed settings. - The critical enterprise use case: legacy and GUI-only software. Every enterprise runs workflows in applications that have never provided an API — ERPs, bespoke internal tools, decades-old procurement systems, government portals. Computer use makes those workflows automatable for the first time without writing custom UI automation scripts. One example from GitHub's announcement: navigating an expense-report workflow in a browser. - Google DeepMind and University of Cambridge published a preprint (arXiv 2610.22603, October 15) describing a Gemini-based agentic system that found and formally verified new acceleration rules for 11 previously unanalyzed six-state Turing machines at the BB(6) frontier of the Busy Beaver problem. All 11 proofs were checked by Lean 4. The machines are called "Cryptids" — their behavior from a blank tape now has compact, exact mathematical descriptions, but whether they ever halt remains an open question. The work doesn't resolve the halting question; it characterizes the behavior in a way that makes future resolution possible. - The Busy Beaver problem is formally uncomputable. No general algorithm can determine, for every Turing machine, whether it eventually halts or runs forever. The DeepMind system chose which machines to study, looked for patterns in execution traces, proposed acceleration rules, drafted informal proofs, and then proved each rule formally in Lean 4. It did this autonomously, without a fixed problem list.
Two stories this week, each about AI operating in territory that was previously described as either practically inaccessible (legacy software without APIs) or theoretically inaccessible (formally undecidable problems).
One is immediately useful to a hundred million enterprise employees. The other is a research landmark most people will never encounter. Together they mark the same expansion: the set of things that AI agents can work on is larger this week than it was last week.
GitHub Copilot Computer Use: why legacy software is the real story
Computer use as a concept is not new. Anthropic demonstrated it with Claude Opus in October 2024. OpenAI shipped it in various Codex and Astra configurations. What GitHub Universe added on October 28 is distribution: computer use is now available to every user of GitHub Copilot, on every Copilot plan, on macOS and Windows, with no additional API access required.
GitHub has 100+ million developers as registered users. A meaningful fraction of those are on Copilot plans, and the plans themselves are available to individuals, teams, enterprises, and educational users at various price points. Computer use is now on by default in the sense that you can enable it in Settings — no separate tier, no new subscription, no different access model.
The implementation is straightforward: Copilot reads application content via the operating system's accessibility tree, which exposes the semantic structure of UI elements (buttons, text fields, menus) in a machine-readable format. When visual context is needed and the accessibility tree is insufficient — for applications that render custom UI components without accessibility annotations — it falls back to screenshots. This mirrors the approach Anthropic took with Claude's computer use: accessibility-first, visual-fallback.
The capability list: read content, click controls, enter and edit text, press keys, scroll, drag, navigate across applications. The important constraint: Copilot asks for approval before controlling each application. You can set "always allow" per app, and organizations can disable the feature entirely through managed settings. This is the same approval model Microsoft used for Guardian Agents: require human authorization before an AI agent gains control over a new application.
Why legacy and GUI-only software matters more than it sounds: the most painful and time-consuming workflows in enterprise environments are not the ones that have APIs. Every modern SaaS application has an API. The workflows that consume the most human hours are the ones in software built before APIs were standard — ERPs from the 1990s and 2000s, bespoke internal tools written in Visual Basic, government reporting portals that have never been updated, procurement systems locked into specific desktop UIs. These are the workflows where automation has always required either expensive custom RPA (robotic process automation) implementations — Selenium, AutoHotkey, UiPath — or human labor.
Copilot Computer Use makes those workflows automatable in plain English, via the same conversational interface developers already use for code generation. The instruction "Summarize the outstanding approvals in the procurement portal and paste them into the weekly report spreadsheet" describes a task that requires no programming knowledge and is now executable without any API, without any RPA script, without any MCP integration.
The limitations are real and documented: Copilot can select the wrong control, enter text in the wrong location, and struggle with non-standard or dynamic UI components. These are the same limitations that make RPA systems brittle — they break when the application's UI changes. Computer use is more adaptive than traditional RPA because it uses visual and semantic understanding rather than hardcoded element coordinates, but it is not reliable in the way that an API integration is reliable.
For IT and enterprise teams evaluating deployment: the governance question is whether you want an AI agent that can click through any desktop application your employees use, including the ones that hold sensitive data and require authenticated access. Approval-per-application is the right starting point. The organization-managed disable switch is the right enterprise control. The question is what "always allow" policies look like in practice — and whether the behavior patterns that showed up in OpenAI's misalignment tracker (agents accessing unauthorized systems, taking actions outside the scope of their instructions) manifest when an agent has desktop-level access.
DeepMind's Busy Beaver work: what the Cryptids are
The Busy Beaver problem is named for the intuitive version of the question: among all Turing machines with exactly N states that eventually halt, which one runs the longest? The answer for a given N is called the Busy Beaver number BB(N). BB(1) = 1. BB(2) = 6. BB(3) = 21. BB(4) = 107. BB(5) is known now (47 million steps). BB(6) is unknown, and its value may be astronomically large.
The reason BB(6) matters: it sits at the boundary of formal computability. Some logicians believe that resolving BB(6) is equivalent to resolving certain open problems in formal systems — specifically, that knowing BB(6) might settle questions about the consistency of mathematical axiom systems. This is not proven, but it is conjectured, and it is part of why the Busy Beaver frontier attracts serious mathematical attention.
The DeepMind and Cambridge system (Gemini 3.1 Pro plus a structured agentic pipeline) examined 1,094 six-state Turing machines whose behavior has not been characterized — the holdouts in the BB(6) frontier. It also examined 65 machines in BB(2,5) and 4 in BB(3,3). The system's task: given a Turing machine with uncharacterized behavior, find a compact mathematical rule — an acceleration rule — that describes how the machine behaves across many steps.
The pipeline: run simulations of the machine, look for patterns in the execution trace, generate conjectures about what regularity might hold, draft informal proofs, and then prove each candidate rule formally in Lean 4. The Lean proof checker verifies each logical step; if any step is missing or incorrect, the proof is rejected. This means the 11 results are not dependent on trusting Gemini's output — they are independently checkable.
The 11 machines are called "Cryptids" — a provisional name from the authors, pending acceptance by the Busy Beaver community. Their behavior from a blank tape now has exact, compact descriptions. Whether they ever halt is still unknown. The paper does not resolve the halting question; it gives the mathematical groundwork that any future resolution would need.
The system works on a problem that has no fixed problem list. The Busy Beaver frontier is, by definition, the set of machines that nobody knows how to analyze. The agent had to choose which of the 1,094 holdouts to examine, develop conjectures autonomously, and prove them in a formal system. It is operating at the boundary of what is mathematically tractable.
This is a different kind of mathematical AI work than OpenAI's 722 manuscripts. Those were presented as produced by an unreleased model, published to GitHub without prior peer review, and contested by the academic community for their publication method. The DeepMind Busy Beaver work was posted as a preprint with full Lean 4 proofs available in the `google-deepmind/cryptids` repository — every proof artifact is public and machine-checkable. The academic community cannot dispute the proof correctness; they can only dispute whether the results are significant enough to be called Cryptids.
What both stories mean for the same week
GitHub Copilot Computer Use is AI operating on the practical frontier — the millions of enterprise workflows that API-based automation has never reached. It is immediately usable, imperfect, and governed by a relatively thin approval layer.
The Busy Beaver work is AI operating on the formal frontier — problems that are provably undecidable in general, but where specific instances can be characterized with enough persistence and the right mathematical tools. The formal verification requirement means the results are reliable in a way that most AI outputs are not.
The common thread: in both cases, the AI agent chose where to focus, took actions that weren't predetermined, and produced outputs that required verification — human approval for computer use, formal proof checking for Busy Beaver. Neither system was autonomous in the sense of operating without oversight. Both systems extended what was previously reachable.



