Exam tips & caveats

Everything you want in your head the night before. Numbers that appear in answer options, the pairs that look alike, the places where the Learn modules and the live documentation disagree, and a lookup table that maps typical scenario wording to the answer the exam expects.

Final review Skills measured: study guide revision of May 4, 2026

Key numbers and defaults

NumberWhat it is
120 min · 700Exam duration · passing score (out of 1000); English; retake after 24 hours
2 yearsValidity of GitHub certifications (moving to Microsoft's renewal process)
59 minutesHard limit of one Copilot cloud agent session; also the maximum timeout-minutes in copilot-setup-steps.yml
1 · 1 · 1Cloud agent works in one repository, on one branch, and opens one PR per task
30,000Maximum characters in a custom agent's prompt
30 sDefault hook timeout (timeoutSec); aim for under 5 seconds
8Consecutive agentStop blocks before the runaway guard ends the turn
28 daysUnused Copilot Memory entries are deleted (timer resets on validated use)
90 daysDefault retention for Actions logs and artifacts (public repos 1–90, private up to 400)
180 daysAgentic activity visible with the actor:Copilot audit log filter
24 hoursWindow of agent sessions listed on the enterprise AI Controls Agents page
~80% · ~95%Copilot CLI starts background compaction · pauses to let it finish
20 KiBCLI tool output above this is saved to a file; only a preview enters context
10 MB · 500 filesCLI rewind cannot restore files above 10 MB or turns that changed more than 500 files
1 AIC = $0.01 · 1,000AI credit value · default max-ai-credits per Agentic Workflows run
COPILOT_MCP_Required prefix for Agents secrets and variables that MCP configuration can use
copilot/Prefix of the branch cloud agent creates

One default the docs disagree on

The autopilot concept page says autopilot pauses after 5 automatic continuations by default; the CLI command reference lists --max-autopilot-continues with a default of unlimited. The safe exam answer for automation is the same either way: set the limit explicitly.

Where Learn and the docs disagree

The Learn modules were written quickly against a moving product, and several examples are conceptual rather than exact. The exam tests the concepts; when a detail matters, the live GitHub documentation is the authority.

Learn module showsThe GitHub docs sayWhat to remember
applyTo globs in a custom agent profileapplyTo is frontmatter for path-specific *.instructions.md files; agent profiles scope through tools and the promptPath scoping = instructions; capability scoping = tools
Hooks as {"trigger": "pre-tool-use", "run": …} or rule lists with permissionDecision{"version": 1, "hooks": {"preToolUse": [{"type": "command", "bash": …}]}}; the script prints permissionDecision JSONThe concept is right: pre-tool hooks block, post-tool hooks log, error hooks escalate
npx @github/copilot-cli; copilot agent run CodeAgentnpm install -g @github/copilot, then copilot -p and copilot --agent=NAMERead the intent: programmatic run, named agent, restricted tools
COPILOT_GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}GITHUB_TOKEN plus copilot-requests: write (org billing policy on), or a fine-grained PAT with Copilot Requests in COPILOT_GITHUB_TOKENBuilt-in token for org automation; PAT for personal repos
"Copilot cannot sign commits" — add a bypass actor for "require signed commits"Copilot's commits are signed and show as Verified; it may be blocked by rules on other commit metadata, such as allowed authorsThe fix is still "add Copilot as a bypass actor on the ruleset"
Cloud agent never opens a PR itself; you decideAgents-tab sessions do not open a PR unless asked; issue assignment and CLI /delegate open a draft PREither way a human marks it ready, approves and merges
agents: and handoffs: in a planner profilehandoffs and argument-hint are VS Code properties, ignored by cloud agent on GitHub.comSubagent orchestration on GitHub uses the agent tool
MCP allowlist = registry with Allow all / Registry onlyAlso true, but managed-settings.json allowlists are now GA and recommended; neither registries nor these policies govern cloud agentCloud agent MCP is governed by repository settings and profiles
A plan gate that checks for Github/pull_request_template.mdThe template lives at .github/pull_request_template.md; a meaningful gate inspects the PR bodyA gate validates plan shape, not plan quality
"Copilot coding agent", "Copilot Cloud Agent" used interchangeablyRenamed to Copilot cloud agent in April 2026Same agent, same security model

