GH-600

GH-600 Exam Overview

The GH-600 Developing in Agentic AI Systems exam validates your ability to deploy, operate, integrate, supervise, and govern AI agents within production-grade software development lifecycle workflows.

The exam focuses on using GitHub as the system of record and control plane for agentic development. Candidates must understand how to integrate agents into development workflows, configure tools and Model Context Protocol servers, manage agent memory and execution, evaluate agent outputs, coordinate multiple agents, and implement appropriate guardrails.

Passing the GH-600 exam earns the GitHub Certified: Agentic AI Developer certification. The examination is provided through Microsoft’s certification platform, but the exam and associated certification are maintained by GitHub.

CertQueen GH-600 preparation materials help candidates review the current objectives, practice certification-style questions, identify knowledge gaps, and prepare more efficiently for the official exam.

Page Contents

1. GH-600 Exam Overview

2. GH-600 Exam Information

3. Who Should Take GH-600?

4. Technologies and Services Covered

5. GH-600 Exam Objectives

6. GH-600 vs. AI-103

7. GH-600 Study Plan

8. Original Sample Questions

9. Frequently Asked Questions

10. CertQueen Preparation Materials

11. Disclaimer

GH-600 Exam Information

The passing score is based on a scaled scoring system. A score of 700 does not necessarily mean that candidates must answer exactly 70 percent of the questions correctly.

While GH-600 remains in beta, candidates may not receive their scores immediately. Microsoft states that beta results are generally released after the beta period has concluded and the examination has been evaluated.

Who Should Take the GH-600 Exam?

GH-600 is intended for professionals who operate, integrate, supervise, and govern AI agents within production development environments and software delivery workflows.

Suitable candidates may include:

• Agentic AI developers
• GitHub Copilot administrators and developers
• Application developers using coding agents
• DevOps and platform engineers
• Software and solution architects
• AI engineers working with development agents
• Site reliability engineers
• Application security engineers
• Engineering productivity specialists
• Technical leads coordinating multi-agent development

Candidates should understand the software development lifecycle, GitHub repositories, branches, pull requests, CI workflows, code review, security scanning, development artifacts, and organizational controls.

Practical experience with GitHub Copilot, MCP servers, custom instructions, custom agents, tools, and Copilot setup steps is also recommended.

GH-600 candidates commonly work with architects, platform engineers, DevOps engineers, application developers, product managers, and security engineers to develop and operate agents on the GitHub platform.

GH-600 Technologies and Services

GH-600 focuses on current GitHub and agentic AI capabilities rather than one fixed software version.

Candidates should be familiar with the following technologies and concepts:

• GitHub repositories
• GitHub branches and pull requests
• GitHub Actions and CI workflows
• GitHub Copilot
• GitHub Copilot coding agent
• GitHub Copilot custom instructions
• Custom agents
• Agent tools and tool permissions
• Model Context Protocol servers
• GitHub remote MCP server
• MCP registries and allow lists
• Agent memory and state
• Agent execution environments
• Agent plans, logs, traces, and artifacts
• Automated code and security scanning
• Multi-agent orchestration
• Human-in-the-loop approval workflows
• Agent guardrails and least-privilege access
• Error handling, retries, rollbacks, and escalation

GitHub and Microsoft update cloud services continuously. Candidates should review the current GH-600 study guide and GitHub documentation before taking the exam.

GH-600 Exam Objectives

The GH-600 exam is organized into six domains covering agent architecture, tools, memory, evaluation, multi-agent coordination, and governance.

Domain 1 – Prepare Agent Architecture and SDLC Processes (15–20%)

This domain evaluates whether candidates can design agent responsibilities and integrate agent workflows into the software development lifecycle.

Preparation should include:

• Identifying appropriate SDLC steps for agents to perform
• Recognizing and mitigating common agent anti-patterns
• Defining agent inputs, outputs, and success criteria
• Separating planning, reasoning, and execution
• Configuring an agent to generate a structured plan
• Validating an agent-generated plan
• Preventing execution until a plan has been checked or approved
• Selecting an appropriate level of agent autonomy
• Configuring agents to produce inspectable development artifacts
• Adding human intervention without unnecessarily slowing delivery

Domain 2 – Implement Tool Use and Environment Interaction (20–25%)

