GH-600 Study Guide: How to Pass the GitHub Agentic AI Developer Exam

What Is GH-600, Exactly?

GH-600 is the exam behind the credential GitHub Certified: Agentic AI Developer. Microsoft's own certification page describes the role as demonstrating "deep expertise in deploying, operating, integrating, and governing AI agents in production SDLC workflows, ensuring reliability, safety, and speed with GitHub as the control plane." It is not a certification about writing agents from scratch or training models — it tests whether you can run agents that already exist (primarily GitHub Copilot coding agent) safely inside a real software delivery pipeline.

The page lists this exam as provided by Microsoft but maintained by GitHub, which explains why the exam code uses GitHub's "GH" prefix rather than Microsoft's usual product-line prefixes (AZ, MS, SC), while still living inside Microsoft's standard credential and scheduling system.

Microsoft does not publish a fixed question count or a flat exam price on its GH-600 certification or study-guide pages — price is set by the country/region where you sit the exam, so we're not going to guess a number here. Check the current figures on your Pearson VUE scheduling page before you book.

Why the Tool-Use-and-MCP Domain Decides Whether You Pass

Implement tool use and environment interactioncarries 20–25% of the exam, the single heaviest domain, and it is the one most experienced Copilot users underestimate because they've only used tools through a chat interface. The official skills outline splits it into four sub-areas: selecting and configuring agent tools and their permissions, configuring MCP (Model Context Protocol) servers, integrating agents into development environments (repo scoping, CI invocation, branch-based scope), and operating agents with safe execution paths — error handling, retries, rollbacks, and escalation.

The MCP sub-area rewards knowing the mechanics, not just the acronym. GitHub's own docs show a local MCP server launched with a command and arguments (for example, running an npx-installed server against a local database), versus a remote MCP server reached over HTTP — GitHub's own hosted MCP server at https://api.githubcopilot.com/mcp/ authenticates by OAuth by default, with no personal access token or local install required. Credentials an MCP server needs must be stored as an Agents secret or variable prefixed COPILOT_MCP_; only variables with that prefix are exposed to the MCP configuration.

The Planning-vs-Execution Boundary Most Candidates Miss

Prepare agent architecture and SDLC processes(15–20%) is less about picking an architecture diagram and more about a specific, testable skill: configuring an agent so that its planning step is distinct from its execution step, and that execution cannot start until a structured plan has been produced, validated, and explicitly approved. This shows up in the official sub-skills as "configure agent planning to be distinct from agent execution," "validate agent plans," and "prevent agent action until the agent checked and approved."

The rest of the domain covers identifying steps an agent should perform versus steps that need a human, spotting common agent anti-patterns, and configuring observability so an agent produces inspectable artifacts inside normal developer tooling (pull requests, checks, logs) rather than a black-box output only the agent can interpret.

Memory and State: The Domain That Trips Up Daily Copilot Users

Manage memory, state, and execution (10–15%) is the smallest domain by weight but the one where casual Copilot familiarity actively works against you, because the exam tests operational judgment most personal projects never force. The sub-skills ask you to choose between short-term, long-term, and external memory for a given task, scope memory to only what's task-relevant, and define expiration/pruning/reset rules — then separately, to persist state as durable artifacts so an agent can resume work without repeating steps, and to detect and correct context drift during a long-running task.

For a sense of how GitHub implements this in a real product: GitHub Copilot's own memory feature distinguishes repository-level facts (shared, scoped to the repo they came from) from user-level preferences (personal, follow you across repos), and automatically deletes any stored fact or preference that goes unused for 28 days — a concrete illustration of the "expiration and pruning" sub-skill the exam names abstractly.

How GH-600 Grades Your Evaluation-and-Tuning Judgment

Perform evaluation, error analysis, and tuning (15–20%) asks you to define success criteria and evaluation signals before a task runs, then diagnose failures after one doesn't go as planned. The official outline names three root-cause buckets explicitly: reasoning errors, tool misuse, and context or environment issues— expect scenario questions that describe a failed agent run and ask which bucket it belongs to, since the correct next action (revise instructions vs. refine tool access vs. refine memory usage) depends on getting the classification right first.

Multi-Agent Coordination: What "Orchestration" Actually Means Here

Orchestrate multi-agent coordination(15–20%) covers running more than one agent against the same codebase without them stepping on each other: applying an orchestration pattern, isolating agents for parallel execution, and detecting conflicts — overlapping code changes, duplicated effort, contradictory outputs. It also covers the full lifecycle of an agent inside a multi-agent workflow: adding a new agent, updating or replacing one without disrupting active work, and retiring one while preserving auditability.

Note what the official objectives do notdo: they don't name a fixed list of orchestration patterns (like "sequential" or "supervisor") as exam vocabulary. Treat orchestration pattern as a concept to reason about — how would you structure agents so their work doesn't collide — rather than a term to memorize a single correct label for.

Guardrails and Accountability: The Governance Half of the Exam

Implement guardrails and accountability(10–15%) is where the exam tests judgment about risk, not just configuration steps. You're expected to classify agent actions by operational, security, and compliance risk to right-size human intervention, then implement the guardrails that follow: blocking actions that violate policy, scoping permissions to least privilege, and requiring explicit authorization for irreversible or compliance-sensitive changes — while not adding approval steps that don't materially reduce risk, since the objectives explicitly call out preserving delivery velocity as part of the skill.

GitHub's own cloud agent guardrails documentation gives a concrete real-world example worth knowing: by default, a Copilot coding agent is already restricted from pushing to a default branch or merging pull requests, and workflows triggered by an agent-authored PR are blocked from running until someone with write access approves them — a repository admin can disable that safeguard, but doing so is itself the kind of guardrail decision this domain tests.

Common GH-600 Misconceptions, Corrected

Hours are proportional to the midpoint of each domain's published weight range. Scale the total up or down — the ratios between domains matter more than the absolute number.

How the Official GitHub and Microsoft Learn Resources Compare

Microsoft's official GH-600 study guide and certification pagelink out to per-domain documentation on docs.github.com and three Microsoft Learn training modules — Foundations of Agentic AI in GitHub, Designing Agent Architecture and SDLC Integration, and Tooling, MCP, and Agent Execution Environments. Work through those first; use scenario practice to confirm the judgment calls actually stick.

Related Resources

Frequently Asked Questions