Commonly confused pairs

PairThe difference
Custom instructions vs custom agentInstructions are always-on context for every request; a custom agent is a selectable persona with its own prompt, tools and MCP servers
Custom agent vs agent skillAn agent is chosen for a task; a skill is loaded automatically when relevant and can bundle scripts
Skill vs prompt fileSkills are picked up automatically (cloud agent, CLI, IDE); prompt files are run manually in the IDE
Instructions vs hooksInstructions guide; hooks execute deterministically and preToolUse can deny
--available-tools vs --allow-toolWhat the model can see vs what runs without a prompt
--allow-all vs autopilot vs --no-ask-userPermissions vs continuing autonomously across steps vs suppressing clarifying questions
disable-model-invocation vs user-invocableStops automatic selection (and subagent calls) vs hides from manual selection
Repository MCP settings vs mcp-servers in a profileShared by cloud agent and code review for the repo vs available to that one agent
Agents secrets vs Actions secretsAgents secrets reach cloud agent (COPILOT_MCP_* only MCP servers); Actions, Codespaces and Dependabot secrets never do
Workflow GITHUB_TOKEN vs Copilot's session tokenThe workflow token runs setup steps; Copilot gets its own scoped token for its session
Agent firewall vs MCP allowlistFirewall limits network egress of agent shell processes; allowlists decide which MCP servers can run in IDEs and CLI
Copilot cloud agent vs agent modeAsynchronous on a GitHub Actions runner, delivers a branch/PR vs synchronous edits in your local IDE
Automations vs Agentic WorkflowsAutomations are private to their creator, stored outside Git, private/internal repos only, cloud agent only; Agentic Workflows are versioned markdown, reviewed through PRs, any engine
Copilot Memory vs custom instructionsLearned, validated and expiring vs written, reviewed and versioned
Rulesets vs branch protectionRulesets are layered, reusable and support bypass actors such as Copilot; either can require checks and reviews
CODEOWNERS vs required reviewsCODEOWNERS routes review requests; only "require review from Code Owners" makes their approval mandatory
Plan-first vs plan + executionValidation before any code vs before merge; choose by risk and reversibility
Workflow-level vs job-level concurrencyWorkflow-level stops overlapping runs; job-level only coordinates within a run
Step outputs vs job outputs vs envWithin a job vs across jobs via needs vs runtime configuration, not structured data flow
Automation approvals vs security controlsApprovals decide what should apply; permissions decide what can

Decision trees

Which customization layer?

flowchart TD
  Q["What do you need Copilot to do?"]
  Q --> A1["Follow conventions on every task"] --> R1["Custom instructions<br/>copilot-instructions.md · *.instructions.md · AGENTS.md"]
  Q --> A2["Act as a specialist with its own tools"] --> R2["Custom agent<br/>.github/agents/*.agent.md"]
  Q --> A3["Follow a procedure with scripts, only when relevant"] --> R3["Agent skill<br/>.github/skills/NAME/SKILL.md"]
  Q --> A4["Reach an external system"] --> R4["MCP server<br/>with a tools allowlist"]
  Q --> A5["Guarantee a check runs or a call is blocked"] --> R5["Hook<br/>preToolUse · postToolUse"]
  Q --> A6["Have dependencies ready before it starts"] --> R6["copilot-setup-steps.yml"]
  Q --> A7["Never merge without review or checks"] --> R7["Ruleset · CODEOWNERS · required checks"]
Pick the layer by the job it does. Only the last three can guarantee behaviour.

Where should the control live?

