PracticeVideosBlogFlashcardsEspañol
All Practice Exams

131+ Free GitHub Certified: Agentic AI Developer Practice Questions

Prepare for the GitHub Certified: Agentic AI Developer — Developing in Agentic AI Systems (GH-600) exam with instant access — no signup required.

✓ No registration✓ No credit card✓ No hidden fees✓ Start practicing immediately
131+ Questions
100% Free

Loading practice questions...

Same family resources

Explore More GitHub Certifications

Continue into nearby exams from the same family. Each card keeps practice questions, study guides, flashcards, videos, and articles in one place.

GitHub Foundations

Practice QuestionsStudy Guide1 video1 blog

GitHub Actions Certification

Practice QuestionsStudy Guide1 blog

GitHub Administration (GH-100)

Practice Questions

GitHub Advanced Security (GHAS) Certification

Practice Questions

GitHub Copilot Certification

Practice Questions

More From This Family

Videos and articles for deeper review.

VideoGitHub Foundations Exam Guide 2026: GH-900 Prep That Uses GitHubArticleGitHub Foundations Exam Guide 2026: GH-900 Prep That Uses GitHub7 min readArticleGitHub Actions Certification Guide 2026: GH-200 Prep10 min read
2026 Statistics

Key Facts: GitHub Certified: Agentic AI Developer Exam

700/1000

Passing Score

Microsoft Learn GH-600 study guide

Not published

Exam Questions

GitHub GH-600 certification page

120 min

Exam Time

Microsoft Learn

6

Exam Domains

GH-600 study guide

Available

Certification Status

GitHub GH-600 certification page

Not published

Validity / Renewal

GitHub GH-600 certification page

GH-600 requires a scaled score of 700 out of 1000 and provides 120 minutes for the proctored exam. GitHub does not publish a fixed question count or item-format breakdown. Preparation focuses on GitHub Copilot agent customization, MCP server configuration, memory and state management, multi-agent orchestration, and Responsible AI guardrails.

Sample GitHub Certified: Agentic AI Developer Practice Questions

Try these sample questions to test your GitHub Certified: Agentic AI Developer exam readiness. Each question includes a detailed explanation. Start the interactive quiz above for the full 131+ question experience with AI tutoring.

