Exam at a glance
Exam format
The exam is proctored, scheduled through Pearson VUE and offered in English. The certification page warns that it may include interactive components, so try the exam sandbox to get used to the interface. Most questions cover generally available features, but commonly used preview features can appear — and much of the agent tooling (Copilot Memory, custom agents in some IDEs, third-party agents, GitHub Agentic Workflows) is still in public preview. If you fail, you can retake after 24 hours; later retakes have longer waits.
What the exam validates
GH-600 validates that you can operate, integrate, supervise and govern AI agents inside a production software development lifecycle, using GitHub as the system of record and control plane. It is a judgement exam: most questions describe an agent doing something — or about to — and ask which control, file, setting or escalation path is right. You are expected to read custom agent profiles, hook configurations, MCP JSON, Copilot CLI flags and GitHub Actions YAML and spot what is missing or unsafe.
How to use these notes
Start with Agentic Foundations for the mental model and the vocabulary. Work the six skill pages in outline order — Skill 2 is the heaviest, so give it the most time — and keep the Configuration reference open while you practise. Drill Exam tips & caveats in the final week. These notes are a companion, not a replacement: pair every page with hands-on time with Copilot cloud agent, Copilot CLI and a throwaway repository, and with the official Learn modules listed below.
Names moved while this exam was being written
Copilot coding agent is now Copilot cloud agent (renamed in April 2026, when
it gained research, planning and branch-first work before a pull request). Cloud agent secrets and variables
moved from the copilot Actions environment to a dedicated Agents secrets type.
In agent profiles, infer is retired in favour of disable-model-invocation and
user-invocable. Usage is metered in AI credits. Learn modules, blog posts and
practice questions still mix old and new names — the full translation table is on the
Foundations page.
Skills measured
The weighting is fairly even, but not flat. Skill 2 — tools, MCP and execution environments — is the single heaviest area, and Skills 1, 4 and 5 each carry as much as the two smallest areas together. Memory and guardrails are the lightest, yet guardrail thinking runs through every other skill.
1. Prepare agent architecture and SDLC processes
Mapping agents to SDLC stages, task contracts, anti-patterns, separating planning from execution, structured and validated plans, PR governance, and dialling autonomy with human intervention that does not slow delivery.
2. Implement tool use and environment interaction
The heaviest domain: tool selection and permissions, MCP servers, the GitHub remote MCP server, registries and allowlists, execution context, CI invocation, branch scope, and safe execution with retries, rollback and escalation.
3. Manage memory, state, and execution
Short-term, long-term and external memory, Copilot Memory, sources of truth, expiration and pruning, durable state in issues and pull requests, resuming work, and detecting drift, conflicting and stale context.
4. Perform evaluation, error analysis, and tuning
Success criteria and evaluation signals, required checks and scanning as quality gates, reading session logs and traces, classifying root causes, and tuning instructions, memory and tool access.
5. Orchestrate multi-agent coordination
Orchestration patterns, subagents and fleet mode, isolation with branches, permissions and concurrency, conflict arbitration, evidence and handoffs, failure recovery, and adding, replacing or retiring agents safely.
6. Implement guardrails and accountability
Risk classification and autonomy levels, rulesets, CODEOWNERS and environments, human-in-the-loop at the right decision points, least privilege, hooks that block, and approvals that actually reduce risk.
Bars are drawn to scale against the largest possible weighting, 25%.
Start here and final review
Agentic Foundations
The mental model the exam hangs off: assistant versus agent, plan → act → evaluate, GitHub as system of record and control plane, the contributor model, every Copilot agent surface and the renames you will meet.
Configuration reference
Every file and flag the exam expects you to read: agent profiles, instructions, copilot-setup-steps.yml, MCP JSON, hooks, agentic workflow frontmatter, Copilot CLI permissions and the workflow YAML that gates it all.
Exam tips & caveats
Key numbers and defaults, the renames that cost marks, Learn-versus-docs discrepancies, commonly confused pairs, a scenario-to-answer lookup table and a checklist for the night before.
The control plane in one picture
Almost every GH-600 question sits somewhere on this diagram. An agent runs inside a bounded sandbox, and everything it produces flows through the same branch → pull request → checks → review path as a human's work. If you can say which box a control lives in, you can usually eliminate half the answers.
flowchart TB
INTENT["Developer intent<br/>issue · prompt · automation trigger"] --> AGENT
subgraph CP["GitHub — system of record and control plane"]
direction TB
subgraph SANDBOX["Agent sandbox — runner · firewall · scoped token"]
direction LR
AGENT["Agent<br/>cloud agent · CLI · custom agent"] --> TOOLS["Tools<br/>built-in · MCP servers · skills"]
end
AGENT --> BRANCH["Branch and commits<br/>copilot/… · signed · co-authored"]
BRANCH --> PR["Draft pull request<br/>plan · evidence · session log"]
PR --> CHECKS["Checks and scans<br/>CI · CodeQL · secret scanning"]
CHECKS --> REVIEW["Human review<br/>CODEOWNERS · required approvals"]
end
REVIEW --> SHIP["Merge, then deploy<br/>behind an environment gate"] Suggested study order
flowchart TB F["Agentic Foundations<br/>mental model and vocabulary"] --> S1["Skill 1 · Architecture and SDLC<br/>15–20%"] S1 --> S2["Skill 2 · Tools and MCP<br/>20–25% — the heaviest"] S2 --> S3["Skill 3 · Memory and state<br/>10–15%"] S2 --> S4["Skill 4 · Evaluation and tuning<br/>15–20%"] S3 --> S5["Skill 5 · Multi-agent<br/>15–20%"] S4 --> S5 S5 --> S6["Skill 6 · Guardrails<br/>10–15%"] S6 --> CFG["Configuration reference<br/>files and flags"] CFG --> TIPS["Exam tips and caveats"]
The official learning path
Course GH-600T00-A is a one-day instructor-led course, and its self-paced content is split across six Microsoft Learn modules. They are short and scenario-driven; read each one alongside the skill page it maps to.
| Learn module | Maps to |
|---|---|
| Foundations of Agentic AI in GitHub | Foundations · Skill 1 |
| Designing Agent Architecture and SDLC Integration | Skill 1 · Skill 6 |
| Tooling, MCP, and Agent Execution Environments | Skill 2 |
| Memory, State, and Evaluation | Skill 3 · Skill 4 |
| Multi-Agent Systems and Orchestration | Skill 5 |
| Governance, Guardrails, and Operations | Skill 6 |
Two habits that pay off more than extra reading
One: for every control, be able to say whether it is guidance or
enforcement. An instruction that says "do not edit workflows" is guidance; a tool allowlist, a
preToolUse hook, a ruleset or a CODEOWNERS-required review is enforcement. The exam rewards the
enforceable answer almost every time. Two: assign one real issue to Copilot cloud agent in a
test repository, then read the session log, the commits and the pull request it produces. Ten minutes of that
teaches the branch, token, firewall and approval behaviour better than any page.