GH-600 Study Guide
A curated learning path for the GH-600 exam: the best documentation, videos, blog posts and tutorials for every exam objective.A curated learning path for the GH-600 exam: the best documentation, videos, blog posts and tutorials for every exam objective, in the order worth studying them.
GitHub Certified: Agentic AI Developer
Exam at a Glance
GH-600 measures whether you can run AI coding agents safely inside real software delivery: fitting them into the development lifecycle, giving them the right tools, MCP servers, and environment, managing memory and state, evaluating their output, coordinating several agents, and governing what they may do, with GitHub as the system of record. Expect to decide which customization, tool, or control meets a requirement.
| GH-600 | Developing in Agentic AI Systems |
|---|---|
| Level | Intermediate (GitHub agentic AI exam) |
| Exam length | 120 minutes |
| Questions | Typically 40 to 60; the number and format mix can vary |
| Passing score | 700 out of 1000 |
| Question formats | Not listed; the certification page says it may include interactive components |
| Microsoft Learn access | Not available on GitHub exams |
| Skills measured version | None published; the study guide page was last updated 2026-05-13 |
| Renewal | Not stated on the certification page |
What the Exam Covers
Six domains. Tool use and environment interaction carries the most weight at 20-25%; architecture and SDLC processes, evaluation and tuning, and multi-agent coordination carry 15-20% each, and memory and state and guardrails 10-15% each. The objectives ask which tool, setting, signal, or control fits a requirement, and guardrails also come up inside the architecture and tool-use domains, so do not skim them for their smaller weight.
Prepare agent architecture and SDLC processes — 15-20%
Deciding which lifecycle steps agents should perform and how their work is planned. Questions cover common anti-patterns, defining inputs, outputs, and success criteria, keeping planning distinct from execution, validating and approving a structured plan before the agent acts, the degree of autonomy, inspectable artifacts, and adding human intervention without slowing delivery.
Implement tool use and environment interaction — 20-25%
The heaviest domain. You configure and permission agent tools, add MCP servers (including the GitHub remote MCP server, MCP registries, and allow lists), scope an agent to a repository or branches, invoke it in a CI workflow, and build safe execution paths with error handling, retries, rollbacks, escalation, and traceability for agent actions.
Manage memory, state, and execution — 10-15%
Choosing between short-term, long-term, and external memory, scoping it to the task, and setting expiration, pruning, and reset rules. Questions also cover capturing progress as durable artifacts, resuming without repeating steps or diverging from earlier decisions, correcting drift during long runs, and sharing state without conflicting or stale context.
Perform evaluation, error analysis, and tuning — 15-20%
Specifying expected outcomes, choosing qualitative and quantitative signals (including those from automated scanning tools), and finding failures in logs, plans, traces, and workflow artifacts. Root causes split into reasoning errors, tool misuse, and context or environment issues, and tuning means revising instructions, workflows, or constraints and refining memory and tool access.
Orchestrate multi-agent coordination — 15-20%
Applying an orchestration pattern and isolating agents for parallel work, then resolving conflicts such as overlapping code changes, duplicated effort, and contradictory outputs. Questions also cover documenting handoffs for review and audit, spotting failed, partial, or stalled executions, recovery through rollback or human-in-the-loop, and retiring or replacing agents without losing auditability.
Implement guardrails and accountability — 10-15%
Classifying agent actions by operational, security, and compliance risk and assigning autonomy levels to match. You decide which actions need human judgment, block those that violate security, compliance, or Responsible AI policies, scope permissions for least privilege, require explicit authorization for irreversible changes, and drop approvals that do not materially reduce risk.
The full bullet list is in Microsoft's study guide, linked in Step 1 below.
How This Maps to CertiAce Practice Modules
The CertiAce question bank follows the three modules of the official Developing in Agentic AI Systems Part 1 learning path, plus two case studies of 28 questions each. Each module is the home of some of the six skill areas in full:
| CertiAce practice module | Skills-measured areas it mainly serves |
|---|---|
| Foundations of Agentic AI in GitHub | Prepare agent architecture and SDLC processes (foundations, anti-patterns), Perform evaluation, error analysis, and tuning, and Implement guardrails and accountability |
| Designing Agent Architecture and SDLC Integration | Prepare agent architecture and SDLC processes (SDLC stages, plans, pull request governance), Manage memory, state, and execution, and Orchestrate multi-agent coordination (audit artifacts, handoffs, recovery) |
| Tooling, MCP, and Agent Execution Environments | Implement tool use and environment interaction and Orchestrate multi-agent coordination (orchestration patterns, parallel work, retiring agents) |
The three modules of the Part 2 learning path (Multi-Agent systems and orchestration; Memory, State, and Evaluation; Governance, guardrails, and operations) are covered within these three practice modules for now.
Where GH-600 Fits

