GitHub pushed its Copilot CLI and the standalone Copilot app into a new phase this month, adding a computer-use capability in public preview that lets the agent interact with graphical environments instead of only reading and writing text and files. The change, which entered public preview on October 1, 2026 in the Copilot app and CLI on macOS and Windows as part of GitHub’s October 2026 changelog cycle, arrives alongside a broader model shuffle inside Copilot and a wave of competing moves from OpenAI’s Codex CLI, Anthropic’s Claude Code, and the open-source OpenCode project. Developers searching for “GitHub Copilot CLI” this week are landing on a tool that looks meaningfully different from the one that shipped even a few months ago.
The timing matters. For most of its life, GitHub Copilot CLI operated the way the original Copilot did in the editor: it suggested commands, wrote snippets, and answered questions in a terminal window, but it never touched anything a human wasn’t already looking at. Computer use changes that boundary. An agent that can see and operate a screen can, in principle, click through a settings panel, fill out a web form, or drive a GUI-only installer without a human relaying every step by hand. That is also precisely the capability Anthropic and OpenAI have been racing to ship in their own agent products, which is why this single feature update is being read across the developer-tools industry as a signpost for where coding agents are headed next.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
What GitHub’s Computer-Use Preview Actually Does
GitHub’s own changelog describes the feature as allowing Copilot CLI and the Copilot app to interact with graphical environments rather than being limited to text generation or direct file edits. In practice, that means the agent can be pointed at tasks that live outside a code editor or terminal session, closing a gap that previously forced developers to switch back to manual control the moment a workflow touched anything with a visual interface. On macOS and Windows, the agent can read accessible or visual content, click, type, scroll, drag, and navigate workflows across desktop applications.
From Text Suggestions to Screen Control
The original pitch for GitHub Copilot, back when it launched as an editor autocomplete tool, was narrow by design: suggest the next line, let the developer accept or reject it. Agent mode broadened that into multi-file edits and task execution. Computer use is the next rung on that ladder, giving the agent a path to operate software the same way a person would, through its interface, rather than only through its API or file system. GitHub has not published a full technical breakdown of how the screen-interaction layer works, and the company has not disclosed usage limits or a general-availability timeline beyond confirming the public preview status.
Public Preview Guardrails
Public preview, in GitHub’s own terminology, means the feature is available for developers to try but is not yet guaranteed to be stable or to remain in its current form. GitHub’s official wording for the October 1, 2026 release is public preview, and teams evaluating the capability for anything beyond experimentation are, in effect, being asked to treat it as a beta. Copilot asks for approval before controlling an application, users can review or reset applications granted persistent permission, and macOS requires Accessibility and Screen Recording permissions. That caution is reasonable: an agent that can operate a graphical interface carries a different risk profile than one that only edits text, since mistakes can now extend to clicking the wrong button in a production console rather than just writing a bad line of code. For teams that have already had to lock down agent credentials after exposure incidents, computer use adds a new category of access to think about before it is turned on broadly.
The October 2026 Model Shuffle Behind the Release
Computer use did not ship in isolation. GitHub’s changelog for October 2026 also confirms that Claude Haiku 5.5, described by GitHub as Anthropic’s newest lightweight model, is now generally available across Copilot. Pairing a cheaper, faster model with a more capable agent feature is a familiar pattern: heavier agent actions, like operating a GUI step by step, tend to burn more tokens and more turns than a single code suggestion, so giving developers access to a lower-cost model to run alongside the new capability helps offset that cost at scale.
GitHub paired the new model access with a cleanup on the other end. On October 2, 2026, the company deprecated a set of older models across Copilot Chat, inline edits, ask mode, agent mode, and code completions. GitHub has not published the full list of retired model identifiers publicly beyond confirming the deprecation date, but the move follows GitHub’s established pattern of rotating out older checkpoints roughly in step with how fast the underlying model providers ship new ones.
Codex CLI Answers With Worktrees and Pinned Tasks
OpenAI’s competing terminal agent, Codex CLI, has not stood still. Version 0.162.0 added managed Git worktrees and pinned tasks, giving the command-line agent explicit support for running parallel or isolated streams of work without one task’s file changes bleeding into another’s. That is a direct answer to one of the oldest complaints about autonomous coding agents: left unsupervised, a single agent working across multiple files can step on its own branches, and worktree isolation is the standard git-native fix for that problem.
The release before it, Codex CLI 0.161.0, changed the tool’s default model to GPT-6.1 Sol and added terminal sign-in support for MCP servers, letting developers authenticate to Model Context Protocol tool servers directly from the command line rather than routing through a browser flow. Together, the two releases show OpenAI iterating on both the model layer and the plumbing that lets Codex CLI talk to external tools, which is the same two-front approach GitHub is now taking with Copilot.
Claude Code’s Model Pinning Changes the Automation Calculus
Anthropic’s own terminal agent, Claude Code, shipped version 2.1.296 with model pinning for workflow agents and the ability for subagents to compact their own context on a schedule they control rather than waiting for a parent process to trigger it. Model pinning matters more than it sounds: teams that have built automation around a specific Claude Code version do not want a silent model swap changing the behavior of a pipeline that has already been tuned and tested. Letting subagents manage their own context compaction is a smaller but related fix, aimed at the same problem computer use introduces elsewhere, which is that longer-running autonomous tasks need to manage their own state without constant supervision. The result sits in the same competitive lane as the ongoing three-way rivalry between Claude Code, Codex, and Copilot for day-to-day developer mindshare.
OpenCode’s Release Cadence Signals Open-Source Pressure
The open-source terminal agent OpenCode reached version 1.18.35 by October 9, 2026, adding signed macOS binaries along with machine-readable JSON and Markdown statistics output, plus provider fixes touching Cloudflare, Gemini, and xAI integrations. A few versions earlier, 1.18.31 and 1.18.32 added ACP session-state restoration and summarized adaptive thinking for Copilot models, along with fixes for Amazon Bedrock and Together AI. That pace, several point releases inside a single week, is notable on its own: it shows an open-source alternative shipping fixes and provider support at a rate that keeps it credible as a free alternative to the commercial agents from GitHub, OpenAI, and Anthropic, rather than falling behind as a hobby project.
How the Major Coding Agents Compare This Month
Lined up side by side, the October 2026 release cycle shows four tools converging on the same set of problems, autonomy, isolation, and model flexibility, from different starting points.
| Tool | Maker | Latest version (Oct 2026) | Headline October update |
|---|---|---|---|
| GitHub Copilot CLI / app | GitHub (Microsoft) | 1.0.102 | Computer-use capability in public preview; Claude Haiku 5.5 made generally available |
| Codex CLI | OpenAI | 0.162.0 | Managed Git worktrees and pinned tasks for parallel work |
| Claude Code | Anthropic | 2.1.296 | Model pinning for workflow agents; subagent-controlled context compaction |
| OpenCode | Open-source community | 1.18.35 | Signed macOS binaries; JSON/Markdown stats; Cloudflare, Gemini, xAI fixes |
None of these four tools are standing still, which is the real story here. GitHub Copilot CLI’s computer-use preview is the most visible single feature, but it is arriving in the same window as isolation fixes from OpenAI, scheduling changes from Anthropic, and a flurry of compatibility patches from the open-source side. Developers picking a terminal agent in October 2026 are choosing between tools that are all actively moving, not a stable incumbent against static challengers. That dynamic is also why comparison pieces like the one on Cursor, Devin Desktop, and VS Code Copilot pricing keep needing updates: the feature gaps between these tools close and reopen every few weeks.
Why Computer Use Is the Next Battleground for Developer Tools
The reason computer use is getting outsized attention compared with a typical point release is that it removes one of the last hard boundaries on what a coding agent can be asked to do. Editors, terminals, and even full Dev Container execution, all features that have shipped across the VS Code and Copilot ecosystem over the past few months, keep an agent inside environments built for automation. A browser settings page, a third-party admin console, or a GUI-only installer are not built for that. If GitHub’s preview holds up outside controlled demos, it opens the door to agents that can complete a task end to end even when part of that task lives in software nobody designed an API for.
That is also why rivals are unlikely to let the gap sit for long. Anthropic and OpenAI have both published research and product features around letting their models operate computer interfaces in the past, and the architecture choices Claude Code and Codex CLI are making right now, worktree isolation, model pinning, self-managed context compaction, read like the groundwork needed to support exactly this kind of longer, less supervised task once a computer-use layer is added on top. Whichever vendor pairs computer use with the most reliable isolation and sign-in plumbing first will likely set the pattern the rest of the market copies, in the same way agent mode itself spread quickly across competing tools once GitHub and Microsoft proved it out in VS Code.
Market Impact: Enterprise Budgets and Vendor Lock-In
For engineering leaders, the practical question is less about the novelty of computer use and more about what it does to tooling budgets and vendor relationships. Coding-agent subscriptions already sit on top of existing IDE, cloud, and model-API spend, and a feature that expands what an agent is allowed to touch tends to expand the scope of security review that goes with it. Enterprises that have standardized on GitHub Copilot for its tight integration with existing GitHub workflows now have to decide whether a preview-stage, GUI-operating agent gets turned on org-wide, restricted to a pilot group, or blocked entirely until GitHub moves it out of preview.
There is also a quieter cost dimension. Model deprecations like GitHub’s October 2 cleanup force teams that had tuned prompts or workflows around a specific retired model to re-validate behavior against whatever replaced it, including the newly generally available Claude Haiku 5.5. That re-validation work rarely shows up in a vendor’s pricing page, but it is a real recurring cost of keeping pace with a tool category that is changing this fast. Platform teams evaluating secrets handling for these tools have already had to react to real-world exposure, which is part of why guidance on securing AI agent credentials through MCP gateways has become a recurring topic rather than a one-off concern.
Historical Context: How We Got From Autocomplete to Autonomous Agents
GitHub Copilot’s evolution has moved in fairly clear stages. It started as a line-by-line autocomplete tool bolted onto the editor. The next stage added chat, letting developers ask questions about a codebase instead of only accepting suggestions. After that came agent mode, which let Copilot take a task description and make multi-file changes on its own, running inside the editor’s existing permissions. Dev Container execution extended that further, letting agents run inside a project’s own containerized environment rather than a generic sandbox, using the project’s real tools and dependencies. Computer use is the next stage in that same progression, and it is consistent with the direction every major coding-agent vendor has been pushing: less supervision per task, more surface area the agent is trusted to touch.
The pace of that progression is itself notable. VS Code shipped releases 1.136 through 1.140 across September 2026 alone, a run of updates concentrated heavily on agent and editor tooling rather than general editor features. That is a faster cadence of agent-specific change than the editor saw in comparable stretches even a year earlier, and it lines up with how quickly Codex CLI, Claude Code, and OpenCode have been pushing out their own point releases in the same window. Developers who last evaluated these tools in the spring of 2026 are, in a very literal sense, looking at different products now.
Security and Governance Questions Computer-Use Agents Raise
Every expansion of what a coding agent can do has historically come with a parallel expansion of what can go wrong, and computer use is unlikely to be an exception. An agent limited to editing files in a repository has a bounded blast radius: version control, code review, and CI gates all sit between a bad agent action and anything reaching production. An agent that can operate a graphical interface, by contrast, can potentially interact with systems that have none of those safety nets, from internal admin dashboards to third-party SaaS consoles, where a wrong click has immediate effect and no pull request to catch it first.
Beyond the per-application approval prompt, GitHub has not published detailed guidance yet on scoping what computer use is and is not allowed to touch during the public preview, which puts the burden on individual teams to set their own boundaries. That is the same lesson security teams have been absorbing from the broader rise of agentic tooling this year, including the credential-exposure incidents that pushed MCP gateway security into a mainstream concern. Teams that already built out sandboxing for agent-mode Copilot through tools covered in guides like the VS Code 1.141 Copilot agent sandbox setup are in a better position to extend that same discipline to computer use than teams turning on agent features for the first time.
October 2026 Coding-Agent Release Timeline
| Date | Event |
|---|---|
| September 2026 (ongoing) | VS Code ships releases 1.136 through 1.140, concentrated on agent and editor tooling |
| September 30, 2026 | VS Code 1.140 released |
| October 2, 2026 | GitHub deprecates older models across Copilot Chat, inline edits, ask mode, agent mode, and code completions |
| Early October 2026 | Codex CLI 0.161.0 sets GPT-6.1 Sol as default model; adds terminal MCP sign-in |
| Early-to-mid October 2026 | Codex CLI 0.162.0 adds managed Git worktrees and pinned tasks |
| October 2026 | Claude Code 2.1.296 adds model pinning and subagent-controlled context compaction |
| October 2026 | GitHub Copilot CLI and Copilot app enter public preview for computer-use capability; Claude Haiku 5.5 reaches general availability in Copilot |
| October 9, 2026 | OpenCode reaches version 1.18.35 with signed macOS binaries and JSON/Markdown stats output |
Checking version numbers is now a routine part of evaluating any of these tools, since a gap of even a few weeks can mean missing an entire capability. A quick way to confirm what is actually installed, before assuming a feature like computer use is available, is to check each tool’s reported version directly:
$ codex --version
0.162.0
$ claude --version
2.1.296
$ opencode --version
1.18.35GitHub Copilot CLI’s own version reporting varies by install method, since it ships through the Copilot app, the GitHub CLI extension, and standalone installs that update on different schedules, which is one more reason teams running it at scale have started treating version checks as a standing item in their update process rather than a one-time setup step. The check matters in practice: GitHub Changelog reports that Copilot CLI 1.0.97+ became required for custom skills, agents, and MCP-server usage metrics in October 2026.
What Developers Are Asking Before They Turn It On
Search interest around GitHub Copilot CLI has shifted noticeably toward questions about scope and safety rather than basic setup. Developers already know how to install Copilot CLI; what they are searching for now is what computer use is actually allowed to do, whether it can be scoped down to specific applications, and how it compares with the GUI-adjacent features competitors are building into Codex CLI and Claude Code. That shift mirrors a broader pattern across the agent tooling space this year, where the hardest questions are no longer “how do I use this” but “how much should I let it do,” a question teams setting up workflow automation with tools like Cursor paired with Claude Code have already had to answer for themselves.
5 Predictions for AI Coding Agents Through Early 2027
- GitHub will likely expand computer use beyond public preview with explicit scoping controls, given the enterprise security questions a screen-operating agent raises by default.
- OpenAI and Anthropic are likely to respond with their own computer-use-style features for Codex CLI and Claude Code within the next few release cycles, continuing the pattern where agent-mode features spread across all three vendors within months of each other.
- Model deprecation cycles like GitHub’s October 2 cleanup will likely become more frequent across all major coding-agent vendors as the underlying foundation models themselves ship new versions faster.
- OpenCode and other open-source agents will likely keep closing feature gaps with commercial tools quickly, given the pace of point releases seen through September and October 2026, making the open-source option a more credible default for cost-conscious teams.
- Security and governance tooling built specifically for agent permission scoping, separate from general secrets management, is likely to become a distinct product category as computer-use and GUI-operating agents move from preview into broader production use.
Frequently Asked Questions
What is computer use in GitHub Copilot CLI?
It is a public-preview capability that lets Copilot CLI and the Copilot app interact with graphical environments, rather than being limited to generating text or editing files directly.
Is GitHub Copilot CLI’s computer-use feature generally available?
No. GitHub has released it as a public preview, which the company uses to signal that a feature can be tried but is not guaranteed to be stable or final.
What model update came with the computer-use preview?
GitHub made Claude Haiku 5.5, which it describes as Anthropic’s newest lightweight model, generally available across Copilot in the same October 2026 update cycle.
Which older models did GitHub remove from Copilot?
GitHub has confirmed it deprecated older models across Copilot Chat, inline edits, ask mode, agent mode, and code completions on October 2, 2026, but has not published the full list of retired model identifiers.
How does GitHub Copilot CLI’s computer use compare with Codex CLI and Claude Code?
As of October 2026, Codex CLI and Claude Code have not shipped an equivalent public computer-use feature. Their latest updates instead focus on worktree isolation and pinned tasks for Codex CLI, and model pinning with subagent-controlled context compaction for Claude Code.
What is OpenCode, and how does it relate to GitHub Copilot CLI?
OpenCode is an open-source terminal coding agent that competes with commercial tools like Copilot CLI, Codex CLI, and Claude Code. It reached version 1.18.35 in October 2026 with signed macOS binaries and new provider fixes.
Does computer use work inside Dev Containers?
GitHub has not specified whether the computer-use preview is scoped to work alongside the Dev Container execution features added to the broader Copilot and VS Code agent tooling earlier in the September 2026 release cycle.
Should enterprise teams enable computer use now?
Given its public-preview status and the lack of published scoping or usage-limit details, most security-conscious teams are likely to pilot the feature with a small group before considering a broader rollout.