1In the GH-600 exam domain 'Prepare agent architecture and SDLC processes,' what is the primary purpose of defining clear boundaries between an agent's planning phase and its execution phase?
A.Token-use reduction
B.To gate irreversible actions behind plan review
C.To enable the agent to run multiple tasks simultaneously in parallel
D.To reduce the number of MCP servers required for a workflow
Explanation: Separating planning from execution allows operators to validate the agent's intended actions before they are carried out, which is a core safety principle for agentic AI systems. This human-in-the-loop checkpoint prevents unintended side effects from autonomous actions. The other options describe unrelated concerns such as token efficiency, parallelism, and MCP topology.
2A developer wants to add a third-party data-retrieval service as a tool available to a GitHub Copilot agent. Which GitHub feature is the correct mechanism for exposing that external service to the agent?
A.CI secrets
B.GitHub Codespaces devcontainer.json
C.An MCP server
D.GitHub Packages registry
Explanation: Model Context Protocol (MCP) servers are the standard GitHub Copilot mechanism for exposing external tools, APIs, and data sources to an agent. Configuring an MCP server allows the agent to call the external service with defined permissions and allow-lists. Secrets manage credentials, devcontainer.json configures development environments, and Packages manages software artifacts.
3When configuring MCP servers for GitHub Copilot clients, what is the purpose of an MCP server allowlist?
A.Repository clone permissions
B.Limit clients to approved MCP servers
C.It enumerates the GitHub Actions workflows the agent can trigger
D.It defines the set of pull request reviewers the agent may assign
Explanation: An MCP server allowlist limits which servers Copilot clients may run, reducing the external-tool attack surface. Enterprise managed settings can match servers by name, URL, or launch command. This server-level policy is separate from selecting which individual tools an approved server exposes to an agent.
4You need a GitHub Copilot agent to automatically create a feature branch and open a pull request when a task is complete. Which configuration must be explicitly enabled to allow this autonomous action?
A.An organization-admin token
B.Task-scoped branch and pull-request permissions
C.The repository must be made public so the agent can write to it
D.A GitHub Actions workflow must manually approve every branch the agent creates
Explanation: The GH-600 study guide specifically lists 'Enable an agent to perform autonomous actions, including creating branches and pull requests' as a distinct configuration step under tool use and environment interaction. This explicit permission grant is necessary before the agent can take such actions. Making a repository public or requiring manual approval for every branch contradicts the goal of autonomous operation.
5A GitHub Copilot agent is configured to run inside a CI workflow. Which benefit does invoking the agent within CI provide that running it manually in the IDE does not?
A.CI-only model access
B.The agent can use a larger context window than is available in the Copilot Chat IDE panel
C.Event-triggered, repeatable, logged agent runs
D.CI execution bypasses the MCP allow list restrictions configured for the repository
Explanation: Integrating an agent into a CI workflow means it can be triggered by GitHub events such as push, pull_request, or schedule, producing consistent, auditable, and repeatable automation without requiring a human to manually invoke it each time. The other options describe inaccurate capabilities or explicitly violate security principles covered on the exam.
6What is 'context drift' in the context of long-running GitHub Copilot agents?
A.Iterative code-quality decline
B.A security vulnerability where the agent's context window leaks information to external MCP servers
C.Assumptions drifting from the current repository state
D.The accidental inclusion of irrelevant files in the agent's memory due to misconfigured repository scoping
Explanation: Context drift occurs when an agent's internal representation of the task or codebase falls out of sync with reality during a long-running execution, for example because other developers made commits or because earlier agent decisions are no longer consistent with new information. The GH-600 study guide lists detecting and correcting drift as a key memory and state management skill. The other options describe code quality, security, or scoping issues, not context drift specifically.
7When should a GitHub Copilot agent use long-term memory instead of short-term (in-context) memory for storing a completed task's results?
A.When the task result is less than 100 tokens and can be summarized easily
B.When information must survive sessions or context resets
C.When the selected model lacks tool calling
D.When the repository has more than 10,000 files and context is too large to hold
Explanation: Long-term memory persists information beyond a single context window or session, allowing agents to resume work or reuse prior decisions in future executions. The GH-600 study guide identifies choosing between short-term and long-term memory as a key skill under memory management. The other options describe token limits, model capabilities, or repository size, which are not the primary driver for choosing long-term memory.
8A developer is configuring a GitHub Copilot agent to scope its execution to a specific repository. What is the primary security benefit of this scoping?
A.Repository-specific Actions billing
B.It limits access to the intended repository
C.It forces the agent to use only models available through GitHub Models for that repository
D.It automatically enables required reviewers on all pull requests the agent opens
Explanation: Scoping an agent to a specific repository enforces least-privilege access: the agent can only interact with that repository's code, issues, and branches, limiting the potential damage from a malfunction, prompt injection, or misconfiguration. The GH-600 study guide explicitly lists 'Configure an agent's scope to a specific repository' as a tool and environment interaction skill. The other options describe billing, model selection, and PR review rules, which are unrelated to scoping.
9In the GH-600 evaluation domain, what is the role of 'automated scanning tools' in generating evaluation signals for agent tasks?
A.Automatic pull-request approval
B.Machine-readable test, analysis, and security results
C.They monitor GitHub API rate limits to ensure agents do not exceed usage quotas
D.They generate synthetic training data to fine-tune the underlying language model
Explanation: Automated scanning tools (such as test runners, linters, SAST tools, and dependency scanners) generate structured, machine-readable outputs that serve as quantitative evaluation signals for agent tasks. The GH-600 study guide explicitly mentions using automated scanning tools to generate evaluation signals and align them with development intent. The other options describe PR auto-approval, API quota monitoring, and model fine-tuning, which are not the purpose of scanning tools in this context.
10An agent repeatedly misuses a tool by calling it with incorrect parameters, causing downstream workflow failures. According to the GH-600 study guide, how should this failure be classified?
A.A model-weight reasoning error
B.A context or environment issue caused by insufficient compute resources
C.Tool misuse; refine tool instructions or access
D.A memory expiration issue requiring longer context retention
Explanation: The GH-600 study guide categorizes agent failures into reasoning errors, tool misuse, and context/environment issues. Repeatedly calling a tool with incorrect parameters is a classic tool misuse failure, which should be addressed by revising the agent's tool instructions, refining usage constraints, or adjusting tool access. Model weights and compute resources are infrastructure concerns outside the scope of agent configuration.

About the GitHub Certified: Agentic AI Developer Exam

The GitHub Certified: Agentic AI Developer credential, earned by passing Developing in Agentic AI Systems (GH-600), validates the ability to operate, supervise, and govern autonomous AI agents inside production-grade GitHub SDLC workflows. The current exam is available in English and scheduled through Pearson VUE. It covers six domains: preparing agent architecture and integrating agents into the SDLC, implementing tool use and MCP server configuration, managing memory and state, performing evaluation and error analysis, orchestrating multi-agent coordination, and implementing guardrails and accountability.

Assessment

Question count not published by the exam provider

Time Limit

120 minutes

Passing Score

700/1000

Exam Fee

Price varies by the country or region in which the exam is proctored (GitHub (Microsoft))

GitHub Certified: Agentic AI Developer Exam Content Outline

15–20%

Prepare Agent Architecture and SDLC Processes

Define agent task boundaries, configure planning/execution separation, output structured plans, validate plans before execution, and configure observability with human-intervention controls