flowchart TD
  Q["Where should this control live?"]
  Q --> C1["What the agent may attempt"] --> T1["Tool allowlists<br/>profile tools · MCP tools · --allow-tool"]
  Q --> C2["What it may reach on the network"] --> T2["Agent firewall<br/>Internet access settings"]
  Q --> C3["Which secrets it may read"] --> T3["Agents secrets<br/>environment-scoped secrets"]
  Q --> C4["Which tool calls are refused"] --> T4["preToolUse hook<br/>--deny-tool · managed settings"]
  Q --> C5["What may merge"] --> T5["Ruleset · required checks<br/>CODEOWNERS review"]
  Q --> C6["What may deploy"] --> T6["Environment<br/>required reviewers"]
Each kind of limit has one natural home in the platform.

Which automation mechanism?

flowchart TD
  Q["Recurring or event-driven agent work"] --> V{"Must the automation be<br/>versioned and reviewed as code?"}
  V -->|"yes"| GHAW["GitHub Agentic Workflows<br/>markdown + lock file · any engine"]
  V -->|"no"| R{"Private or internal repository,<br/>and cloud agent is enough?"}
  R -->|"yes"| AUTO["Copilot automations<br/>schedule or event triggers"]
  R -->|"no — one step inside existing CI"| CLI["Copilot CLI in a workflow step<br/>-p with minimal --allow-tool"]
Choosing between Agentic Workflows, automations and the CLI in CI.

Scenario → answer lookup

If the scenario says……the answer is usually
"Guarantee the planning agent cannot modify files"Read-only tools list in its profile — not an instruction
"Review the approach before any code is written" for an infra changePlan-first: a plan-only PR or session, approved, then an explicit handoff
"Agent keeps failing to install private packages"copilot-setup-steps.yml + Agents secrets for the registry + firewall allowlist entry
"Request to an internal host was blocked; warning in the PR"Add the domain or URL to the firewall custom allowlist
"MCP server needs an API key"Agents secret named COPILOT_MCP_…, referenced as $COPILOT_MCP_…
"Cloud agent should read issues in another repository"Configure the GitHub MCP server in repo MCP settings with a PAT or GitHub App, ideally on /readonly
"Only approved MCP servers may be used in VS Code and the CLI"managed-settings.json allowedMcpServers (or registry + Registry only)
"Enable only the Actions tools of the remote GitHub MCP server"X-MCP-Toolsets: actions header or the /mcp/x/actions URL
"Cloud agent is blocked by a commit-author rule"Add Copilot as a bypass actor on the ruleset
"Workflows did not run on Copilot's PR"Expected — a user with write access clicks Approve and run workflows
"The developer who assigned the issue cannot approve the PR"By design — the requester is co-author; another reviewer approves
"Run an agent nightly in CI with no stored PAT"GITHUB_TOKEN + copilot-requests: write + org billing policy — or Agentic Workflows
"The CI agent step should only run git commands"--allow-tool='shell(git:*)' (plus --deny-tool for anything like git push)
"Block rm -rf for every agent session in the repo"preToolUse hook in .github/hooks/ on the default branch
"The block must hold even if the hook script crashes"Command preToolUse hooks fail closed on errors — but timeouts fail open, so keep it fast
"Two agent PRs keep conflicting on the lockfile"Scope boundaries per agent + CODEOWNERS + merge-validation check; escalate after two failures
"Stop overlapping runs of the same workflow on a PR"concurrency: ${{ github.workflow }}-${{ github.ref }} with cancel-in-progress: true
"Merge the outputs of two parallel analysis jobs"A third job with needs: [a, b] (fan-in)
"Run security validation only after CI finishes"workflow_run on the CI workflow's completed event
"Watch a stalled cloud agent run live from the terminal"gh agent-task view --log --follow
"Find everything agents did in the org last month"Audit log filtered by actor:Copilot, grouped by agent_session_id
"An evidence artifact disappeared"Audit log action:artifact.destroy
"Resume yesterday's agent work without redoing it"Re-anchor to the PR: description, linked issue, commits, Checks tab
"Agent used outdated information from an old branch state"Stale context: update the branch, re-run checks, re-read the issue
"Agent keeps making the same repository-specific mistake"Add it to custom instructions (authoritative); delete any wrong Copilot Memory fact
"Stop the orchestrator from auto-invoking a destructive agent, keep it selectable"disable-model-invocation: true
"Test an org-wide custom agent before everyone gets it"Put it in .github/agents of .github-private, then move it to agents/
"Deploys must wait for a named approver and use prod secrets only"Environment with required reviewers and environment-scoped secrets
"Triage automation should only auto-apply confident label changes"Automation level Cautious (the default)
"Reviewers approve agent PRs without reading them"Rubber-stamping: smaller PRs, evidence-first, CODEOWNERS routing, fewer low-value approvals
"Agent's task is vague and open-ended"Do not run it autonomously — define criteria, constraints and paths first

