GH-700 study guide: Human-in-the-loop for agents

GH-700 · Perform human-in-the-loop tasks for agentic workflows (20–25% of the exam)

"Perform human-in-the-loop tasks for agentic workflows" is skill area 4 of GH-700 and carries 20–25% of the exam. Human-in-the-loop means a person reviews, approves or redirects an agent's work at set points, instead of letting it run unchecked. The exam tests where those points are, which control sits on which GitHub surface (the place you use Copilot: GitHub.com, Copilot CLI, VS Code or the Copilot app), and what happens when you approve, reject, steer or stop an agent.

Now you can get Claude Certified and earn OpenAI badges and certifications too Here's how

What the official study guide covers

The guide lists ten lines under three headings: design human review and validation practices, interact with agentic workflows, and supervise and monitor agentic workflows.

What the guide lists	What it means in practice
Identify critical decision points where human judgment is required	Know where a person must decide
Choose how the agent will perform work, including interactive, plan, and autopilot modes	Decide how often the agent waits for you
Design and configure escalation paths based on tool usage	Decide which tools run freely, ask first or are refused
Respond to requests for interaction from agentic workflows, including approvals, rejections, or revisions	Answer prompts, reviews and suggestions correctly
Interact with an agentic workflow while it is running	Redirect a session without restarting it
Interact with agentic workflows to resolve failures	Read the logs, fix the cause, run again
Stop an agentic workflow that is running	Use each surface's stop control
Ensure that agentic workflows meet requirements	Check output against the acceptance criteria
Review agentic workflow outputs	Review pull requests, diffs and issue changes
Monitor agentic workflow runs	Track sessions, run status, tokens and cost

Where GitHub puts a person in the loop

Some decision points are built in; others you add.

Decision point	What GitHub does
Merging a Copilot cloud agent pull request	The pull request is a draft (marked as not ready to merge). The agent cannot approve or merge it, and the person who asked for it cannot approve it
Running GitHub Actions workflows on that pull request	By default, nothing runs until a user with write access clicks Approve and run workflows
A GitHub Agentic Workflows (gh-aw) change to protected files	Changes to files that control how things run, such as dependency lists, agent instructions or anything in `.github/`, open with a review already attached that asks for changes, so a person must approve before merge
A job that targets a GitHub environment (a named deployment target such as production) that has required reviewers set	The job waits until a reviewer approves or rejects it
Issue changes made by an automation	Changes rated below the repository's automation level wait as suggestions

Each repository has an automation level (Full control, Cautious, Balanced or Full automation) that sets which issue changes an automation applies by itself. Full control holds every change for a person; Cautious, the default, applies only high-confidence changes automatically.

For other steps, add a person when the step is hard to undo (deleting, publishing, deploying), changes how future runs behave (workflow files, dependency lists, agent instructions), or needs business judgement such as priority.

Interactive, plan and autopilot modes

These modes exist in Copilot CLI, the command-line tool, and in the GitHub Copilot app. Copilot cloud agent has no mode picker; you get a similar effect by asking it to research or plan before it changes code.

Mode	How the agent works	Use it when
Interactive	Waits for your input before it continues	You are exploring or expect many decisions
Plan	Asks questions and writes a plan for you to approve before coding	You want to check the approach first
Autopilot	Writes code, runs tests and iterates without waiting	The outcome and the checks are clear

For complex work GitHub suggests plan, then autopilot: in Copilot CLI, select Accept plan and continue in Autopilot execution mode once the plan is right.

Autopilot does not grant permissions. Autopilot decides whether the agent continues without a new prompt; permissions decide which tools run without asking. If you enter autopilot with "Use Manual Approval for this session", Copilot denies tool requests that need approval, so the task may not finish.
copilot --plan --mode autopilot skips the plan review. It moves to autopilot as soon as the plan is ready.
You can cap the run with --max-autopilot-continues (how many times the agent may carry on by itself), or set a soft AI credit limit with /limits.

