GitHub Copilot's Autonomous Agents Break Out of the IDE: Cloud Agent Goes GA for Linear

GitHub Copilot Cloud Agent Extends Beyond GitHub to Linear

When Copilot arrived, it finished your sentences inside the editor. Now it finishes your tickets from someone else's app.

The Copilot cloud agent, GitHub's autonomous coding worker that operates without a developer at the keyboard, is now generally available for Linear 1. Assign a Linear issue to Copilot and it spins up its own ephemeral development environment, writes code, opens a draft pull request, streams progress back to your Linear activity timeline, and requests review when the work is complete 1.

For builders, the signal is bigger than any single integration. The tools that manage your work are starting to do the work.

The trajectory is the story

GitHub's own documentation draws a line between two modes of AI-assisted coding. Agent mode in the IDE makes autonomous edits directly in a developer's local environment. Copilot cloud agent works independently in a GitHub Actions-powered environment, where it can research a repository, create implementation plans, fix bugs, implement features, improve test coverage, and resolve merge conflicts 2. One sits next to you. The other works while you do something else.

The Linear integration extends that second mode beyond GitHub's own walls. Previously, you triggered the cloud agent from GitHub Issues, GitHub Copilot Chat, or a pull request comment 2. With Linear GA, tasks created in a third-party tool can dispatch autonomous engineering capacity. GitHub's documentation lists additional integrations with Azure Boards, JIRA, Slack, and Teams alongside Linear 2, pointing Copilot toward a future as a platform-agnostic engineering resource rather than an editor plugin.

One constraint is worth noting. From third-party integrations including Linear, the cloud agent goes straight to creating a pull request. The deeper research, planning, and iteration cycle available on GitHub.com does not carry over to external tools 2. Linear users get autonomous coding and draft PRs, but not the exploratory pre-PR phase that GitHub.com offers.

The controls that make autonomous viable

The GA release ships with controls that answer the obvious question: how do you trust an autonomous agent with production code?

Developers can pick which model Copilot uses for a given task, point it at custom agent configurations built for specific team workflows, set target and working branches, and steer an active session by mentioning Copilot in a Linear comment mid-flight 1. Settings can be applied per issue or standardized across a workspace or team through Linear agent guidance 1.

The custom agents feature is where this gets practical. GitHub's documentation describes specialized agents for frontend development, documentation, and test generation, each configurable with task-specific prompts and tools 2. A team is not deploying one generic bot. It is assembling a roster of role-specific workers.

Session steering matters because it preserves the one thing fully autonomous systems tend to erase: human judgment at the point where it is most useful. You can redirect the agent while it works instead of waiting for a take-it-or-leave-it pull request at the end.

Who gets it

Copilot cloud agent is available across Pro, Pro+, Business, and Enterprise plans 1. Setup requires installing the GitHub Copilot for Linear app from the GitHub Marketplace, with organization owner permissions in GitHub and workspace admin privileges in Linear 1. Enterprise administrators can track adoption through Copilot usage metrics, including pull request counts, merge rates, and median time to merge for agent-created PRs 2.

What this changes

The locus of control has been migrating for years. Copilot started as a suggestion engine inside the editor. Agent mode moved it toward autonomous action, still anchored to a developer's local machine. The cloud agent detached it from any single developer's session entirely. The Linear integration detaches it from GitHub itself.

The work product has shifted just as far: from suggested lines of code to completed, reviewable pull requests filed from a project management tool that does not belong to GitHub. For teams living in Linear, their issue tracker can now hand work to an autonomous engineer. For everyone watching the broader space, the boundary between project management and project execution is starting to close.