Assign a GitHub issue to Copilot and, within a minute, GitHub's coding agent clones your repository into an ephemeral sandbox powered by GitHub Actions, plans the change, writes code, runs your tests, and opens a draft pull request with you on the review line. It ships with every paid Copilot plan, from the $10/month Pro tier through Enterprise, which makes it the lowest-friction asynchronous coding agent you can try in 2026. It's also narrower than the launch demos suggest. This review covers how it works, what it costs after GitHub's June 2026 move to usage-based AI Credits, where it's strong, and where per-issue assignment stops scaling.
One disclosure before the details: we build Codowave, a backlog-native agent that competes with part of what Copilot's agent does. The last section covers that difference directly. Everything before it is drawn from GitHub's own documentation and our team's production use, with sources linked.
How the Copilot coding agent works
GitHub announced the coding agent in May 2025 as the async counterpart to Copilot's in-editor agent mode. In April 2026 it was folded into "Copilot cloud agent", which added research and planning modes, but the core loop is unchanged: you hand it a unit of work, it disappears into a sandbox, and it comes back with a draft PR.
The sandbox is the interesting part. Per GitHub's documentation, each session runs in an ephemeral development environment powered by GitHub Actions. Inside it, the agent explores the codebase, edits files, and runs your tests and linters before pushing commits. You can watch the session log live or read it afterward, and every commit is co-authored so the provenance is never ambiguous.
The guardrails are conservative by design, and mostly good. A session works on one repository and one branch, produces one PR, and can't bypass your branch protection rules. CI workflows on the agent's pull requests don't run until a human approves them, so the agent can't burn your deploy pipeline on unreviewed code. Sessions are also time-boxed to just under an hour, which caps how far a bad plan can run.
How to assign a GitHub issue to Copilot
The headline path is the one in the name: open an issue, and in the assignees field pick Copilot the way you'd pick a teammate. The agent reacts to the issue, starts a session, and links a draft PR back to the issue as it works.
That's not the only entry point. You can also start the agent from the agents
panel on github.com, mention @copilot in a pull request comment to request
follow-up changes, or delegate a task from VS Code or GitHub Mobile. Business
and Enterprise organizations have to enable the agent in admin settings
before any of this appears.
Iteration happens where review already happens. Leave a PR review comment,
mention @copilot, and the agent starts a new session to address it. Teams
that get good results treat the issue body as a spec: acceptance criteria,
file pointers, and constraints. Two repo-level files do a lot of work here —
.github/copilot-instructions.md for conventions, and a
copilot-setup-steps.yml workflow that pre-installs dependencies so the
agent's environment matches yours.
What the coding agent costs in 2026
The agent is included in every paid Copilot plan: Pro at $10/month, Pro+ at $39/month, and the Business and Enterprise seats. Copilot Free doesn't include it. That "included" carries an asterisk, though, because the agent draws on two meters beyond the subscription.
The first meter is model usage. Through mid-2026 this was counted in premium requests, but GitHub moved Copilot to usage-based billing on June 1, 2026: premium requests were replaced by GitHub AI Credits, consumed by actual token usage — input, output, and cached — at each model's published API rates. Each plan includes monthly credits equal to its sticker price ($10 on Pro, $39 on Pro+), and usage beyond that is billed as overage.
The second meter is GitHub Actions minutes. The sandbox is an Actions runner, so every session draws from the same minutes pool as your CI, and long agent sessions on private repos are not free compute.
The practical consequence: your bill now tracks how hard your tasks turn out to be, not how many you assigned. A gnarly issue that sends the agent through long exploration and repeated test runs consumes credits accordingly. After the June change, heavy agentic users publicly reported monthly costs landing well above the old flat rate — which is fine if you budget for it, and a surprise if you don't.
The subscription buys you access. The credits and the Actions minutes buy each unit of work, and nobody caps a unit of work for you.
Where it shines
The integration is the product, and it's excellent. If your team lives on GitHub, the agent requires zero new tools: work arrives as issues, output arrives as draft PRs, iteration happens in review comments, and the audit trail is the session log. For a company that already pays for Copilot, the procurement conversation is already over.
It's genuinely good at well-scoped, single-repo tasks. Bug fixes with clear reproduction steps, test coverage gaps, documentation, dependency-adjacent chores, and small features with named files — this is the envelope where draft PRs come back mergeable with light review.
It rewards well-tested repositories. The agent validates its own work by running your suite inside the sandbox, so a repo with meaningful tests gets a meaningfully self-checked PR. A repo with thin tests gets a PR that compiles. GitHub says this plainly in its own guidance, and our experience matches.
The security posture deserves credit too. Draft-only PRs, human-approved CI, enforced branch protections, and co-authored commits are the right defaults for letting an agent loose on production repositories.
Where it strains
Every task needs a human dispatcher. The agent never decides what to work on — someone triages the backlog, scopes each issue, and assigns it, one at a time. For five issues a week that's no overhead at all. For a backlog of forty, the triage-and-assign loop becomes the bottleneck the agent was supposed to remove: you've automated the coding and kept the project management.
Cost is open-ended per task. Token-metered credits plus Actions minutes mean there's no per-task dollar ceiling you can set in advance; the spend on a hard issue is discovered after the fact. Engineering leads who need a number finance can pre-approve have to build that discipline around the tool.
The envelope is one repo, one branch, under an hour. Cross-repo changes mean multiple assignments and manual coordination, and work that doesn't fit in a session gets split by you, not by the agent.
And it's GitHub-shaped all the way down. The models are GitHub-managed with no bring-your-own-key option, and if half your backlog lives in Jira or Linear, the agent can't see it.
Copilot coding agent vs backlog-native agents
Both categories end in the same artifact — a PR a human reviews — but they automate different halves of the job. Copilot automates execution and leaves selection to you. A backlog-native agent like Codowave automates selection too: it reads the tracker, scores open issues against your filters, picks work, and ships PRs without a per-issue dispatch step.
| Copilot coding agent | Codowave | |
|---|---|---|
| Trigger | Human assigns each issue | Agent selects from backlog filters |
| Trackers | GitHub Issues and PRs | GitHub Issues, Jira, Linear, Trello |
| Runs in | GitHub Actions sandbox | Isolated container per task |
| Billing | Plan + AI Credits + Actions minutes | Flat monthly plan, hard issue quota |
| Model | GitHub-managed | BYOK Anthropic Claude |
| Safety ramp | Draft PRs, CI approval gate | Watch-only by default, then graduated auto-merge |
The honest trade runs both ways. Copilot's agent needs no new vendor, no new review surface, and no trust decision beyond the one you made buying Copilot. A backlog agent asks you to connect a third-party app and grant repo access — in exchange for the selection loop, a flat bill with a hard monthly issue quota and capped BYOK model spend, and a watch-only default while it earns auto-merge. If your bottleneck is typing speed on tasks you've already picked, Copilot's model fits. If your bottleneck is the forty issues nobody has picked, the dispatcher is the part that needed automating.
The verdict
The Copilot coding agent is the easiest recommendation in the async category for teams already paying for Copilot: assign one well-written issue on a well-tested repo this week and judge the draft PR yourself, because the marginal cost of trying is a few credits. Treat it as a very fast junior who does exactly one ticket at a time, never picks up the next one unprompted, and bills by the token. Whether that's a review or a warning depends entirely on which half of the job — the coding or the choosing — was eating your week.