Designing escalation paths based on tool usage

An escalation path is what happens when the agent wants a tool: it runs, asks a person, or is refused.

In Copilot CLI, a tool prompt offers "Yes" (this time only), "Yes, and approve TOOL for the rest of the running session", or "No, and tell Copilot what to do differently". To decide in advance, start the CLI with allow and deny patterns. This lets the agent run any git command but never git push, the command that sends changes to GitHub:

copilot --allow-tool='shell(git:*)' --deny-tool='shell(git push)'

On cloud agent, a custom agent's tools list and an automation's selected tools set what the agent can do at all. In gh-aw, the frontmatter (the settings block at the top of the workflow's Markdown file) lists the tools. The agent runs read-only, and every write goes through a safe output: a declared action, such as creating an issue, that a separate job performs afterwards. The protected-files setting decides what happens when a pull request touches a protected file:

Policy	Result
`request-review` (default)	The pull request is created with a "request changes" review; a human must approve before merge
`blocked`	The safe output fails with an error
`fallback-to-issue`	Nothing is pushed; a review issue tells a human how to apply or reject the change
`allowed`	No restriction

To require approval before a gh-aw workflow runs at all, add manual-approval: production under on:, where production is an environment with required reviewers.

GitHub calls approvals for issue changes "a workflow convenience, not a security control", so to guarantee an agent cannot take an action, remove the tool or the permission.

Responding to approvals, rejections and revisions

Request	To approve	To reject or revise
Copilot CLI tool prompt	"Yes", or approve the tool for the session	"No, and tell Copilot what to do differently", then say what to do instead
Cloud agent pull request	Another reviewer approves; the requester's approval does not count	Mention `@copilot` in a comment, or push commits to the branch
GitHub Actions environment review	Approve and deploy; the job continues and can use the environment's secrets	Reject; the workflow fails
Issue suggestions panel	Accept or Accept all; the change applies at once	Decline or Decline all; the issue is unchanged

Steering a running agent and resolving failures

To steer Copilot cloud agent, open the session on the agents page and type below the session log. Copilot applies your message after its current tool call. Each steering message uses AI credits, and third-party coding agents cannot be steered. In Copilot CLI you can send or queue (Ctrl+Enter) follow-up messages while the agent works. Steer when the direction is mostly right; stop when the work is not wanted.

To resolve a failure, start from the evidence: a failed gh-aw run posts a failure issue or comment, and gh aw audit with the run URL shows the failure cause, tool use, network access and cost. Fix the Markdown file, recompile it and commit both files. For cloud agent, the session log shows the agent's reasoning, tools and test runs.

Which surface has which control

Choosing a mode, controlling tools and steering

Surface	Choose mode	Control tool use	Steer while running
Copilot CLI	Shift+Tab	Tool prompt; `--allow-tool`, `--deny-tool`	Follow-up or queued messages
GitHub Copilot app	Dropdown below the prompt	`/allow-all-tools`, `/reset-allowed-tools`; choose to run in a cloud or local sandbox (an isolated workspace)	Prompt in the session
Copilot cloud agent	No modes; ask for a plan in the prompt	`tools` list in a custom agent	Prompt box below the session log
Copilot automations	Not applicable	Tools selected for the automation	Open the session it starts to follow it
GitHub Agentic Workflows	Not applicable	`tools:`, safe outputs, `protected-files`	Edit, compile, run again

Stopping, reviewing and monitoring

Surface	Stop	Review and monitor
Copilot CLI	Esc twice stops what it is doing now	`/diff` shows every changed file; then run your own checks
GitHub Copilot app	Not covered in the current docs	Session list; `/security-review`
Copilot cloud agent	Stop session ends the Actions run and keeps pushed commits	Session log with token use, linked from each commit
Copilot automations	Disable the automation	Approvals panel on issues
GitHub Agentic Workflows	Cancel workflow for one run; `gh aw disable` disables it and cancels in-progress runs	`gh aw status`, `gh aw logs`, `gh aw audit`

Stopping never undoes work already done.

Rules that decide exam answers

How far the agent continues alone is a mode; which tools run without asking is a permission.
The three modes belong to Copilot CLI and the Copilot app, not cloud agent.
If someone must sign off on the plan, do not use --plan --mode autopilot; it skips that review.
Approving a tool for the rest of the session approves every use of that tool.
To guarantee an agent cannot act, remove the tool or permission; approval panels are not a boundary.
Changes to workflows, dependency files and agent instructions need human review; gh-aw requests it by default.
Cancel one gh-aw run in Actions; gh aw disable stops the workflow running again.

Two sample questions

These are original Timo practice questions, not official exam questions.

Question 1

In Copilot CLI, Copilot asks a project manager to run rm ./drafts/old-notes.md, and she selects "Yes, and approve rm for the rest of the running session". What has she allowed?

A. Copilot may skip asking her only when it deletes old-notes.md during this session.B. Copilot may run any rm command without asking her until this session ends.C. Copilot may run rm without asking in this session and in later sessions in the repository.D. Copilot may skip asking her only when it deletes files in the drafts folder this session.

Answer: B. This option lets Copilot use the tool "in any way it thinks is appropriate" for the rest of the running session, so one approved rm command allows any rm command. A and D are wrong because the approval covers the whole tool, not one file or folder. C is wrong because Copilot asks again in new sessions and when you resume this one.

Question 2

A team's Copilot automation triages new issues, and the security lead says it must never close one. The team plans to set the automation level to Full control so every change waits for review. Why is this not enough, and what should they do?

A. Full control covers labels only, so they should also forbid closing issues in the prompt.B. Approvals are not a server-side boundary, so they should not grant the issue-closing tool.C. The automation level applies to pull requests only, so they should add a branch protection rule.D. Full control holds only low-confidence changes, so they should choose the Cautious level instead.

Answer: B. GitHub says approvals are "a workflow convenience, not a security control": an agent with permission to change issues can apply changes directly, so the guarantee must come from the tools and permissions the automation gets. A is wrong because Full control also covers closing, and a prompt instruction is not a guarantee. C is wrong because the automation level governs issue changes, not pull requests. D is wrong because Full control holds every change, while Cautious applies high-confidence changes automatically.

Build exercise

You need Copilot CLI and a free test repository with a short README.md.

Clone (copy) the repository to your computer, run copilot inside it, and confirm that you trust the folder.
Press Shift+Tab until the status line shows Plan mode. Ask: "Add a CONTRIBUTING.md with three short sections and link to it from README.md." Answer its questions, then ask for one change to the plan.
Select Accept plan and continue in Autopilot execution mode and choose "Use Manual Approval for this session". Any tool request that would need your approval is denied automatically, so the task may stop short of the full change.
Press Esc twice to interrupt. In interactive mode, repeat the request and answer a tool prompt with "No, and tell Copilot what to do differently" plus an instruction. It should change its approach.
Run /diff and review every changed file before you commit.

Practise this topic

Start with the free GH-700 practice test. The GH-700 practice tests add 200 questions with four timed 50-question mocks (US$15), and the GH-700 prep material has one module per skill area with guided labs (US$15); both together cost US$25. See GH-700 practice tests and prep material, or the GH-700 exam guide for the whole exam.

Now you can get Claude Certified and earn OpenAI badges and certifications too

Register for all four Claude certification exams through Amotion AI, which is Certified in the Claude Partner Network. Claude Certified Associate covers business and knowledge work, not coding.
Take 11 OpenAI PartnerU learning programs with assessments and course-completion certificates, and work towards the expert badges for ChatGPT, Codex and APIs.
Practise with 20 full-length Claude mock exams.

Join Timo for Claude and OpenAI certifications

Sources

Independent Timo practice material. Not affiliated with or endorsed by GitHub or Microsoft.