GH-600
Developing in Agentic AI Systems
GH-600 Exam Guide: Skills, Study Plan, and Scheduling Decisions
GH-600, Developing in Agentic AI Systems, validates the ability to operate, integrate, supervise, evaluate, and govern AI agents inside production software-development workflows using GitHub as the system of record and control plane. It is intended for experienced developers, DevOps engineers, AI engineers, architects, and related practitioners rather than candidates learning GitHub from scratch. This guide helps you decide whether your background is ready, which domains need the most attention, how to sequence practical study, and what to confirm before scheduling.
What GH-600 validates
GH-600 tests whether you can make agentic systems useful and controllable within the software development lifecycle, not merely describe artificial-intelligence concepts or generate code with an assistant. The associated certification is GitHub Certified: Agentic AI Developer, and the exam is titled “Developing in Agentic AI Systems.”
The official role profile centers on production-grade SDLC workflows and development environments. Candidates are expected to operate agent workflows, supervise autonomous behavior with GitHub controls, evaluate and tune outputs using scans and artifacts, configure custom agents, and coordinate multi-agent execution safely.
This emphasis changes how you should prepare. A study plan based only on prompt writing or model theory will leave important gaps. You need to understand how an agent receives a task, accesses tools and environments, preserves relevant state, produces observable artifacts, passes through review or approval controls, and recovers when its work is incomplete or unsafe.
Microsoft states that the exam is provided by Microsoft, while the exam and associated certification are maintained by GitHub. Treat the GitHub platform, its workflows, controls, coding-agent capabilities, and development practices as the center of your preparation rather than as optional product background.
Is your experience a fit?
GH-600 is a sensible target when you already understand GitHub-based development and can reason about the operational boundaries around AI agents. The official certification profile classifies it as Intermediate and lists AI Engineer, App Maker, Data Engineer, Developer, DevOps Engineer, and Solution Architect among the associated roles.
The expected candidate works with architects, platform engineers, DevOps engineers, application developers, product managers, and security engineers. That does not mean every candidate must hold each job title. It does mean you should be comfortable discussing trade-offs across development, delivery, quality, security, and operational ownership.
The profile calls for experience with the SDLC, GitHub workflows and controls, code quality, security and review practices, GitHub Copilot, MCP servers, custom instructions, custom agents, tools, and Copilot setup steps. Use this list as a readiness screen: mark each area as can explain, can configure, or can troubleshoot.
A candidate who has used GitHub only for source storage should first strengthen repository, branch, pull-request, CI, and CD fundamentals. A candidate who already runs automated workflows but has not worked with agent permissions, state, evaluation, or guardrails should prioritize the agent-specific domains instead.
Do not interpret the audience profile as a formal prerequisite unless the official registration page states one. It describes the capability expected for the role; it is more useful for deciding readiness than for excluding yourself based on job title.
What the blueprint prioritizes
Use the domain ranges to allocate study time, but keep every range attached to its official domain because the percentages describe different capabilities. The largest published range is Domain 2, Implement Tool Use and Environment Interaction, at 20–25%; the remaining domains each have their own published range and should not be treated as interchangeable.
The assessed domains are:
Domain 1: Prepare agent architecture and SDLC processes (15–20%).
Domain 2: Implement Tool Use and Environment Interaction (20–25%).
Domain 3: Manage Memory, State, and Execution (10–15%).
Domain 4: Perform Evaluation, Error Analysis, and Tuning (15–20%).
Domain 5: Orchestrate Multi-Agent Coordination (15–20%).
Domain 6: Implement Guardrails and Accountability (10–15%).
A practical allocation is to give extra attention to Domain 2, then pair Domain 1 with Domain 3 so that architecture decisions connect to execution behavior. Study Domain 4, Domain 5, and Domain 6 through the same end-to-end workflow: define a task, allow an agent to act, inspect the result, coordinate additional work where appropriate, and apply controls before acceptance.
The study guide says the bullets under each skill are illustrative and that related topics may also be covered. It also says most questions address generally available features, although commonly used preview features may appear. Therefore, do not memorize a narrow list of feature names and assume that list defines the entire assessment.
Turn ranges into decisions
Blueprint ranges are planning signals, not a promise about the exact number or format of questions. For each domain, write a short explanation of the problem it solves, identify the GitHub control or workflow involved, and record one failure mode that the design must prevent.
Your notes should answer questions such as: What belongs in an agent architecture and SDLC boundary? Which tool or MCP permission is necessary for a task? What state must persist between actions? How will success be measured? When should several agents coordinate? Which human or automated control can stop unsafe execution?
Build the foundation before agent features
Start with the official learning path if repositories, branches, pull requests, CI/CD, or basic AI concepts are not yet comfortable. It lists a GitHub account, basic AI fundamentals, basic knowledge of repositories, branches and pull requests, and general CI and CD knowledge as prerequisites for that path.
The path is organized around three modules: Foundations of Agentic AI in GitHub; Designing Agent Architecture and SDLC Integration; and Tooling, MCP, and Agent Execution Environments. It is listed as Part 1 of 2, so use it as a foundation rather than assuming it covers every exam domain.
A good first pass should establish distinctions that later domains depend on: an agent task versus a workflow, planning versus execution, an input versus an output artifact, and autonomy versus authorized action. Then connect each distinction to a repository or delivery process.
If you are already strong in GitHub development, do not spend your entire preparation rereading introductory material. Skim the foundation, verify that you can explain the concepts without notes, and move to configuration, evaluation, coordination, and governance. The goal is not to finish every resource in order; it is to close capability gaps revealed by the blueprint.
Study tools, environments, and execution
Domain 2 deserves deliberate hands-on preparation because it covers how agents use tools and interact with development environments. Practice reasoning from a task to the minimum tools, permissions, context, and execution boundary needed to complete it safely.
The official learning path specifically includes agent tools, permissions, MCP servers, and GitHub workflows. Build a small mental model for each: what the tool does, what data it can access, what action it can take, who authorizes it, and what evidence it leaves behind.
When reviewing an agent design, ask whether the agent can perform only the requested operation or whether its access is broader than necessary. Consider how an incorrect tool call could affect source, dependencies, tests, deployment configuration, or sensitive information. Then identify where a review, approval, scan, or workflow boundary should intervene.
Custom instructions, custom agents, tools, and Copilot setup steps are listed in the candidate profile. Study them as configuration choices with consequences, not as isolated vocabulary. Be able to explain when customization improves consistency and when it could create hidden assumptions, excessive permissions, or an unclear ownership model.
A useful lab does not need to reproduce a live exam task. Choose a harmless repository exercise, define the agent’s input and expected artifact, document its permitted tools, and inspect the resulting changes. Record what the agent could not do and whether that limitation was intentional.
Connect memory, state, and evaluation
An agent that can act is not automatically reliable; GH-600 also expects you to reason about memory, state, execution, measurement, and tuning. Study these as a chain: preserve the right context, observe what happened, compare the result with a defined success signal, and adjust the system based on evidence.
For memory and state, distinguish information that should persist from information that should be discarded after a task. Consider how progress is represented, how a later action knows what an earlier action completed, and what happens when execution stops or resumes in another environment.
For evaluation, define the expected behavior before inspecting an output. Useful study artifacts include a task statement, acceptance conditions, generated changes, test or scan results, execution trace, and a short error analysis. The point is to identify why an agent failed, not simply to label the result good or bad.
Tuning should follow diagnosis. If an agent selects the wrong tool, review its tool description or permission boundary. If it produces incomplete work, examine task decomposition, context, state handling, or stopping conditions. If it produces unsafe work, inspect guardrails and approval points rather than merely asking for a more confident response.
The official course describes performance evaluation, governance, guardrails, and management of memory, state, and execution as core topics. Use those topics to organize your lab notes and avoid studying evaluation as an afterthought.
Prepare for coordination and governance
Multi-agent coordination and accountability require system-level judgment: assign distinct responsibilities, make handoffs visible, control shared resources, and retain a safe way to stop or recover execution. Prepare to explain why a single agent is insufficient and what additional complexity coordination introduces.
For a coordinated workflow, specify the role of each agent, the input and output passed between agents, the source of truth for progress, and the condition that permits the next step. Look for ambiguous ownership, duplicated actions, circular handoffs, and conflicting edits.
The Microsoft learning material highlights observable workflows, coordinated artifacts, and safe recovery mechanisms for multi-agent systems. Translate those ideas into review questions: Can an operator see which agent acted? Can another agent verify the artifact? Can the workflow resume without repeating a destructive action? Can a failed participant be isolated?
Guardrails and accountability should be studied alongside autonomy. Review least-privilege access, human-in-the-loop approvals, governance, auditability, security checks, and recovery. The official source specifically identifies GitHub-native controls, human-in-the-loop approvals, and least-privilege access as governance themes.
A common mistake is to treat more agents as automatically better. Coordination adds interfaces, state transitions, failure modes, and ownership questions. In a practice design, first produce a reliable single-agent flow; only then justify splitting work into specialized agents and define the controls that make the handoff safe.
Use the official course and learning path strategically
The related instructor-led course is GH-600T00-A, Developing in Agentic AI Systems. Microsoft lists it as Intermediate, English-language, and one day, with coverage of agent architectures, tools and environments, memory, state and execution, performance evaluation, governance, guardrails, and multi-agent coordination.
The course can be useful as a structured overview, but its listed duration is not a guarantee that one day is enough for exam readiness. Candidates who lack the underlying GitHub and SDLC experience will need additional practice; experienced candidates may use the course to identify which domains require deeper work.
The learning path is a better starting point for candidates who need foundations in agentic AI, architecture and SDLC integration, or tooling, MCP, and execution environments. The course and path should be paired with the study guide, because the study guide is the document that organizes the exam’s measured skills.
Microsoft Reactor also published a GH-600 certification deep-dive session focused on the official exam objective domains and study guides. Treat an event or recording as orientation and explanation, not as a substitute for building the capabilities named in the blueprint.
Do not assume that completing a course, path, livestream, or sandbox grants exam readiness. After each resource, demonstrate the skill without copying the lesson: design a bounded workflow, configure its tools, inspect its artifacts, evaluate its behavior, and explain its safeguards.
A practical study roadmap
A staged roadmap works best when each stage ends with evidence of capability rather than passive completion. Use the official domains as the checklist, select one small GitHub-based workflow for practice, and increase its complexity only after you can explain its boundaries and failure handling.
Stage one is readiness and orientation. Review the audience profile, list your strengths and gaps, and confirm the foundation topics from the learning path. If GitHub workflows, pull requests, CI/CD, or AI fundamentals are weak, repair those gaps before concentrating on advanced agent coordination.
Stage two is architecture and execution. Work through agent task definitions, inputs and outputs, planning and execution boundaries, tools, permissions, MCP servers, and environment interaction. Produce a one-page design showing the agent’s allowed actions, expected artifacts, and points where the workflow stops for review.
Stage three is state and quality. Add a representation of progress, decide what context persists, and create success signals. Run or review several outcomes, including an incomplete or incorrect result, then write an error analysis that separates task-design, tool, context, state, and control problems.
Stage four is coordination and governance. Split a workflow only where specialization has a clear benefit. Define handoffs, shared artifacts, recovery, approval, least privilege, accountability, and security checks. Revisit the design from the perspective of a developer, operator, reviewer, and security engineer.
Stage five is blueprint review. Return to all six domains, with particular attention to Domain 2: Implement Tool Use and Environment Interaction (20–25%), Domain 1: Prepare agent architecture and SDLC processes (15–20%), Domain 4: Perform Evaluation, Error Analysis, and Tuning (15–20%), Domain 5: Orchestrate Multi-Agent Coordination (15–20%), Domain 3: Manage Memory, State, and Execution (10–15%), and Domain 6: Implement Guardrails and Accountability (10–15%). The labels must remain attached to the ranges in your notes.
Stage six is exam-environment practice. Use the official exam sandbox to experience the interface and available question interaction before scheduling or sitting the assessment. It can reduce interface uncertainty, but it does not reveal live questions or replace technical study.
Avoid these preparation traps
The most damaging mistakes are usually study-design mistakes: learning feature names without understanding boundaries, ignoring lower-weight domains, and treating an agent’s successful output as proof that the system is production-ready. Correct those habits by requiring a design rationale and observable evidence for every practice exercise.
Do not study only GitHub Copilot. The candidate profile also includes MCP servers, custom instructions, custom agents, tools, setup steps, SDLC controls, code quality, security, and review practices. Copilot knowledge is relevant, but it is one part of a broader agentic-system role.
Do not equate autonomy with unrestricted access. A strong design limits tools and permissions, defines approval points, records artifacts, and provides recovery. When reviewing a scenario, ask what the agent is allowed to change and how a human or workflow can intervene.
Do not memorize domain percentages without their labels. Domain 2’s 20–25% concerns tool use and environment interaction, while Domain 3’s 10–15% concerns memory, state, and execution; the numbers are not interchangeable study topics.
Do not rely on exam dumps, leaked questions, or memorized answer keys. They cannot establish that you can configure, evaluate, supervise, or govern an agent, and they do not guarantee a passing result. Use legitimate objectives, Microsoft Learn material, and your own controlled practice instead.
Do not treat preview behavior as universal. The study guide says most questions cover GA features and that commonly used preview features may appear. Check current official material for feature status and study the underlying decision, not an unverified screenshot or third-party claim.
Confirm delivery and registration details
Before booking, verify the current exam page because availability, language options, pricing, and scheduling details can change. The confirmed page states that GH-600 is proctored, may include interactive components, provides 120 minutes for the assessment, and can be scheduled through Pearson VUE.
The certification page currently lists English as an exam language. The study guide explains that localized versions may be updated approximately eight weeks after the English version and that other available languages appear in the Schedule Exam section. If your preferred language is unavailable, the study guide says you can request an additional 30 minutes.
Microsoft recommends registering with a personal Microsoft account. Using an organizational work or school account can create a serious record-keeping problem if you later leave that organization, because the certification page warns that exam records could be lost and unrecoverable.
The exam sandbox is the practical pre-test action to take before registration or at least before the appointment. It lets you experience the look and feel of the exam and interact with different question types in the same user interface used during the exam; it is not a source of live exam content.
The certification page states that the price is based on the country or region where the exam is proctored. Check the registration flow for the amount applicable to you rather than relying on an old article or an unofficial listing. Review accommodation options early if you use assistive devices, need extra time, or require another modification.
The official certification page reports a passing score of 700 or greater, and the study guide repeats that requirement. Treat the score as a fixed official requirement, not as a target to reverse-engineer from practice tests; your preparation should aim for consistent understanding across all domains.
Decide when to schedule
Schedule when you can explain the six domains, complete a bounded agent workflow, diagnose an unsuccessful outcome, and justify permissions, approvals, handoffs, and recovery. A calendar date alone is not a readiness measure, and completing a one-day course does not prove that the operational skills are in place.
Use a simple readiness review before committing: Can you map an unfamiliar scenario to an exam domain? Can you choose tools and permissions rather than grant broad access? Can you distinguish memory from execution state? Can you define evaluation signals? Can you design multi-agent handoffs? Can you identify where governance and accountability belong?
If several answers are uncertain, delay scheduling and turn each uncertainty into a small practical exercise. If the technical answers are strong but the interface or registration process is unfamiliar, use the sandbox and review the official appointment instructions rather than adding more general reading.
Microsoft documents a retake policy in which a failed certification exam may be retaken 24 hours after the first attempt; subsequent retake timing varies. That policy is a recovery option, not a reason to schedule before you understand the blueprint. Check the current policy before relying on it.
Your final review checklist
The final review should be short, active, and tied to decisions you may need to make in a scenario. Replace broad rereading with a domain-by-domain explanation and one concrete design artifact that shows how the parts work together.
Confirm that you can:
Explain GitHub’s role as system of record and control plane in an agentic SDLC workflow.
Define agent tasks, inputs, outputs, planning boundaries, execution boundaries, and expected artifacts.
Select tools, permissions, MCP servers, and environments appropriate to a task.
Describe how memory, state, and execution progress are managed across steps or environments.
Evaluate an output using tests, scans, artifacts, or other defined success signals and perform error analysis.
Design a justified multi-agent workflow with explicit roles, handoffs, coordination, observability, and recovery.
Apply governance through least privilege, human approval, security and review practices, accountability, and guardrails.
Distinguish generally available features from preview features and verify current product information in official sources.
Confirm the current language, scheduling, accommodation, account, and delivery details on the official certification page.
On the day before scheduling, do not replace weak domains with last-minute memorization. Recheck your account choice, review the sandbox, gather only permitted materials, and make sure your study notes use the exact domain labels and ranges. Then schedule through the official route when your readiness evidence supports the decision.
Conclusion
GH-600 preparation is strongest when it mirrors the responsibility being assessed: design a bounded agent workflow, give it appropriate tools, observe its execution, evaluate its results, coordinate work carefully, and enforce accountability. Start with the official study guide and learning resources, use the domain ranges to expose weak areas, and validate your understanding through controlled practice rather than recalled answers. Before booking, confirm the live certification page for language, registration, accommodations, price, and delivery details, then use the exam sandbox to remove avoidable interface uncertainty.
Related exams
- AI-200 exam — Developing AI Cloud Solutions on Azure
- PL-500 exam — Microsoft Power Automate RPA Developer
- SC-100 exam — Microsoft Cybersecurity Architect