Try each one before opening the answer. Every option is explained, with the GitHub documentation page that proves it.
Question 1 · choose 1
In VS Code, a developer picks Plan from the agents dropdown and describes a refactor. A colleague asks what the agent has done to the codebase by the time the plan appears in chat. What is the accurate answer?
AIt created a scratch branch and tried each step there to check that the plan works
BIt researched using read-only tools and drafted steps with open questions; no code changed
CIt ran the test suite first to find out which steps the plan needs
DIt opened a draft pull request that holds the plan, so reviewers can comment before work starts
Show the answer and why
AIt created a scratch branch and tried each step there to check that the plan works
Incorrect
The plan agent doesn't edit code or create branches; it researches and drafts a plan.
BIt researched using read-only tools and drafted steps with open questions; no code changed
Correct
The plan agent researches with read-only tools and makes no code changes until you review and approve the plan.
CIt ran the test suite first to find out which steps the plan needs
Incorrect
Running commands is agent-mode work; the plan agent researches with read-only tools.
DIt opened a draft pull request that holds the plan, so reviewers can comment before work starts
Incorrect
The plan is presented in the chat view for you to iterate on; nothing is pushed or opened as a pull request.
The plan agent researches the task with read-only tools and codebase analysis, breaks it into actionable steps, includes open questions about ambiguous requirements and presents a plan draft in a standard format. It makes no code changes until you review and approve the plan.
A platform team scripts Copilot CLI to plan and then implement changes in a regulated repository, where a person must approve every plan before any code is written. The draft script runs copilot --plan --mode autopilot. Why does this script break the team's rule?
AIt skips planning entirely, because --mode autopilot overrides --plan
BIt also needs --yolo, or Autopilot can't run any tool after planning
CIt only runs inside GitHub Actions, where plans are approved through environment reviewers
DIt continues into Autopilot as soon as the plan is ready, without waiting for a person's sign-off
Show the answer and why
AIt skips planning entirely, because --mode autopilot overrides --plan
Incorrect
The command plans first; the problem is that it moves on to Autopilot without an approval step.
BIt also needs --yolo, or Autopilot can't run any tool after planning
Incorrect
Tool access isn't what breaks the rule here; the missing plan approval is.
CIt only runs inside GitHub Actions, where plans are approved through environment reviewers
Incorrect
The command runs wherever the CLI runs and has no link to Actions environment approvals.
DIt continues into Autopilot as soon as the plan is ready, without waiting for a person's sign-off
Correct
This command moves from planning to Autopilot automatically and does not wait for interactive plan approval.
copilot --plan --mode autopilot starts a plan-then-Autopilot session that switches to Autopilot automatically when the plan is ready; it doesn't wait for interactive plan approval. To keep a human approval, plan interactively in Plan mode, review and revise the plan, and only then accept it and continue in Autopilot.
Before letting Copilot CLI implement a risky migration plan, a developer asks the rubber duck agent to critique it. Which statements describe how that agent works? (Choose TWO.)
AIt is consulted automatically after every plan unless you switch it off
BIt runs on a model from a different family than the one driving the session
CIt flags style, naming and formatting problems alongside functional ones
DIt can read the code with exploration tools but can't edit files or change the environment
EIt reruns the session's own model with a higher reasoning effort
Show the answer and why
AIt is consulted automatically after every plan unless you switch it off
Incorrect
By default it is not invoked automatically; you ask for a critique each time unless you change the default.
BIt runs on a model from a different family than the one driving the session
Correct
Copilot picks a critic model that contrasts with the session model, so the critic is less likely to share the same blind spots.
CIt flags style, naming and formatting problems alongside functional ones
Incorrect
It is configured not to comment on style, formatting, naming or minor refactors.
DIt can read the code with exploration tools but can't edit files or change the environment
Correct
The rubber duck agent has read-only access and returns a critique; the main agent decides what to do with it.
EIt reruns the session's own model with a higher reasoning effort
Incorrect
It deliberately uses a different model, not the same model with more reasoning.
The rubber duck agent in Copilot CLI and the GitHub Copilot app is a constructive critic for plans, code and tests. It runs on a model from a different family than the session model, has read-only access through the standard exploration tools, sorts its findings into blocking issues, non-blocking issues and suggestions, and leaves out style comments. The main agent then decides how to use the critique.
In the GitHub Copilot app, a developer wants the agent to propose its approach and wait for their approval before it changes anything. Which session mode should they pick?
AAutopilot
BInteractive with a cloud sandbox
CChats
DPlan
Show the answer and why
AAutopilot
Incorrect
Autopilot works fully autonomously without waiting for input.
BInteractive with a cloud sandbox
Incorrect
Interactive mode suggests changes and waits for input step by step; a sandbox changes where it runs, not when it plans.
CChats
Incorrect
Chats is a conversation area without a dedicated branch or worktree, not a session mode for planning work.
DPlan
Correct
In Plan mode the agent creates a plan first, and you review and approve it before the agent executes it.
The session mode in the GitHub Copilot app controls how much autonomy the agent has. Interactive means you and the agent work together step by step; Plan means the agent creates a plan first and you review and approve it before it executes; Autopilot means the agent works fully autonomously. You can change the mode at any time.
A developer opens Copilot Chat on GitHub.com, attaches a repository as context and asks how its caching layer works. What does Copilot do before it researches the repository in depth?
AIt opens a pull request containing its findings
BIt asks the developer to approve a deep research session
CIt hands the question to Copilot code review
DIt waits for a copilot-setup-steps.yml on the default branch
Show the answer and why
AIt opens a pull request containing its findings
Incorrect
Research sessions answer questions; they don't open pull requests.
BIt asks the developer to approve a deep research session
Correct
With a repository attached in Copilot Chat, Copilot prompts you to approve a deep research session.
CIt hands the question to Copilot code review
Incorrect
Code review reviews pull requests; it isn't used for research questions.
DIt waits for a copilot-setup-steps.yml on the default branch
Incorrect
Setup steps customize the agent's environment; they aren't required to start research.
Copilot cloud agent can research a repository, plan an approach and iterate on changes before any pull request exists. You can start research from the agents tab or panel, or open Copilot Chat and attach the repository as context, in which case Copilot prompts you to approve a deep research session.
GitHub's example implementation-planner custom agent writes plans and specifications as Markdown files instead of implementing code. Which tools does its profile enable?
Aread, search and edit
BAll tools, because it leaves out the tools property
Cexecute and web, to run builds and research
DNone, because it sets tools: []
Show the answer and why
Aread, search and edit
Correct
The example sets tools: ["read", "search", "edit"], a subset of the available tools.
BAll tools, because it leaves out the tools property
Incorrect
That is the testing-specialist example; the planner lists a subset.
Cexecute and web, to run builds and research
Incorrect
The planner doesn't enable shell or web tools.
DNone, because it sets tools: []
Incorrect
An empty list would disable all tools, and the planner needs to read and write files.
The implementation-planner example in the custom agents configuration reference enables only the read, search and edit tools and tells the agent to create structured Markdown plans with tasks and acceptance criteria rather than implementing code. Omitting tools enables all tools, and tools: [] disables them.
A team hands work to Copilot cloud agent from the tools it already uses. For larger changes it wants the agent to research the repository and agree a plan with them first, with no pull request until they are satisfied. Apart from GitHub.com itself, which of these integrations supports that way of working?
AThe Jira integration
BThe Linear integration
CThe Slack integration
DThe Azure Boards integration
Show the answer and why
AThe Jira integration
Incorrect
Jira is one of the integrations that only support creating a pull request directly.
BThe Linear integration
Incorrect
Linear only supports creating a pull request directly.
CThe Slack integration
Correct
Research, plan and iterate is in public preview for the Teams and Slack integrations, besides being available on GitHub.com.
DThe Azure Boards integration
Incorrect
Azure Boards only supports creating a pull request directly.
Researching a repository, planning an approach and iterating on a branch before creating a pull request are available with Copilot cloud agent on GitHub.com, and in public preview for the Teams and Slack integrations. Other cloud agent integrations, such as Azure Boards, Jira and Linear, only support creating a pull request directly, so planning before action has to happen elsewhere when work starts from them.