This is the largest GH-600 domain. It covers agent tools, MCP servers, development environments, permissions, safe execution, and error handling.

Preparation should include:

• Identifying the tools required by an agent
• Configuring agent tools and permissions
• Applying least-privilege access to tools
• Adding an MCP server as an agent tool
• Configuring the GitHub remote MCP server
• Configuring MCP registries
• Configuring MCP allow lists
• Evaluating an agent’s execution context
• Scoping an agent to a specific repository
• Invoking an agent from a CI workflow
• Using branch-based scope
• Allowing an agent to create branches and pull requests
• Handling environment-specific constraints
• Implementing error handling and retries
• Implementing rollback procedures
• Creating escalation paths
• Preserving traceability and accountability for agent actions

Domain 3 – Manage Memory, State, and Execution (10–15%)

This domain evaluates whether candidates can preserve useful agent context while preventing stale, conflicting, or irrelevant information from influencing execution.

Preparation should include:

• Choosing between short-term, long-term, and external memory
• Limiting memory to task-relevant information
• Defining memory expiration and pruning rules
• Resetting agent memory when appropriate
• Capturing progress and decisions as durable artifacts
• Resuming work without unnecessarily repeating completed steps
• Preventing divergence from previous decisions
• Detecting and correcting context drift
• Sharing state across tools and environments
• Preventing conflicting or stale context

Domain 4 – Perform Evaluation, Error Analysis, and Tuning (15–20%)

This domain covers the evaluation of agent outcomes, failure investigation, and behavior improvement.

Preparation should include:

• Defining expected outcomes for agent tasks
• Defining operational constraints
• Selecting qualitative and quantitative evaluation signals
• Aligning evaluations with development intent
• Generating evaluation signals with automated scanning tools
• Reviewing logs, plans, traces, outputs, and workflow artifacts
• Identifying reasoning failures
• Identifying incorrect tool use
• Identifying context and execution environment problems
• Revising agent instructions and workflows
• Adjusting agent constraints
• Refining memory strategies
• Refining tool selection and tool access

Domain 5 – Orchestrate Multi-Agent Coordination (15–20%)

This domain evaluates whether candidates can safely coordinate multiple agents while maintaining isolation, observability, recoverability, and auditability.

Preparation should include:

• Selecting an orchestration pattern for multiple agents
• Configuring isolation for parallel agent execution
• Detecting overlapping code changes
• Detecting duplicated work and contradictory outputs
• Resolving conflicts between agents
• Producing reviewable and auditable artifacts
• Documenting agent decisions, handoffs, and outcomes
• Performing post-execution analysis
• Identifying failed, partial, or stalled executions
• Responding to degraded coordination
• Implementing rollback and recovery patterns
• Adding human intervention to recovery workflows
• Adding or replacing agents without disrupting active workflows
• Retiring agents while preserving auditability

Domain 6 – Implement Guardrails and Accountability (10–15%)

This domain focuses on controlling autonomous behavior according to operational, security, compliance, and Responsible AI risks.

Preparation should include:

• Classifying agent actions according to risk
• Assigning appropriate autonomy levels
• Identifying actions that require human judgment
• Blocking actions that violate security or compliance policies
• Blocking actions that violate Responsible AI requirements
• Scoping permissions according to least privilege
• Controlling agent execution contexts
• Requiring explicit authorization for irreversible actions
• Creating controlled paths for compliance-sensitive changes
• Minimizing approvals that do not materially reduce risk

GH-600 vs. AI-103

The most important difference is the operating environment. GH-600 focuses on AI agents performing development work inside GitHub repositories and production SDLC workflows. AI-103 focuses on building broader AI applications and agents with Microsoft Foundry and Azure AI services.

GH-600 gives greater attention to repository scope, branches, pull requests, MCP servers, development artifacts, context continuity, agent conflicts, safe autonomous actions, and multi-agent accountability.

AI-103 provides broader coverage of models, RAG, Azure AI Search, computer vision, speech, text analysis, multimodal content, document extraction, Azure infrastructure, and Foundry-based agent development.

GH-600 Preparation Plan

The following six-week plan can be adjusted according to your GitHub, SDLC, and coding-agent experience.

Week 1 – Agent Architecture and SDLC Integration

