The Cloud Agent

Copilot’s async background developer. You assign a GitHub issue before lunch; by the time you’re back, there’s a pull request waiting.

Agent mode vs. the cloud agent — the crucial distinction

☺ Like you’re 10: Agent mode is a helper who builds a LEGO set right next to you while you watch and hand them pieces; the cloud agent is a helper who takes the box to their own room, builds the whole thing alone, and brings it back for you to check later.

These get confused constantly. The difference is where the work happens and whether you wait for it:

The issue-to-PR workflow

☺ Like you’re 10: You write a chore on a sticky note (the issue) and stick it on the helper’s door; they do the whole chore in their room, then leave the finished work on the table with a note asking “Is this okay?” (the pull request) so you can say yes or ask for a change.

1. Create or pick a GitHub issue describing the task — like a ticket for a teammate: clear acceptance criteria, references to relevant files or patterns.
2. Assign it to Copilot (select “Copilot” as the assignee) or comment @Copilot implement this. You can also kick off a task from the Agents panel on GitHub.com, or from Copilot Chat.
3. It works autonomously in a sandboxed Actions environment: researches the repo, forms a plan, makes changes on a branch, writes commit messages, pushes, and runs your tests.
4. It opens a draft pull request and requests your review.
5. You review and iterate. Look at the branch diff. Leave PR comments with adjustments — the agent picks up your feedback and revises, just like a human contributor.

Everything happens as commits viewable in logs, so there’s a transparent trail of what it tried and validated. That auditability is what makes delegating to an agent safe for a team.

What lands in the PR

☺ Like you’re 10: Think of the finished work coming back like a school report with the pages neatly labeled — here’s what I added, here’s the test I ran to make sure it works, and here’s a short list of exactly what changed — so you can flip through and check it fast.

Concretely, assign an issue like “Add a /health endpoint returning {status:'ok'}, with a test” and the draft PR waiting for you looks like:

Draft PR #214  "Add /health endpoint"        branch: copilot/health-endpoint
  3 commits
     - add GET /health route
     - add health.test.js
     - handle missing-config case   (self-review follow-up)
  Files changed (2): routes/health.js, test/health.test.js
  checks: tests passing in Actions   security scan clean
  Copilot self-review: "simplified the handler; added a test for the error path"

You review the diff and the commit trail like any teammate’s PR — then merge, or leave a comment (“also return uptime”) and the agent revises on the same branch.

The safety net: model picker, self-review, security scanning

☺ Like you’re 10: Before the helper hands you their homework, they proofread it themselves, fix their own mistakes, and run it past a safety checker — like checking your bike’s brakes before riding — so most problems are already caught before you even look.

• Model picker. The Agents panel lets you choose the model per task — stronger for harder work, faster for routine jobs, or Auto.
• Self-review. Before opening the PR, the agent reviews its own changes using Copilot code review, gets feedback, and improves the patch. By the time you’re tagged, it has already cleaned up obvious issues — even catching its own overly-complex code and simplifying it.
• Built-in security scanning. The output is scanned for security problems before it reaches you.
• CLI handoff. Start a task in the terminal and continue it in the cloud, or vice versa — the session carries context across surfaces.

Making the cloud agent smarter about your repo

☺ Like you’re 10: It’s like giving your helper the house rules written on the fridge and letting them remember things they learned last time — so instead of guessing, they already know how your family likes chores done.

The more the agent knows about your codebase, conventions, and tools, the better it performs. Two levers (covered in Customizing Copilot): custom instructions — natural-language statements stored as files in the repo — and Copilot Memory, which (on higher tiers) stores useful details it figures out about a repo and reuses them in later sessions. Prune stale memories periodically; outdated “facts” hurt.