GH-600 Exam Guide: Developing in Agentic AI Systems
GH-600 validates whether you can operate, integrate, supervise, and govern AI agents inside production-grade software development lifecycle workflows using GitHub as the system of record and control plane. It serves developers, AI engineers, DevOps engineers, solution architects, app makers, and related practitioners who work with coding agents, tools, MCP servers, and GitHub controls. This guide helps you decide whether your current experience is sufficient, which exam domains need the most attention, and how to sequence practical study before scheduling.
What does GH-600 certify?
GH-600 is the exam associated with the GitHub Certified: Agentic AI Developer certification, titled “Developing in Agentic AI Systems.” The credential focuses on building and governing agent-enabled development workflows rather than treating AI as only a code-completion feature.
Microsoft describes the target role as someone who can deploy, operate, integrate, supervise, and govern AI agents in production SDLC workflows. GitHub is used as the system of record and control plane, so preparation should connect agent behavior to repositories, workflow controls, code quality, security, and review practices.
The certification is classified as Intermediate. Its listed roles include AI Engineer, App Maker, Data Engineer, Developer, DevOps Engineer, and Solution Architect. That range matters: GH-600 is not limited to a single programming language or a narrow job title. It is aimed at people responsible for how agents are introduced, controlled, evaluated, and operated within development environments.
The exam and certification occupy an unusual ownership arrangement. Microsoft provides the exam, while GitHub maintains the exam and associated certification. Use the current Microsoft Learn certification page for scheduling, policy, language, and availability decisions rather than relying on older announcements or third-party summaries.
Is GH-600 a match for your background?
GH-600 is a sensible target if you already understand the software development lifecycle and can reason about agent behavior, tools, controls, and production risks. If your experience is limited to asking a coding assistant for snippets, study the GitHub workflow and governance material before treating the exam as a near-term booking.
The official audience profile expects experience with SDLC workflows, GitHub controls, code quality, security, and review practices. It also names coding agents such as GitHub Copilot, MCP servers, custom instructions, custom agents, tools, and Copilot setup steps. These are useful signals for a readiness check, not a substitute for reading the current skills outline.
The first Microsoft Learn path lists these prerequisites: a GitHub account, basic AI fundamentals, basic knowledge of repositories, branches, and pull requests, and general knowledge of CI and CD concepts. The path is labelled Beginner and Intermediate, while the related instructor-led course and certification are listed at Intermediate level.
Before scheduling, write down one development workflow you know well. Identify where an agent receives a task, which tools or environment it can use, what outputs it produces, which checks review those outputs, and where a person or policy can stop or redirect execution. Gaps in that explanation indicate where practical study should begin.
Which skills carry the most exam emphasis?
The official blueprint divides GH-600 into six domains. Tool use and environment interaction has the largest published range at 20–25%, while the remaining domains cover architecture, execution state, evaluation, multi-agent coordination, and accountability. Use the domain labels with the percentages when allocating study time; do not plan from isolated numbers.
Domain 1: Prepare agent architecture and SDLC processes (15–20%). Study how agentic work fits into the development lifecycle, including task boundaries, architecture decisions, and workflow integration. Your notes should explain why an agent belongs at a particular point in the lifecycle and what must remain controlled.
Domain 2: Implement Tool Use and Environment Interaction (20–25%). Give this domain first priority because it has the highest published weighting. Focus on how an agent interacts with tools, development environments, MCP servers, permissions, and execution boundaries. Practise distinguishing a useful capability from an unsafe or unnecessarily broad capability.
Domain 3: Manage Memory, State, and Execution (10–15%). Prepare to reason about how an agent maintains progress and operates across execution steps or environments. A useful exercise is to map what information must persist, what state can be discarded, and how execution can be observed or recovered.
Domain 4: Perform Evaluation, Error Analysis, and Tuning (15–20%). Study how agent outputs are assessed using meaningful success signals, scans, and artifacts. Prepare a repeatable review method: define the expected result, inspect the output, classify the failure, change one relevant control, and evaluate again.
Domain 5: Orchestrate Multi-Agent Coordination (15–20%). Learn to reason about task division, coordination, observable workflows, artifacts, and safe recovery when several agents contribute to one outcome. A multi-agent design is not automatically better; it needs clear responsibilities and a way to detect incomplete or conflicting work.
Domain 6: Implement Guardrails and Accountability (10–15%). Review governance, human-in-the-loop approvals, least-privilege access, operational safeguards, accountability, and recovery. Treat this domain as a design requirement that applies across the other domains, not as a final security checklist added after the workflow is built.
The percentages describe the assessed domains, not a guaranteed question distribution or a promise that every listed topic will appear in isolation. Microsoft’s study guide says the bullets under the skills measured illustrate assessment and that related topics may also be covered. Most questions cover generally available features, although commonly used Preview features may also appear.
How should you use the official learning path?
Use the Microsoft Learn path as a foundation, then move from reading to design and troubleshooting exercises. It contains 3 modules and introduces foundations, agent architecture and SDLC integration, and tooling, MCP, and execution environments. Those subjects establish the vocabulary needed for the broader exam blueprint.
Start with Foundations of Agentic AI in GitHub so that you can describe what makes an agentic workflow different from a static automation or a simple coding-assistance interaction. Do not leave the module with only definitions; write a short description of an agent task, its inputs, its outputs, and its execution boundary.
Next, work through Designing Agent Architecture and SDLC Integration. Draw a workflow that shows where planning, reasoning, execution, review, and approval occur. Mark the points at which GitHub controls, repository practices, or CI and CD checks affect the agent’s work.
Finish with Tooling, MCP, and Agent Execution Environments. For each tool in your study design, record its purpose, required permission, expected output, failure condition, and recovery action. This turns passive familiarity into the kind of structured reasoning needed for scenario-based decisions.
The path is listed as Part 1 of 2, so do not assume completing it alone covers the entire certification. Pair it with the GH-600 study guide and the certification page. Use the study guide’s domain outline as the authority for scope, and use learning activities to build understanding rather than attempting to predict individual exam questions.
What should you learn from the GH-600 course?
The related course is GH-600T00-A, “Developing in Agentic AI Systems.” Microsoft lists it as an Intermediate, English-language, 1-day course and says it can be approached through self-directed learning. Its syllabus mirrors the practical concerns of the certification: architecture, tools and environments, memory and state, evaluation, governance, guardrails, and multi-agent coordination.
Use the course as a compact map of the subject, not as evidence that a single day of instruction removes the need for hands-on preparation. After each topic, create a small design decision. For architecture, define boundaries. For tools, define permissions. For memory, define persistence. For evaluation, define success signals. For governance, define approval and recovery.
If you prefer structured instruction, the course gives you a named Microsoft resource to compare with the study guide. If you prefer self-paced preparation, use its topic sequence to organize notes and then validate each note against the official exam domains. The course’s listed audience profile also helps you identify whether your existing GitHub and SDLC experience is adequate.
Avoid copying course headings into a memorization sheet without explaining the relationship between them. For example, a tool choice affects permissions, permissions affect guardrails, and execution state affects evaluation and recovery. A connected model is more useful than six disconnected vocabulary lists.
What practical exercises build the right judgment?
Build one small, controlled agent workflow and inspect it from six perspectives: architecture, tools, state, evaluation, coordination, and accountability. The objective is not to reproduce undisclosed exam content. It is to practise explaining why a design is reliable, what can fail, and which control limits the impact.
Begin with a clearly bounded task in a repository. Define the task input, the expected artifact, the tools the agent may use, and the conditions under which execution must stop. Keep a written record of each choice. If you cannot explain a permission or tool in one sentence, narrow the design before adding more capability.
Add an evaluation pass that checks the resulting artifact against explicit criteria. Include code-quality and security review practices where appropriate, and note which scans or artifacts provide evidence. Then create a failure classification such as incorrect output, incomplete work, unsafe action, or environmental failure. The classification should lead to a different tuning or recovery decision.
For memory and state, sketch what happens if execution pauses, restarts, or moves between environments. Identify the minimum information needed to resume safely. For multi-agent work, assign distinct responsibilities and define the artifact or signal each agent hands to the next one.
Finally, add accountability controls. Identify who can approve a sensitive action, which permissions are least necessary, how a reviewer can inspect the agent’s work, and how the workflow recovers after a rejected or failed step. This single exercise can expose gaps across several domains without depending on live questions or unofficial question banks.
How do you allocate study time across the blueprint?
Allocate effort by published domain range, then adjust for your own experience. Start with Domain 2: Implement Tool Use and Environment Interaction (20–25%), because it has the highest range. Give comparable attention to the three domains at 15–20%, and use targeted review for the two domains at 10–15% rather than ignoring them.
A useful allocation method is to score each domain as ready, developing, or weak after reading the study guide. Ready means you can explain a design choice and its trade-off. Developing means you recognize the terms but need an example. Weak means you cannot yet describe a safe implementation or diagnose a failure. Spend the next study block on the weakest high-weight area.
Do not turn the ranges into artificial precision. The blueprint does not tell you that a particular percentage of your personal study time must equal a domain’s lower or upper bound. It tells you where the assessment emphasis lies. Experience with repositories may reduce the time needed for architecture basics, while unfamiliarity with MCP servers or agent evaluation may require more practical work.
Reassess after each exercise. If your tool design is strong but your explanation of state recovery is vague, move the next session to Domain 3: Manage Memory, State, and Execution (10–15%). If you can describe guardrails but cannot connect them to operational accountability, revisit Domain 6: Implement Guardrails and Accountability (10–15%).
Which preparation mistakes create avoidable gaps?
The most common preparation error is studying agent features as isolated products instead of decisions inside an SDLC. GH-600’s audience profile connects agent operation with GitHub controls, code quality, security, review practices, and production workflows. Your notes should therefore explain consequences, boundaries, and evidence, not merely define tools.
Mistake one is overfocusing on prompt wording. Custom instructions matter, but the certification also covers architecture, tools, state, evaluation, coordination, and governance. Balance configuration knowledge with the ability to choose a control, interpret an output, and respond to a failure.
Mistake two is treating autonomy as the goal. A capable workflow still needs execution boundaries, permissions, review practices, human approval where appropriate, and recovery mechanisms. When reviewing a design, ask what the agent may do, what it may not do, and how the system proves what happened.
Mistake three is skipping evaluation. An agent can produce plausible output that is incomplete, insecure, or unsuitable for the requested task. Practise defining success signals and using scans or artifacts to support a decision. Tuning should follow error analysis rather than vague dissatisfaction with the result.
Mistake four is assuming a course completion equals exam readiness. Learning resources provide structure, but readiness comes from applying the concepts to unfamiliar scenarios. Explain your solution aloud or in writing, identify the trade-off, and state the control that limits risk.
Mistake five is relying on dumps or memorized claims about supposedly repeated questions. Unofficial material cannot establish the current exam scope, may expose candidates to inaccurate or inappropriate content, and does not build the judgment the role requires. Use the official study guide, learning path, course, and exam sandbox instead.
What is the recommended study roadmap?
A practical roadmap has four phases: establish foundations, build one controlled workflow, review the blueprint by weakness, and rehearse the delivery experience. Move forward when you can explain decisions and failure handling, not simply when you have read every page.
Phase one: establish foundations. Confirm that you have a GitHub account, basic AI fundamentals, familiarity with repositories, branches, and pull requests, and general CI and CD knowledge. Complete the learning path modules in sequence. Create a glossary in your own words for agents, tools, environments, memory, state, evaluation, orchestration, guardrails, and accountability.
Phase two: build and inspect. Design a repository-based workflow with a defined agent task, bounded inputs and outputs, selected tools, permissions, and a review point. Map the workflow to Domain 1: Prepare agent architecture and SDLC processes (15–20%) and Domain 2: Implement Tool Use and Environment Interaction (20–25%). Then document what persists and how execution resumes for Domain 3: Manage Memory, State, and Execution (10–15%).
Phase three: test the design. Introduce a deliberately incomplete or incorrect output and write an error analysis. Decide which signal, scan, or artifact reveals the problem and what tuning action follows. Extend the design with a second cooperating agent only after the single-agent workflow is understandable. Add coordination, safe recovery, least-privilege access, approval, and accountability controls.
Phase four: use the official exam sandbox and perform a blueprint review. The sandbox demonstrates the look and feel of the exam and its different question types. Mark any domain where you still confuse similar concepts. Finish by reviewing Domain 4: Perform Evaluation, Error Analysis, and Tuning (15–20%), Domain 5: Orchestrate Multi-Agent Coordination (15–20%), and Domain 6: Implement Guardrails and Accountability (10–15%) in the context of your workflow.
Keep a decision log during the roadmap. Each entry should contain the scenario, chosen design, alternative considered, risk, control, evidence, and recovery action. This is more useful than rereading the same page because it forces you to connect the exam’s terms to operational choices.
What are the official GH-600 delivery details?
Microsoft states that GH-600 provides 120 minutes to complete the assessment. The exam is proctored and may include interactive components, so candidates should prepare for more than passive recall and should explore the official exam sandbox before scheduling.
The certification page lists English as an exam language and directs candidates to schedule through Pearson Vue. The study guide explains that some exams are localized and that localized versions are updated approximately eight weeks after the English version is updated, although the schedule is not guaranteed. Check the Schedule Exam section for current language availability.
If the exam is not available in your preferred language, the study guide says you can request an additional 30 minutes. Treat this as an accommodation or scheduling decision to verify in the current official process, not as an automatic extension applied to every appointment.
The published passing requirement is a score of 700 or greater. This is a scaled score requirement, not a promise that a fixed number or percentage of questions must be correct. Microsoft does not use the published passing score to disclose a guaranteed question count or domain-by-domain pass threshold.
The price depends on the country or region in which the exam is proctored. Confirm the amount and appointment options during the official Pearson Vue scheduling process. The certification page strongly recommends registering with a personal Microsoft account because records connected to an organizational work or school account may become unrecoverable if you leave that organization.
Request accommodations before booking if you use assistive devices, need extra time, or need a modification to the exam experience. The official study guide provides an accommodations route, while the certification page provides the exam and scheduling entry points.
When should you schedule the exam?
Schedule when you can explain the complete agent lifecycle and have verified the current exam details, not merely when you finish a course. A reasonable readiness gate is the ability to map a workflow across all six domains, defend tool and permission choices, interpret evaluation evidence, and describe safe recovery.
First, review the current certification page and study guide because language, delivery, policies, and feature coverage can change. The study guide notes that most questions cover generally available features, while commonly used Preview features may also appear. Your final review should therefore distinguish stable concepts from feature-specific behavior that needs current verification.
Second, confirm your Microsoft Learn profile and account arrangement. Microsoft says connecting the certification profile to Microsoft Learn allows you to schedule and renew exams and share and print certificates. Use a personal Microsoft account for registration as recommended on the certification page, especially if your learning activity is tied to an employer or school.
Third, use the sandbox before the appointment. Learn how the interface presents different question types and identify how you will manage time across reading, analysis, and any interactive elements. Do not infer the exam’s undisclosed question count or actual content from the demonstration.
If your readiness depends on a future launch or availability claim, verify the live scheduling page instead of relying on announcements or community answers. The Microsoft Q&A material records discussion about the exam’s beta and live timing, but it is not a substitute for the current official appointment system.
How should you manage the final review?
The final review should compress your notes into decisions and relationships. Revisit the official domain outline, then test whether you can choose an architecture, tool boundary, state model, evaluation method, coordination pattern, and accountability control for a new scenario without searching for a memorized answer.
Prepare one page per domain, but avoid copying the blueprint verbatim. For architecture, record lifecycle placement and boundaries. For tools, record permissions and environment interaction. For state, record persistence and resumption. For evaluation, record evidence and error categories. For orchestration, record roles and handoffs. For guardrails, record approvals, least privilege, and recovery.
Use contrast questions in your review: When is a tool too broad? What evidence distinguishes an agent failure from an environment failure? What state must survive a restart? When should a multi-agent design be simplified? Which action requires human approval? These questions exercise the trade-off reasoning behind production workflows.
Set aside a final check for terminology that you can recognize but not apply. Being able to define MCP servers, custom agents, or custom instructions is less useful than explaining where they fit, what they can access, and how their behavior is monitored and constrained.
Do not use the final session to chase rumored questions or unverified feature lists. Check the official study guide for scope, use Microsoft Learn for concepts, use the course and learning path for structured practice, and use the sandbox for interface familiarity.
What happens after an unsuccessful attempt?
A failed attempt is a signal to analyze the score report and revise the weakest skills, not a reason to memorize more isolated answers. Microsoft states that a retake is available 24 hours after the first attempt; subsequent retake timing varies, so confirm the current retake policy before making another appointment.
After an unsuccessful result, separate knowledge gaps from execution problems. A knowledge gap appears when you cannot justify a design or control. An execution problem appears when you understood the scenario but misread a constraint, ran short of time, or mishandled an interactive component. The remedy differs for each type.
Rebuild the relevant workflow rather than rereading every topic equally. If the weakness concerns tools, narrow permissions and document environment boundaries. If it concerns evaluation, create explicit success signals and classify failures. If it concerns coordination, define handoffs and recovery. If it concerns guardrails, add approval and accountability points and explain their purpose.
Do not assume a retake will repeat the same material or that unofficial question collections can predict it. Use the score report, current Microsoft resources, and a new set of design exercises. A second attempt should represent improved reasoning, not just increased exposure to recalled wording.
How is the certification maintained?
Plan for ongoing maintenance if you earn the credential. The GH-600 study guide states that Microsoft associate, expert, and specialty certifications expire annually and can be renewed by passing a free online assessment on Microsoft Learn. Check the credential’s current renewal information and connect your certification profile so that future renewal actions remain associated with your account.
Agentic development practices and GitHub features can change, so continued learning is relevant even after the exam. Revisit the official certification resources when the study guide or exam details change. Pay particular attention to updates affecting generally available features, localized versions, accommodations, and scheduling.
Keep your preparation notes as operational documentation rather than discarding them after the exam. A decision log covering tools, permissions, evaluation signals, state handling, coordination, and guardrails can support later work and make renewal study more efficient.
The renewal statement applies according to Microsoft’s certification policy categories. Do not infer a renewal date, fee, or assessment format beyond what the current Microsoft Learn credential and renewal pages state.
What should you do next?
Start with the official GH-600 study guide, map your experience against all six domains, and complete the learning path before choosing an exam date. Then build one bounded agent workflow, evaluate its outputs, add coordination and guardrails, explore the sandbox, and verify current Pearson Vue details through the certification page.
Use the following order: confirm prerequisites and account access; read the skills measured; complete the learning path; study the related course topics; build and critique a workflow; review weak domains; test the sandbox; request any needed accommodation; and schedule only after checking the live language, policy, and price information.
The strongest preparation decision is to treat GH-600 as an engineering and governance assessment. You need to understand not only what an agent can do, but also how GitHub controls its work, how evidence supports evaluation, how state and coordination affect reliability, and how people remain accountable for consequential actions.
Do not measure readiness by the number of pages read or by access to alleged exam questions. Measure it by whether you can make and defend safe design choices in an unfamiliar agentic SDLC scenario.
Conclusion
GH-600 preparation is most effective when study follows the agent’s complete operating lifecycle: define the architecture, constrain tools and environments, manage state, evaluate results, coordinate work, and enforce accountability. Use the official blueprint to prioritize, the Microsoft Learn resources to build foundations, and a controlled workflow to test your judgment. Before scheduling, verify the live certification details, practise in the exam sandbox, and make sure your account and accommodation arrangements are ready.
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