| Certification | What it validates | When to take it |
|---|---|---|
| GH-900: GitHub Foundations | Foundational knowledge of Git, GitHub, and collaborating on GitHub | Optional first step if you are new to GitHub |
| GH-300: GitHub Copilot | Using GitHub Copilot effectively and responsibly, from prompting and features to privacy safeguards | Not required, but the natural step before GH-600 if you are new to Copilot |
| GH-600: GitHub Certified: Agentic AI Developer (this exam) | Operating, integrating, supervising, and governing AI agents in production development workflows, with GitHub as the control plane | You are here |
| GH-200: GitHub Actions | Automating workflows and software pipelines with GitHub Actions | A companion if you run agents in CI workflows or build the checks that gate their work |
| GH-500: GitHub Advanced Security | Securing code, secrets, and dependencies with GitHub's security features | A companion if you use code scanning, secret scanning, and dependency review as signals and gates for agent work |
| GH-100: GitHub Administration | Administering GitHub Enterprise: identities and access, governance, security features, Actions, and usage | A next step if you govern Copilot and its agents across organizations or an enterprise |
GH-600 has no prerequisite certification, and the other GitHub certifications above do not list one either. GH-300 is not required, but the GH-600 audience profile asks for experience with coding agents including GitHub Copilot, MCP servers, and agent customization such as custom instructions, custom agents, tools, and Copilot setup steps, so GH-300 is the natural predecessor if you have not worked with Copilot yet. GH-900 is a natural first step if you are new to GitHub. If you already run Copilot's agents in your repositories, go straight to GH-600. GH-200 and GH-500 cover the workflows, checks, and scanners that GH-600 uses as controls and evaluation signals.
Before You Start
The exam is written for people who already run coding agents in real repositories: its audience profile asks for experience with the software development lifecycle, workflows in GitHub and its controls, code quality, security, and review practices, and coding agents including GitHub Copilot. Anything unfamiliar in this table is where to start:
| Area | You should be comfortable with |
|---|---|
| Everyday GitHub | Repositories, branches, pull requests, reviews, and issues, and how work moves through your team's development lifecycle |
| GitHub controls | Rulesets and branch protection, required status checks and approvals, CODEOWNERS, and deployment environments |
| GitHub Actions | What a workflow, job, and runner are, how to read a short workflow YAML file, and how token permissions and secrets work |
| Code quality and security | What code scanning, secret scanning, and dependency review report, and how a failing check blocks a merge |
| Copilot and coding agents | Using Copilot Chat and agent mode, and what custom instructions, custom agents, tools, MCP servers, and Copilot setup steps are |
| AI basics | What a large language model, a prompt, and a context window are, and why agent output always needs review |
Commonly Confused Pairs
These pairs tend to show up together as the two plausible answers to one question:
| Looks similar | The difference that decides the answer |
|---|---|
| Custom instructions or agent skills | Custom instructions are always-on context that Copilot applies automatically to every interaction in their scope, so they suit standards that apply broadly. An agent skill is a folder of instructions, scripts and resources that Copilot loads only when it is relevant to the task, which keeps a detailed workflow out of every conversation. |
| An instruction or a preToolUse hook | An instruction asks the model to follow a rule. A hook runs your own command at a set point in the agent's work, and a preToolUse hook runs before a tool is used and can approve or deny that tool call. When a rule must be enforced rather than requested, use a hook. |
| Agents secrets or Actions secrets | Copilot cloud agent receives only Agents secrets and variables, set at organization or repository level, and never gets Actions, Codespaces or Dependabot secrets. Agents secrets whose names start with the COPILOT_MCP_ prefix reach only MCP servers; the others are exposed to the agent as environment variables. |
| Autopilot or granting all permissions | In Copilot CLI, autopilot controls continuation: the agent works through successive steps without waiting for your next prompt. Granting all permissions controls approvals: the agent may use every tool, path and URL without asking, but it still stops when it needs direction. In autopilot with manual approval, tool requests that need approval are denied. |
| GITHUB_TOKEN or a GitHub App token | Events caused by GITHUB_TOKEN start no new workflow runs, except workflow_dispatch and repository_dispatch, and pull requests it opens or updates get runs that wait for approval from someone with write access. A GitHub App installation token or a personal access token does trigger workflows, so automation that must start other workflows uses one of those. |
Step-by-Step Study Plan