• Review GitHub repositories, branches, pull requests, reviews, and CI workflows.
• Identify development tasks that can be assigned to agents.
• Define inputs, outputs, constraints, and success criteria.
• Practice separating agent planning from execution.
• Review common agent anti-patterns.

Week 2 – Tools, MCP, and Execution Environments

• Review agent tool selection and tool permissions.
• Configure a supported MCP server for an agent.
• Study GitHub remote MCP server configuration.
• Review MCP registries and allow lists.
• Practice repository and branch-based execution scope.
• Study safe branch and pull request creation.

Week 3 – Memory, State, and Error Handling

• Compare short-term, long-term, and external memory.
• Define memory expiration, pruning, and reset rules.
• Store task progress and decisions as durable artifacts.
• Practice detecting stale context and context drift.
• Review retries, rollbacks, and escalation paths.

Week 4 – Evaluation and Agent Tuning

• Define qualitative and quantitative success signals.
• Review logs, plans, traces, outputs, scans, and artifacts.
• Classify reasoning, tool, context, and environment failures.
• Practice improving instructions, memory, tools, and constraints.
• Review code quality and security scanning results.

Week 5 – Multi-Agent Coordination

• Review common multi-agent orchestration patterns.
• Practice isolating parallel agent tasks.
• Study overlapping code changes and conflicting outputs.
• Document agent handoffs and decisions.
• Review recovery patterns for failed or stalled agents.
• Study agent replacement and retirement procedures.

Week 6 – Guardrails and Final Review

• Classify agent actions according to operational and security risk.
• Apply least-privilege access to tools and environments.
• Define approval requirements for sensitive actions.
• Review human-in-the-loop workflows.
• Complete scenario-based practice sessions.
• Review incorrect answers against the six official domains.
• Recheck the official GH-600 study guide before the exam.

Original GH-600 Sample Questions

The following original questions illustrate knowledge covered by the published objectives. They are not copied from the official GitHub examination.

Question 1

A coding agent can analyze an issue and propose a remediation plan. The organization requires a developer to approve the plan before the agent modifies the repository. What should be configured?

A. A separation between planning and execution with an approval gate

B. Unlimited repository permissions

C. Permanent long-term memory

D. Automatic merging into the default branch

Answer: A

Explanation: Separating planning from execution allows the organization to inspect and approve a structured plan before the agent performs potentially consequential actions.

Question 2

An agent needs access to an external development tool through Model Context Protocol. Only approved MCP servers can be used in the organization. What should the administrator configure?

A. An MCP registry and allow list

B. A public repository

C. Unlimited long-term memory

D. An automatic merge rule

Answer: A

Explanation: MCP registries and allow lists help organizations control which MCP servers and tools are available to agents.

Question 3

An agent resumes a task after an interruption but repeats completed steps and ignores an earlier architectural decision. What should be improved?

A. Durable state and decision artifacts

B. Repository visibility

C. Exam scheduling

D. Image generation settings

Answer: A

Explanation: Persisting progress and decisions as durable artifacts allows an agent to resume work without repeating completed tasks or diverging from earlier decisions.

Question 4

Two agents working in parallel modify the same configuration file and produce incompatible pull requests. Which control would best reduce this problem?

A. Isolated scopes with conflict detection

B. Shared unrestricted write access

C. Removal of all execution logs

D. Permanent approval of every agent action

Answer: A

Explanation: Parallel agents should use isolated task, repository, or branch scopes. The workflow should also detect overlapping changes and conflicting outputs.

Question 5

An agent repeatedly selects the correct task but invokes an inappropriate tool with excessive permissions. Which tuning action is most appropriate?

A. Refine tool selection and reduce tool permissions

B. Increase the agent’s autonomy

C. Remove all evaluation signals

D. Allow direct changes to the default branch

Answer: A

Explanation: The failure is related to tool selection and access. The agent’s tool configuration and permissions should be refined according to least-privilege principles.

Question 6

An agent is authorized to update documentation, but it attempts to delete a protected production environment. What should the workflow do?

A. Block the action and require explicit authorization

B. Allow the action because the agent is autonomous

C. Remove the audit trail

D. Add the action to long-term memory

Answer: A

Explanation: Irreversible and high-risk actions should be blocked by guardrails and routed through an explicit authorization or controlled approval process.