Traps and caveats

Enforcement beats guidance

If two answers differ only in whether the rule is written down or enforced — an instruction versus a tool allowlist, a README policy versus a ruleset, "ask the agent to" versus a hook — the enforced option is the one the exam wants.

Cloud agent MCP tools run without asking

There is no approval prompt for MCP tools in cloud agent. The only protection is the tools allowlist you configure, so allowlist specific read-only tools and treat adding MCP tools like adding a high-risk dependency.

The firewall has gaps

It covers processes the agent starts through its shell tool — not MCP server processes, not setup-step processes — and it is incompatible with self-hosted and Windows runners, where you must bring your own network controls.

Preview features can appear

Copilot Memory, custom agents in some IDEs, third-party agents, automations' rationale and approvals, and GitHub Agentic Workflows are public preview at the time of writing. Commonly used preview features may be tested — learn their behaviour, not just their names.

Read the execution context first

Before evaluating the options, decide where the agent in the question is running: cloud agent, CLI on a laptop, CLI in a workflow, Agentic Workflows, or IDE agent mode. Many wrong answers are correct controls for a different surface — a private MCP registry for cloud agent, or a repository firewall rule for a local CLI session.

Pre-exam checklist

  • I can explain assistant vs agent, the plan → act → evaluate loop and the contributor model.
  • I can name the GitHub controls that make up the control plane and what each enforces.
  • I can write a custom agent profile from memory, including tools semantics and the two invocation flags.
  • I know where instructions, agents, skills, hooks, setup steps, MCP settings and Agents secrets live.
  • I can read repository MCP JSON and spot a missing type or tools, or a secret without COPILOT_MCP_.
  • I know what the default GitHub MCP token can do in cloud agent, and how to widen it safely.
  • I can compare registry restriction with managed-settings.json allowlists, and know neither governs cloud agent.
  • I know cloud agent's limits: one repo, one branch, one PR, 59 minutes, draft PRs, workflow approval, firewall.
  • I can choose between Agentic Workflows, automations and the CLI in CI, and authenticate each correctly.
  • I can design bounded retries, escalation, rollback and traceability for an agent workflow.
  • I can place information correctly across short-term, long-term and external memory, and explain Copilot Memory's rules.
  • I can detect and correct drift, and prevent conflicting and stale context.
  • I can classify a failure as reasoning, tool, context or environment, and name the fix layer.
  • I can write fan-out/fan-in, workflow_run and concurrency YAML, and explain isolation.
  • I can add, update, replace and retire a custom agent without breaking active work.
  • I can classify actions by risk, assign an autonomy level, and explain how preToolUse hooks fail.
  • I can name the approvals that reduce risk — and the ones that only slow delivery.

Last pass

Skim the Configuration reference once more, re-read the Exam callouts on each skill page, and try the exam sandbox so the interface is familiar. Good luck.