Treat these estimates as planning guidance and adjust them to your starting knowledge and weekly study hours:
| Your starting point | Suggested prep time |
|---|---|
| You run Copilot cloud agent or other coding agents in your team's repositories weekly | 2 to 4 weeks |
| You use GitHub and Copilot daily but have not yet operated coding agents | 4 to 8 weeks |
Step 1: Read the Official Study Guide
Read the skills list once and mark every bullet you could not explain to a colleague. The list carries no version date (the page was last updated on 2026-05-13) and no change log, while the agent features it covers change every month, so check older material against the current documentation. Most questions cover generally available features, but commonly used preview features may also appear.
Step 2: Schedule Your Exam
Choose a realistic target date after reviewing the skills list and your available study time, then work backwards from it with the prep-time table above. You schedule through Pearson VUE, online or at a test center. The exam is offered in English only. If the exam is not available in your native language, check the English as a Second Language accommodation and arrange any approved extra time before booking.
Certification and Exam Details Page
Step 3: Work Through the Official Learning Paths
Complete both Developing in Agentic AI Systems learning paths on Microsoft Learn; the CertiAce practice modules follow the three Part 1 modules. Write down every concept you cannot explain in plain words, and try each control in your own repository as you go. GitHub's documentation changes faster than the training modules, so when a unit and docs.github.com disagree, go with the documentation. Instructor-led course GH-600T00 is also available.
Developing in Agentic AI Systems Part 1 of 2
Developing in Agentic AI Systems Part 2 of 2
Step 4: Get Hands-On Practice
GH-600 rewards people who have run agents under real controls. Copilot cloud agent, the surface many objectives are written around, is available on all paid Copilot plans; Copilot Free includes only limited access. Make sure you personally:
- Assign an issue to Copilot cloud agent, steer it with a pull request comment, and approve its workflow runs
- Create a custom agent profile with a restricted tools list, and compare its output with and without custom instructions
- Add a copilot-setup-steps.yml file that preinstalls your dependencies, and find its run in the session log
- Configure an MCP server for the repository that allows only the tools a task needs
- Add a branch ruleset with required checks and approvals, and watch how it gates the agent's pull request
Organization and enterprise policies, such as the MCP servers in Copilot policy, apply only to members who get Copilot Business or Copilot Enterprise from that organization or enterprise; learn those from the documentation.
Configure the development environment
GitHub Skills offers free, interactive exercises inside GitHub repositories, including Copilot cloud agent and MCP servers. Check each exercise's prerequisites: the cloud agent exercise needs a paid Copilot plan.
Step 5: Benchmark Your Knowledge
Use CertiAce to benchmark your readiness module by module. The practice modules map to the exam domains as shown above, so use the module mapping and the topics behind your missed questions to identify the skills-measured areas to revisit. The two case studies mix several domains in one scenario, so use them as a final check. The GH-600 certification page does not offer a free official practice assessment. If a module stays weak, read the explanations on the questions you missed, then retry that module.
Step 6: Take the Exam
The day before, review only your weak topics. In the exam, many GH-600 scenarios turn on where a control lives (repository, organization, enterprise, agent profile, or workflow file), which surface the agent runs on (Copilot cloud agent on GitHub, Copilot CLI, or an IDE), or what a built-in protection already does. Settle those first and eliminate the options that do not fit.
- This is a closed-book exam: Microsoft Learn access is not available on GitHub exams.
- You can take unscheduled breaks, but the clock keeps running and you cannot return to questions you already saw.
- Labs may appear: GH-600's 120-minute allotment is the one Microsoft uses for role-based exams that may contain labs. The introduction screen tells you whether yours does; if it does, budget extra time for them.
- Watch the naming: older material calls Copilot cloud agent the coding agent, and newer features such as Copilot automations are not named in the skills list. Learn the outline's features first and treat newer ones as background.
- Try the GitHub exam sandbox beforehand so the interface holds no surprises: GitHub Exam Sandbox
Additional Learning Resources
| Resource | Type | Why it is useful |
|---|---|---|
| GitHub Copilot documentation | Docs | The official home for Copilot, from Copilot cloud agent and customization to MCP and administration |
| GitHub Copilot on GitHub.com | Docs | How Copilot cloud agent researches, plans, and implements changes, how session context and session logs work, and its limits on repositories, branches, and rulesets |
| Custom agents | Docs | Agent profiles, where custom agents run, built-in agents, and how a custom agent differs from a subagent |
| Comparing Copilot customization features | Docs | When to use custom instructions, agent skills, tools, MCP servers, hooks, subagents, or a custom agent |
| Model Context Protocol (MCP) | Docs | The cloud agent's default MCP servers, repository-level MCP configuration, MCP servers in agent profiles, the GitHub MCP server, and the MCP policy |
| About GitHub Copilot Memory | Docs | Repository facts compared with user preferences, how citations are validated, why unused entries expire, and who can delete them |
| Delegating and parallelizing work with agents | Docs | How an orchestrator splits work into subtasks for subagents, when parallel work pays off, and what it costs |
| Risks and mitigations for GitHub Copilot cloud agent | Docs | The cloud agent's built-in protections: who can trigger it, branch and credential limits, human review before merge, workflow-run approval, the firewall, and audit trails |
| GitHub Agentic Workflows | Docs | Repository automations written in Markdown that run as GitHub Actions workflows, with read-only defaults and safe outputs as guardrails |
| GitHub Changelog: Copilot | Blog | Copilot product updates, useful for spotting renamed, retired, or newly released features |
Realistic GH-600 exam-style questions with instant feedback and detailed explanations.
Practice GH-600 now