GH-600 Frequently Asked Questions

Is GH-600 difficult?

GH-600 can be challenging because it expects more than basic GitHub Copilot knowledge. Candidates must understand production SDLC controls, MCP configuration, agent memory, error analysis, multi-agent coordination, security, and accountable autonomous execution.

How many questions are on the exam?

A fixed question count is not publicly guaranteed. The exam may contain different question formats and interactive components.

How long do candidates have?

Candidates have 120 minutes to complete the GH-600 exam.

What is the passing score?

The passing score is 700 on a scaled scoring system.

When will beta exam results be available?

Beta examination results are not normally provided immediately. Microsoft indicates that scores may be released approximately eight weeks after the beta period concludes. Actual release timing may vary.

Is GH-600 a Microsoft or GitHub certification?

The examination is provided through Microsoft’s certification platform, but the GH-600 exam and GitHub Certified: Agentic AI Developer certification are maintained by GitHub.

What is the GH-600 retake policy?

Candidates can generally retake the exam 24 hours after the first failed attempt. Different waiting periods may apply to later attempts. Verify the current policy before scheduling another attempt.

How long is the GitHub Certified: Agentic AI Developer certification valid?

Candidates should verify the current validity and renewal policy on the official certification page. The certification is maintained by GitHub, and its terms may differ from other Microsoft role-based certifications.

Should I take GH-600 or AI-103?

Choose GH-600 if you operate coding agents and multi-agent workflows within GitHub-based software delivery processes. Choose AI-103 if you build broader AI applications, RAG solutions, multimodal systems, and agents using Microsoft Foundry and Azure AI services.

Is programming experience required?

Practical development experience is strongly recommended. Candidates should understand source control, CI workflows, code review, security scans, development artifacts, and the behavior of coding agents.

Can Preview features appear on the exam?

Most questions cover generally available features, but commonly used Preview features may appear. Review the current study guide before taking the exam.

How are CertQueen materials updated?

CertQueen reviews its GH-600 preparation materials when GitHub or Microsoft changes relevant objectives, tools, workflows, or certification information. Customers receive free updates for one year from the purchase date.

Are the sample questions actual exam questions?

No. The sample questions on this page are independently written for legitimate study purposes. They do not reproduce confidential live exam content.

CertQueen GH-600 Preparation Materials

CertQueen GH-600 preparation materials are organized around the official objectives and provide focused practice across agent architecture, tools, MCP servers, memory, evaluation, multi-agent orchestration, and governance.

Using the preparation materials can help you:

• Review all six GH-600 exam domains.
• Understand the differences between GH-600 and AI-103.
• Strengthen GitHub-based agent workflow knowledge.
• Review agent tools, permissions, and MCP configuration.
• Practice memory, state, and execution scenarios.
• Analyze reasoning, tool, context, and environment failures.
• Review multi-agent isolation and conflict resolution.
• Understand guardrails and human approval workflows.
• Practice certification-style scenario questions.
• Identify weak areas before taking the exam.

Use CertQueen materials together with the official GH-600 study guide, GitHub documentation, Microsoft Learn training, hands-on repositories, GitHub Copilot, MCP servers, and practical agent workflow experience.

Ready to begin? Review the latest GH-600 practice questions, study the explanations, and build a preparation plan around the objectives you have not yet mastered.

Start Your GH-600 Exam Preparation Today

Disclaimer

CertQueen is an independent exam preparation provider and is not affiliated with, endorsed by, sponsored by, or authorized by GitHub, Inc. or Microsoft Corporation.

GitHub, GitHub Copilot, Microsoft, Microsoft Azure, Microsoft Foundry, Model Context Protocol, and related product names may be trademarks or registered trademarks of their respective owners. They are used on this page for identification and educational purposes only.

The sample questions on this page are independently written study questions. They are not copied from the live GH-600 exam and should not be interpreted as actual or guaranteed exam content.

Certification details are subject to change. Candidates are responsible for reviewing the current official study guide, beta status, registration requirements, exam policies, pricing, and certification terms before purchasing materials or scheduling the examination.

No training course, practice question set, or study guide can guarantee a passing result. Exam success depends on the candidate’s knowledge, practical experience, preparation, and performance during the official examination.