GH-600 Exam Guide: Developing in Agentic AI Systems
GH-600 validates the ability to design, operate, integrate, supervise, evaluate, and govern AI agents inside production-grade software development lifecycle workflows, with GitHub serving as the system of record and control plane. It is intended for practitioners working across development, DevOps, architecture, security, and AI engineering responsibilities. This guide helps you decide whether your current experience is sufficient, which exam domains deserve the most study time, how to build practical preparation exercises, and when to schedule through the official exam route.
What GH-600 actually validates
GH-600 is the exam associated with the GitHub Certified: Agentic AI Developer certification, titled “Developing in Agentic AI Systems.” The assessment is focused on applying agentic systems within GitHub-based SDLC workflows, not simply describing generative AI concepts or writing isolated code snippets.
The certification emphasizes production-oriented judgment. A candidate should understand how an agent receives work, uses tools, interacts with development environments, preserves relevant memory and state, produces observable artifacts, and operates within review, security, and governance controls.
Microsoft states that the exam is provided by Microsoft while the exam and associated certification are maintained by GitHub. The certification is classified as Intermediate and is associated with GitHub. Listed roles include AI Engineer, App Maker, Data Engineer, Developer, DevOps Engineer, and Solution Architect.
The practical capability behind the credential
The target candidate can operate agent workflows inside the SDLC, supervise autonomous behavior with GitHub controls, evaluate and tune outputs using scans and artifacts, configure custom agents, and coordinate multi-agent execution safely.
That profile is broader than a developer who has only used an AI coding assistant. Preparation should therefore include system boundaries, permissions, handoffs, evaluation signals, recovery, and accountability. If your experience is limited to prompting an assistant, begin with the foundational learning path before attempting domain-focused revision.
Who should prepare for this exam
GH-600 is best suited to practitioners who already understand software delivery and are moving into the design or operation of AI-assisted development workflows. The official profile expects experience with SDLC practices, GitHub workflows and controls, code quality, security, review practices, coding agents, MCP servers, and agent customization.
The most relevant audience includes developers, platform and DevOps engineers, solution architects, AI engineers, application makers, security engineers, and technical leads who must decide how agents should be introduced into controlled engineering processes. Product managers and architects may also benefit when their responsibilities include workflow design or governance.
This is not an official prerequisite list for the certification. It is the capability profile Microsoft associates with the role. Treat it as a readiness test: you should be able to explain not only what an agent can do, but also where it must stop, what evidence it should leave, and how a human or control system reviews its work.
Check your starting point before choosing a study plan
The first related Microsoft Learn path lists a GitHub account, basic AI fundamentals, basic knowledge of repositories, branches and pull requests, and general CI/CD knowledge as prerequisites. Candidates missing these foundations should close those gaps before concentrating on advanced orchestration or guardrails.
Use a short self-assessment. Can you trace a change from an issue through a branch, pull request, review, checks, and deployment? Can you distinguish an agent instruction from a tool permission? Can you describe how an agent’s state persists and how its output is evaluated? Gaps in these answers identify your first study block.
How the six measured domains shape preparation
The blueprint contains six domains. The largest stated range is Domain 2: Implement Tool Use and Environment Interaction at 20–25%, so tool configuration, permissions, MCP servers, and execution environments should receive deliberate attention. Do not study the domains as unrelated features; most realistic decisions connect architecture, tools, state, evaluation, coordination, and controls.
The official study guide notes that the bullets beneath each skill illustrate assessment coverage and that related topics may also appear. It also states that most questions cover generally available features, although commonly used preview features may be included. Use the current study guide as the authority when product behavior changes.
Domain 1: Prepare agent architecture and SDLC processes (15–20%)
Study how an agentic workflow fits into the SDLC. Focus on defining the task, inputs, outputs, execution boundaries, responsibilities, and points where GitHub workflows and review controls apply.
A useful exercise is to take a routine repository task and document its lifecycle: trigger, context, tools, proposed change, validation, approval, and recovery path. Then identify which step requires human judgment and which step can be automated safely.
Domain 2: Implement Tool Use and Environment Interaction (20–25%)
This domain covers the practical interface between an agent and its environment. Review tools, permissions, MCP servers, development environments, and the safeguards that constrain actions.
Do not memorize tool names without understanding authorization. For each tool in a practice workflow, record what data it can access, what action it can perform, what result it returns, and what happens when it fails or receives unsafe input.
Domain 3: Manage Memory, State, and Execution (10–15%)
Prepare to reason about what an agent knows, what it should retain, how progress is persisted, and how execution proceeds across steps or environments. Separate short-lived task context from durable state and consider the risks of stale or irrelevant information.
Build a small state diagram for a multi-step task. Mark initialization, transitions, checkpoints, interruption, retry, and completion. This makes abstract questions about execution behavior easier to analyze.
Domain 4: Perform Evaluation, Error Analysis, and Tuning (15–20%)
This domain requires more than checking whether an output looks plausible. Study success criteria, evaluation signals, error analysis, scans, artifacts, and tuning decisions that improve reliability and usefulness.
For a practice agent, define expected behavior before running it. Collect its proposed changes and supporting artifacts, classify errors, and change one factor at a time. The goal is to learn how evidence leads to a tuning decision rather than treating every failure as a prompt-writing problem.
Domain 5: Orchestrate Multi-Agent Coordination (15–20%)
Multi-agent work introduces task decomposition, coordination, communication, observable workflow steps, artifact handoffs, and safe recovery. Study when dividing work improves control and when it merely adds unnecessary complexity.
Design a workflow with clearly separated roles, such as planning, implementation, and validation. Specify the input and output contract for each role, the authority each agent has, and the condition that sends work back for correction.
Domain 6: Implement Guardrails and Accountability (10–15%)
Guardrails and accountability concern safe operation: governance, least-privilege access, human-in-the-loop approvals, auditability, recovery, and controls that make autonomous behavior reviewable.
When studying a feature, ask four questions: What can the agent do? What may it access? Who approves consequential actions? What evidence remains after execution? These questions help connect security controls to the operational scenario presented in an assessment item.
A preparation sequence that follows the work
A strong study order is foundations first, then architecture and tools, followed by state and evaluation, and finally multi-agent coordination and governance. This sequence mirrors the dependencies in an agentic workflow: you cannot evaluate a system clearly until you know what it is supposed to do, and you should not orchestrate agents before defining their boundaries.
Use the official GH-600T00-A course or the related self-paced path as a content map, then turn each topic into an observable practice task. Reading alone is unlikely to expose confusion about permissions, state transitions, or evidence. Build, inspect, and explain a small workflow instead.
Stage one: establish the GitHub and SDLC baseline
Review repositories, branches, pull requests, checks, CI/CD concepts, code review, and security practices. Connect each item to an agent workflow rather than studying it as platform vocabulary.
Your checkpoint is a written workflow that shows where an agent may plan, modify, test, request review, and stop. If you cannot identify the control points, postpone scheduling and strengthen the baseline.
Stage two: map architecture, tools, and environments
Work through the learning path modules on agentic AI foundations, agent architecture and SDLC integration, and tooling, MCP, and execution environments. For every component, note its purpose, inputs, outputs, authority, and failure mode.
The official course describes coverage of agent architectures, tools and environments, memory, state and execution, performance evaluation, governance, guardrails, and multi-agent coordination. Use that course scope to check that your notes cover the complete system rather than one favorite tool.
Stage three: practice evidence-based evaluation
Create expected outcomes and validation checks before asking an agent to act. Inspect generated changes, test results, scans, logs, or other artifacts available in the workflow. Classify whether a failure comes from context, planning, tool access, execution, evaluation, or policy.
This prevents a common mistake: changing instructions repeatedly without identifying the actual failure source. A candidate who can explain why an agent failed is better prepared for scenario questions than one who has only collected successful demonstrations.
Stage four: add coordination and governance
Only after the single-agent workflow is clear should you split work among agents. Define contracts between agents, prevent duplicate authority, and establish recovery when one agent produces incomplete or conflicting work.
Then review least privilege, approval gates, accountability, and audit evidence. Governance is not a final paragraph added to an architecture; it changes how tasks, tools, state, and handoffs are designed.
A practical study roadmap
Use a roadmap with deliverables rather than an arbitrary number of reading sessions. Begin by measuring your baseline against the six domains, study the official material in dependency order, and finish with scenario review and exam-environment practice. Schedule only when you can explain trade-offs across the domains without relying on memorized wording.
The roadmap below is a recommendation, not an official Microsoft schedule. Adjust it to your experience, access to practice environments, and the date shown in the official scheduling system.
Step 1: baseline and scope
Read the official study guide and write one page for each domain: purpose, key decisions, likely failure modes, and evidence you would inspect. Mark each page as strong, developing, or unfamiliar.
Confirm the current exam details before booking. The study guide is the source for the measured skills, scoring information, language guidance, accommodations, and exam sandbox.
Step 2: build one controlled agent workflow
Use a repository-based task that can be reviewed safely. Define the agent’s objective, context, tools, permissions, expected artifacts, and stopping conditions. Keep the scope narrow enough that you can inspect every action.
Document the architecture and SDLC integration after the exercise. This creates revision material for Domain 1 while also exposing gaps in Domains 2, 3, and 6.
Step 3: test state, evaluation, and recovery
Interrupt the workflow, provide incomplete context, and introduce a validation failure in a controlled setting. Record how state is handled, how the agent detects the problem, and how a human or later step resumes work.
Create an evaluation table with expected behavior, observed behavior, evidence, error category, and proposed tuning change. This is more useful than a list of disconnected feature definitions.
Step 4: model multi-agent execution
Divide the workflow into roles only where separation improves reliability or control. Define handoff artifacts, ownership, permissions, validation, and recovery for each role.
Review whether the same result could be achieved with one agent. Being able to justify not using multi-agent orchestration is part of sound engineering judgment.
Step 5: consolidate and verify readiness
Revisit weak domains using the official course and learning path. Explain each concept in terms of a repository workflow, a control boundary, and an observable result.
Use the official exam sandbox to become familiar with the question interface and interactive components. Do not treat unofficial question collections or copied exam content as a substitute for understanding; they cannot establish that you can apply the skills measured by the blueprint.
Exam delivery and scheduling details that are confirmed
Microsoft states that GH-600 provides 120 minutes to complete the assessment. The exam is proctored and may include interactive components, and Microsoft provides an exam sandbox to demonstrate the interface and question types. Confirm the current appointment details and policies before scheduling because operational information can change.
The certification page lists English as an exam language and directs candidates to schedule through Pearson Vue. Microsoft strongly recommends registering with a personal Microsoft account because records tied to an organizational work or school account may be lost and unrecoverable if the candidate leaves that organization.
The price is based on the country or region in which the exam is proctored. Do not rely on a generic price shown elsewhere; check the official scheduling flow for the applicable amount and appointment availability.
Language and accommodations
The study guide explains that localized exam versions may be updated approximately eight weeks after the English version, although this timing is not guaranteed. Other available languages are listed in the Schedule Exam section of the exam details page.
If the exam is not available in your preferred language, Microsoft states that you can request an additional 30 minutes. Candidates who need assistive devices, extra time, or another modification should review the official accommodation process before booking rather than waiting until the appointment.
Scoring, retakes, and certification maintenance
A score of 700 or greater is required to pass. Microsoft states that a failed certification exam may be retaken 24 hours after the first attempt; later retake intervals vary under the full retake policy.
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. Connect your certification profile to Microsoft Learn so you can schedule and renew exams and share or print certificates.
How to use the blueprint without misreading it
Blueprint percentages indicate the stated weighting ranges for domains, not a promise about an exact question mix or a reason to ignore the smaller domains. Allocate extra practice to Domain 2: Implement Tool Use and Environment Interaction (20–25%), while still building working coverage of every other domain.
Avoid comparing bare percentages. Domain 1: Prepare agent architecture and SDLC processes is 15–20%; Domain 3: Manage Memory, State, and Execution is 10–15%; Domain 4: Perform Evaluation, Error Analysis, and Tuning is 15–20%; Domain 5: Orchestrate Multi-Agent Coordination is 15–20%; and Domain 6: Implement Guardrails and Accountability is 10–15%.
These ranges should guide study allocation, not replace the skill descriptions. A question can require several capabilities at once. For example, selecting a tool safely may depend on architecture, execution boundaries, permissions, evaluation, and accountability.
Turn each domain into a decision checklist
For architecture, ask whether the task, inputs, outputs, and boundaries are explicit. For tools, ask whether access is necessary and least privileged. For state, ask what must persist and how execution resumes. For evaluation, ask what evidence defines success. For coordination, ask who owns each handoff. For guardrails, ask who approves consequential behavior and what is recorded.
This approach converts a broad blueprint into repeatable reasoning. It also reduces the temptation to learn isolated terminology without understanding when a design choice is appropriate.
Common preparation mistakes and their fixes
Most weak preparation plans fail through misalignment: they emphasize prompt tricks, ignore SDLC controls, or treat a successful demonstration as proof of reliability. GH-600’s official role profile points toward operating, supervising, evaluating, configuring, and governing agents, so preparation must include the system around the model.
Use the following corrections to keep study practical and evidence-led.
Mistake: studying only the coding assistant experience
Correction: trace the entire workflow from task definition through review and validation. Include tools, MCP servers, custom instructions, custom agents, permissions, artifacts, and stopping conditions. The exam’s audience profile expects more than conversational use of an AI assistant.
Mistake: memorizing features without boundaries
Correction: for every feature, write what it enables, what it cannot safely do, what access it needs, and how its result is checked. Scenario questions are easier when you reason from authority and outcome rather than recall a product label.
Mistake: ignoring failure and recovery
Correction: deliberately examine incomplete context, failed checks, unavailable tools, conflicting outputs, and interrupted execution in a controlled exercise. Record the recovery path and the evidence that shows whether recovery succeeded.
Mistake: treating preview behavior as permanent
Correction: prioritize generally available features because the study guide says most questions cover GA features. Review commonly used preview features only with current official documentation and do not assume that an earlier interface or behavior remains unchanged.
Mistake: using dumps as the main preparation method
Correction: use the official blueprint, Microsoft Learn materials, course content, learning path, and exam sandbox. Memorized or leaked-looking material cannot replace the ability to design a safe workflow, interpret artifacts, or select an appropriate control. It also creates a risk of studying obsolete or inaccurate content.
Mistake: booking before checking account and language details
Correction: connect the certification profile to Microsoft Learn, register with a personal Microsoft account when scheduling, verify the available language, review accommodations if needed, and confirm the current appointment information through Pearson Vue.
The official resources worth using first
Start with the GH-600 study guide because it defines the audience profile, measured domains, scoring information, exam sandbox, language guidance, and related preparation links. Then use the certification page for scheduling and delivery details.
The GH-600T00-A course provides a concentrated course structure and is listed as an intermediate, English-language, one-day course. The related learning path provides a self-paced route covering foundations, architecture and SDLC integration, and tooling, MCP, and execution environments. Use the course as a structured overview and the path as a sequence for building fundamentals.
Use supplementary official content selectively
The Microsoft Reactor GH-600 session is presented as a technical roadmap that unpacks the official exam objective domains and study guides. It can help organize revision, but it should supplement rather than replace the study guide.
Microsoft’s GitHub Agentic AI resource collection also points to topics including multi-agent systems and orchestration, memory, state and evaluation, and governance, guardrails, and operations. Select resources that answer a specific gap in your study notes instead of browsing broadly without a practice objective.
When to schedule GH-600
Schedule when your readiness evidence is consistent across all six domains, not merely when you finish reading. You should be able to design a bounded agent workflow, explain its tools and state, interpret evaluation artifacts, describe multi-agent handoffs, and justify governance controls using concrete SDLC scenarios.
Before committing, open the current certification and study-guide pages, inspect the official exam sandbox, verify language and accommodations, and confirm the available appointment information through the scheduling route. These checks protect you from relying on catalogue summaries or older third-party details.
If your baseline is weak in repositories, pull requests, CI/CD, or AI fundamentals, follow the listed learning-path prerequisites first. If your baseline is strong but your agent experience is shallow, spend your time on controlled practice with permissions, state, evaluation, and recovery rather than repeating introductory AI definitions.
A final readiness test
Give yourself a new agentic SDLC scenario and explain your design without looking at notes. State the task boundary, required tools, permissions, memory and state behavior, evaluation evidence, coordination model, guardrails, approval points, and recovery path.
If your answer relies on “the agent will figure it out,” the design is not ready. If you can identify observable evidence and explain why each control exists, you are practicing the type of applied reasoning the official role profile describes.
Next actions for a focused GH-600 plan
Download or open the official study guide, mark your confidence against each domain, and choose one repository-based practice workflow. Study architecture and SDLC integration before adding tools, then test state, evaluation, coordination, and guardrails with written evidence.
After each exercise, update a concise decision log: the problem, the agent’s authority, the artifact produced, the validation result, the failure mode, and the control that should change. This log becomes a revision aid and exposes gaps more reliably than passive rereading.
Finally, use the official certification page to confirm current scheduling, language, account, delivery, and policy details. Keep the date of your own review in your notes and recheck the official sources before booking, especially for product features or exam information that may change.
Conclusion
GH-600 preparation is strongest when it treats an AI agent as part of a controlled engineering system rather than as an isolated assistant. Build from GitHub and SDLC fundamentals, practice tool and environment boundaries, test memory and recovery, evaluate outputs with evidence, and add coordination and governance deliberately. Use the official study guide as the final authority for domains and policies, then schedule only after your practice work shows that you can explain safe, reliable agent operation across the complete workflow.
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
