GH-600: Agentic AI Developer

A complete, exam-focused companion for Developing in Agentic AI Systems, built around the skills measured in the official study guide (revision of May 4, 2026). Learn how agents plan, act and get evaluated inside GitHub, which control stops what, and where each configuration file lives.

Intermediate LevelGitHub CopilotAgentic AIAgents · MCP · Guardrails
Disclaimer: these notes are an independent study aid for learning purposes only, not affiliated with or endorsed by GitHub or Microsoft. GitHub Copilot ships changes almost weekly and features are renamed often — always verify details against the official documentation linked throughout.

Exam at a glance

GH-600
Exam code
120
Minutes
700
Passing score
6
Skill areas
2 yrs
Validity

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.

15–20%

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.

20–25%

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.

10–15%

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.

15–20%

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.

15–20%

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.

10–15%

Bars are drawn to scale against the largest possible weighting, 25%.

Start here and final review

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"]
GitHub wraps the agent's sandbox — an Actions runner behind a firewall, with a scoped token and a 59-minute session. Work is proposed on a branch, validated by checks and accepted by people and policy: rulesets, CODEOWNERS, required checks, environments and the audit log.

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"]
Foundations first, then the skills in outline order. Memory and evaluation can be studied in either order — both feed multi-agent coordination.

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.

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.