20–25%

Implement Tool Use and Environment Interaction

Select and configure tools, configure MCP servers and allow lists, add remote GitHub MCP servers, manage MCP registries, scope agents to repositories and branches, invoke agents in CI, implement retry/rollback/escalation, and ensure traceability

10–15%

Manage Memory, State, and Execution

Choose short-term, long-term, or external memory; scope memory to task-relevant information; define expiration and pruning rules; capture durable artifacts; detect and correct context drift; share state and prevent conflicting or stale context

15–20%

Perform Evaluation, Error Analysis, and Tuning

Define success criteria and evaluation signals, use automated scanning tools, identify failures from logs/plans/traces, classify root causes (reasoning errors, tool misuse, context/environment issues), and tune instructions, memory, and tool access

15–20%

Orchestrate Multi-Agent Coordination

Apply orchestration patterns, configure agent isolation, detect and resolve agent conflicts, configure multi-agent observability and artifact production, document decisions and handoffs, detect and respond to multi-agent failures, and manage agent lifecycle

10–15%

Implement Guardrails and Accountability

Classify actions by risk, assign autonomy levels, block policy-violating actions, scope permissions to least-privilege, require explicit authorization for irreversible or compliance-sensitive changes, and preserve velocity by minimizing unnecessary approvals

How to Pass the GitHub Certified: Agentic AI Developer Exam

What You Need to Know

  • Passing score: 700/1000
  • Assessment: Question count not published by the exam provider
  • Time limit: 120 minutes
  • Exam fee: Price varies by the country or region in which the exam is proctored

Keys to Passing

  • Work through all 131 available questions
  • Review every answer and explanation
  • Track weak areas and revisit them
  • Use our AI tutor for tough concepts

GitHub Certified: Agentic AI Developer Study Tips from Top Performers

1Focus first on the highest-weighted domain (20–25%): MCP server configuration, allow lists, remote MCP servers, and MCP registries
2Understand the six domains cold and which skills belong to which domain — GH-600 frequently tests domain attribution
3Practice the planning-before-execution pattern: define inputs/outputs/success criteria, output a structured plan, validate it, then execute
4Know the three root-cause categories for agent failures: reasoning errors, tool misuse, and context/environment issues — and the tuning action for each
5Memorize the guardrails principle: irreversible or compliance-sensitive changes require explicit authorization; low-risk reversible actions can proceed autonomously
6Understand memory strategy selection: short-term (in-context), long-term (persistent external), and when to use each in long-running vs. short tasks
7Study multi-agent conflict types: overlapping code changes, duplicated effort, and contradictory outputs — and the isolation and orchestration patterns that prevent them
8Complete 100+ practice questions across all six domains and review every wrong answer until you can explain the GH-600 principle behind the correct choice

Frequently Asked Questions

What is the GH-600 passing score?

The official GH-600 study guide states that a scaled score of 700 or greater is required to pass. The official certification page provides 120 minutes for the exam, but GitHub does not publish a fixed question count.

Is GH-600 currently available?

Yes. The current Microsoft Learn certification page lists GitHub Certified: Agentic AI Developer and provides scheduling through Pearson VUE. The exam is currently listed in English, and its price is based on the country or region in which it is proctored.

What does the GH-600 exam cover?

GH-600 covers six domains: (1) preparing agent architecture and integrating agents into the SDLC (15–20%), (2) implementing tool use and MCP server configuration (20–25%), (3) managing agent memory, state, and execution (10–15%), (4) performing evaluation, error analysis, and tuning (15–20%), (5) orchestrating multi-agent coordination (15–20%), and (6) implementing guardrails and accountability (10–15%). MCP server configuration carries the highest weight and is central to the exam.

What prior experience do I need for GH-600?

GitHub lists no formal prerequisite credential. It recommends experience with the software development lifecycle, GitHub workflows and controls, code quality, security and review practices, and coding agents including GitHub Copilot, MCP servers, custom instructions, custom agents, tools, and Copilot setup steps.

How long should I study for GH-600?

GitHub does not publish a recommended number of study hours or weeks for GH-600. Build a plan from the six official domain weights and include hands-on practice with MCP servers, agent workflows, memory and state, evaluation, multi-agent coordination, and guardrails.

What is Model Context Protocol (MCP) and why is it important for GH-600?

MCP (Model Context Protocol) is an open standard for connecting AI models to tools and data sources. GH-600 covers adding MCP servers as agent tools, configuring the GitHub remote MCP server, registries, and allow lists within the largest official domain range, Tool Use and Environment Interaction (20–25%).

Does GH-600 expire, and how is it renewed?

GitHub does not publish a GH-600 validity period or renewal requirement on the current certification page. Check the official certification page and your credential profile for any future renewal instructions instead of assuming the annual policy for Microsoft associate, expert, and specialty certifications applies.