Agent - hand off the whole task

Some tasks are bigger than a list of files. Building an approval workflow inside an order service means the endpoint needs a threshold check, the order model needs a new state, an approval action needs a handler, audit events need wiring, and tests need updating - and the exact file list is part of what the work discovers. For that shape of task, Copilot’s Agent role lets you hand over the goal instead of the steps.

The loop you are delegating to

Agent is the autonomous entry in the agents dropdown - the role picker in the Chat view. You give it a goal, and it runs the loop you would have run by hand: plan an approach, edit across the files it decides are relevant, run commands and tests, read the results, and fix what failed - repeating until it judges the task done. It scopes itself; where a scoped edit works inside files you named, Agent decides which files matter.

Two facts about how it handles your control are worth knowing before you hand anything over:

• It works through the task continuously, rather than stopping at one proposed diff the way a one-shot edit request does; whether each edit applies immediately or pauses for a yes is set by your permission level - the next fact. Either way, your review of the full change comes at the end: you read the whole set of changes once it finishes, not keystroke by keystroke.
• What it may run without asking is governed by your permission level - control made concrete: what happens before you look. At the manual default, potentially destructive actions - file edits, terminal commands, and external tool calls - are held for your confirmation; looser levels let more through (as of September 2026; the approvals documentation tracks the default). That dial is consequential enough to have its own chapter - Permissions - and nothing here requires you to set it in advance.

Give the goal, not the steps

With Agent selected, describe the outcome the way you would brief a colleague who could be trusted to find the details. This lesson works the service side of the scenario this chapter follows - orders-service, the course’s illustrative order-management API your squad owns - and assumes the library side has already landed: shared-lib, the internal library a dozen services import, now has the threshold check and the approval-requested event. Agreeing that library change’s approach before any code exists is the next lesson, Plan; on a real task it comes first. With the helpers in place, the request can stay at the level of the goal:

Implement the large-order approval workflow. Orders at or above the approval threshold should enter an “awaiting approval” state instead of being fulfilled, expose an action for a second user to approve them, and record an approval-requested audit event using the shared library. Update the tests.

Then watch it work. It lays out a plan, edits across the endpoint, the state model, the handler, and the tests, runs the suite, and reacts to failures - fixing its own mistakes without you pointing at each one. The first time you watch a multi-file change drive itself to green, it genuinely feels like a different tool from the autocomplete you may know Copilot as.

The posture: in the loop, not on the keystrokes

The trap with a capable agent is that its competence invites you to stop paying attention. The counter-trap is reviewing every keystroke, which wastes the handoff. The workable posture sits between:

• Read the confirmation prompts. When it pauses before running something consequential, read what it wants to run. That prompt is your live checkpoint, not a dialog to dismiss.
• Review the whole change at the end, as one diff. When it declares done, read everything it touched in one pass. “The tests pass” is necessary, not sufficient; tests it wrote itself can pass for the wrong reason.
• Steer with words when it drifts. If it is heading somewhere you do not like, say so in the conversation and it re-plans. You are not committed to its first approach.

Try it

Give Agent a task in a repo you own that touches two or three files - add a field to a response and update the matching test. Watch it plan, apply, and verify without you pointing at each file, and notice where it pauses for confirmation. On the default permission level, that pause is your live checkpoint while it runs; on a looser level the pauses move to your final diff review, so read that diff harder.

Agent earns its autonomy on well-scoped work in code you can afford to iterate on - a feature in your own service, not a redesign of a library other teams import. And notice the assumption inside “give it the goal and watch it go”: you trusted it to choose the approach. On work where the approach itself is the risk, you want to see and approve the approach before any code exists. That is what Plan is for. Next: Plan - see the plan first.