Study guide
1.1 GH-600 Exam Facts and Strategy
GitHub Certified: Agentic AI Developer GH-600
Track your progress as you read
Finished sections get a check mark.
1 Introduction & Exam Overview
1.1 GH-600 Exam Facts and Strategy 1.2 Core Concepts of Agentic AI in GitHub
2 Chapter 1: Agent Architecture & SDLC Integration
1.1 Agent SDLC Integration & Task Boundaries 1.2 Planning vs. Execution Separation & Plan Output 1.3 Agent Observability & Human Intervention Controls
3 Chapter 2: Tool Use & MCP Server Configuration
2.1 Function Calling & Tool Selection 2.2 MCP Architecture, Transports & Registries 2.3 Tool Scoping in CI/CD & Branch Workflows 2.4 Error Handling, Retries & Escalation Paths
4 Chapter 3: Memory, State & Execution
3.1 Short-Term, Long-Term & External Memory 3.2 Durable Artifacts & Context Pruning 3.3 Context Drift & State Continuity
5 Chapter 4: Evaluation, Error Analysis & Tuning
4.1 Evaluation Signals & Automated Scanning 4.2 Root-Cause Failure Classification 4.3 Instruction, Memory & Tool Access Tuning
6 Chapter 5: Multi-Agent Orchestration
5.1 Multi-Agent Orchestration Patterns 5.2 Parallel Execution & Workspace Isolation 5.3 Conflict Detection, Handoffs & Lifecycle Management
7 Chapter 6: Guardrails & Accountability
6.1 Action Risk Classification & Autonomy Levels 6.2 Least-Privilege Permissions & Policy Enforcement 6.3 Authorization Checkpoints & Responsible AI Compliance
1.1 GH-600 Exam Facts and Strategy
Key Takeaways Explain This Topic AI
The official GH-600 page provides 120 minutes for the proctored exam, and the study guide requires a scaled score of 700 or greater; GitHub does not publish a fixed question count or item-format breakdown.
Exam domain weighting heavily prioritizes Tool Use & Model Context Protocol (MCP) Server Configuration (20–25%) and Multi-Agent Orchestration (15–20%).
Candidates are expected to have experience operating, integrating, supervising, and governing AI agents inside production-grade GitHub SDLC workflows.
Effective preparation requires mastering context management, context window pruning, tool error handling, and multi-agent conflict resolution strategies.
Preparation should emphasize applying the official skills measured to trade-offs among agent autonomy, security guardrails, observability, and delivery velocity.
Last updated: August 2026
1.1 GH-600 Exam Facts and Strategy
Quick Answer: The GitHub Certified: Agentic AI Developer (GH-600) exam evaluates a candidate's ability to operate, integrate, supervise, and govern AI agents inside production-grade SDLC workflows. The official certification page provides 120 minutes, and the study guide requires a scaled score of 700 or greater. GitHub does not publish a fixed question count, item-format breakdown, validity period, or renewal requirement. Pricing is based on the country or region in which the exam is proctored. Dominant topic domains include Tool Use & Model Context Protocol (MCP) Server Configuration (20–25%) and Multi-Agent Orchestration (15–20%).
The GitHub Certified: Agentic AI Developer (GH-600) certification is GitHub's role-focused credential for software engineers, DevOps architects, and AI developers building next-generation agentic workflows. As software engineering transitions from passive code completion to autonomous, multi-agent systems, the GH-600 exam validates technical mastery in building robust, goal-directed AI systems that interact directly with repositories, issue trackers, CI/CD pipelines, and external tools.
Exam Specifications & Logistics
The GH-600 exam is proctored and scheduled through Pearson VUE according to the current official certification page. The table below outlines the core administrative and structural parameters of the examination:
- Specification Exam Parameter Detail
- Exam Code GH-600
- Exam Title GitHub Certified: Agentic AI Developer
- Total Question Count Not published by GitHub
- Time Limit 120 minutes (2 hours)
- Passing Score 700 / 1000 scaled points
Registration Fee Based on the country or region in which the exam is proctored; check the official certification page for current local pricing
Question Formats Not published by GitHub
Prerequisites No formal credential is listed; GitHub recommends SDLC, GitHub workflow and control, code quality, security, review, coding-agent, MCP, and agent-customization experience
- Validity Period / Renewal Not published by GitHub
- Domain Breakdown & Blueprint Mapping
The GH-600 exam content is divided across six heavily weighted technical domains. Candidates must demonstrate proficiency across foundational architecture, tool integration, state preservation, performance tuning, orchestration patterns, and enterprise guardrails.
Domain ID Domain Title Blueprint Weight Key Topic Focus Areas
Domain 1 Agent Architecture & SDLC Integration 15–20% Agentic control loops, event triggers, GitHub Actions runners, context boundaries
Domain 2 Tool Use & MCP Server Configuration 20–25% Function calling schemas, MCP client/server setup, tool escalation, error recovery
Domain 3 Memory, State & Execution 10–15% Short-term context, working memory, artifact persistence, context window pruning
Domain 4 Evaluation, Error Analysis & Tuning 15–20% Evaluation benchmarks, telemetry, root cause debugging, instruction tuning
Domain 5 Multi-Agent Orchestration 15–20% Agent topologies, parallel execution, handoff protocols, conflict resolution
Domain 6 Guardrails & Accountability 10–15% Risk classification, least privilege, human-in-the-loop approval, sandbox security
Detailed Domain Breakdown
Agent Architecture & SDLC Integration (15–20%) : Focuses on structuring agent execution loops inside developer workflows. Candidates must know how to trigger agents via GitHub Webhooks, Workflow Dispatch events, or repository dispatch mechanisms, maintaining deterministic execution bounds within asynchronous CI/CD runners.
Tool Use & MCP Server Configuration (20–25%) : Represents the largest domain. Tests candidate knowledge of defining OpenAPI / JSON-RPC function schemas, setting up Model Context Protocol (MCP) servers over stdio and SSE , managing authentication tokens, and handling tool execution timeouts.
Memory, State & Execution (10–15%) : Assesses techniques for maintaining state across long-running agent tasks. Covers scratchpad management, pruning older turn histories, serializing intermediate state into GitHub Artifacts, and preventing context window truncation.
Evaluation, Error Analysis & Tuning (15–20%) : Focuses on measuring agent accuracy, trace analysis, prompt iteration, synthetic test generation, and diagnosing non-deterministic model failures in production pipelines.
Multi-Agent Orchestration (15–20%) : Tests patterns for coordinating specialized sub-agents (e.g., Planner, Coder, Reviewer, Tester), managing parallel execution channels, handling state locking, and resolving conflicting modifications.
Guardrails & Accountability (10–15%) : Evaluates security measures including token scoping, repository write permissions, secret masking, vulnerability mitigation, and human-in-the-loop authorization checkpoints.
Target Candidate Profile & Prerequisites
The ideal candidate for the GH-600 exam is a developer or systems engineer who designs autonomous developer tools and automated repository workflows. Key prerequisite skill areas include:
GitHub Ecosystem Expertise : Deep understanding of GitHub REST and GraphQL APIs, GitHub Actions, repository permissions, environment protection rules, and webhook payloads.
LLM Function Calling & Protocols : Hands-on proficiency with JSON schema definitions for tool parameters, function call parsing, tool response injection, and Model Context Protocol (MCP) architecture.
Software Engineering Standards : Competency in modern programming languages (TypeScript/JavaScript, Python, Go), asynchronous programming, containerization, and unit testing frameworks.
Applying the Skills Measured
GitHub does not publish a fixed GH-600 item-format breakdown. Prepare to apply the official skills measured to realistic development situations at these three cognitive levels:
Architectural Design Scenarios : Evaluating trade-offs between centralized single-agent architectures versus modular multi-agent topologies for complex code refactoring tasks.
Failure Analysis & Debugging : Diagnosing logs where an agent becomes trapped in infinite tool execution loops, consumes excessive token context, or fails due to schema validation errors.
Security Policy & Authorization : Identifying missing permission scopes in GitHub Action tokens ( GITHUB_TOKEN ) or improper MCP server exposure that could lead to unauthorized code execution.
Code & Architecture Example: Deterministic Agent Invocation
Below is an example of a GitHub Actions workflow configured to trigger an autonomous agent using strict permission boundaries, environment variables, and artifact capture: name: Autonomous Code Review Agent
on:
pull_request:
types: [opened, synchronize]
jobs:
agent-review:
runs-on: ubuntu-latest
permissions:
- contents: read
- pull-requests: write
- issues: write
steps:
- name: Checkout Repository Code
- uses: actions/checkout@v4
with:
fetch-depth: 0
- name: Setup Node.js Environment
- uses: actions/setup-node@v4
with:
node-version: '20'
- name: Run MCP Agent Inspector
env:
- GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
- OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
- MAX_AGENT_STEPS: '10'
- LOG_LEVEL: 'debug'
- run: |
- npx @github/agentic-cli run \
- -config ./agent.config.json \
- -pr-number ${{ github.event.pull_request.number }} \
- -output-artifact ./agent-trace.json
- name: Upload Agent Trace Artifacts
- if: always()
- uses: actions/upload-artifact@v4
with:
- name: agent-execution-trace
- path: ./agent-trace.json
- Real-World Scenario Connection: Enterprise Migration
Consider an enterprise migrating legacy monolithic services into microservices. The organization deploys an agentic workflow to automate dependency updates and breaking-change detection across 200 repositories.
During initial rollout, the team discovers that the agent frequently hits API rate limits and creates redundant pull requests. Applying GH-600 principles:
The team implements an MCP Caching Gateway to reduce redundant API requests.
They configure Context Pruning to strip past commit histories, keeping context under 8,000 tokens.
They establish a Multi-Agent Topology where a lightweight Triage Agent filters pull requests before passing complex tasks to a Refactoring Agent .
This real-world pattern illustrates how technical strategy directly aligns with the exam's core domains.
Tactical Study Strategy & Test-Taking Blueprint
Use the following adaptable four-phase sequence and spend more time on weaker domains rather than assuming GitHub publishes a fixed preparation duration:
Phase 1: Foundations & Architecture : Master the agentic control loop (Sense-Plan-Act-Reflect), context boundaries, and GitHub Actions integration.
Phase 2: Tool Integration & MCP : Practice writing MCP servers in TypeScript/Python, defining JSON tool schemas, and handling tool errors.
Phase 3: Orchestration & Tuning : Build multi-agent workflows, implement state serialization, and analyze execution traces.
Phase 4: Security & Practice Exams : Audit token scopes, configure approval checkpoints, and complete practice exam questions.
Test-Taking Best Practices
Read Constraints Carefully : Pay close attention to key constraints such as "least privilege", "deterministic execution", or "minimal latency".
Identify Distractor Options : Eliminate choices that suggest removing security limits, storing state in volatile memory without persistence, or granting full admin write tokens unnecessarily.
Manage the 120-minute clock : Monitor time in the exam interface and mark items for review; do not base pacing on an assumed question count or format.