GH-600 study guide
GH-600 treats agentic AI in GitHub as a controlled SDLC system: plan the task, scope the agent, grant only the tools it needs, run it in a bounded environment, produce reviewable artifacts, and put gates before anything irreversible. The sections below follow the domains in weight order. Drill each table until any scenario maps onto actor, scope, tool, artifact, gate and rollback.
Know cold vs. look up later
| Know cold | Searchable if available |
|---|---|
| Official domain weights | Exact current page headings |
| Actor, scope, tool, artifact, gate, rollback parser | UI paths and setting labels |
| Built-in tool vs MCP vs custom agent vs hook | Exact MCP configuration file/schema details |
| Repository, branch, workflow, runner, environment, secret, network boundaries | Product-specific availability limits |
| Planning vs reasoning vs action | Exact tutorial wording |
| Session log, PR, check, scan, workflow artifact, audit event | Exact audit event names |
| Single, sequential, concurrent, handoff, group, manager-led patterns | SDK method names |
| Memory vs session state vs external state vs secrets | Exact memory product behavior labels |
Memorize why the safe answer is safer, not specific answers.
The scenario parser
For every question, fill this in before reading the answer choices too closely.
| Slot | Question to answer |
|---|---|
| Actor | Who acts: user, cloud agent, custom agent, workflow, MCP server, external system, reviewer? |
| Scope | What boundary matters: org, repo, branch, PR, issue, workflow, environment, secret, token, network? |
| Tool | Which mechanism is needed: built-in Copilot tool, MCP tool, hook, GitHub Actions, scan, review, custom agent? |
| Artifact | What proves progress: plan, diff, PR, check, workflow log, trace, session log, audit event? |
| Gate | Where should humans decide: before mutation, before merge, before deploy, before secret, before external impact? |
| Rollback | How do you undo or stop it: close PR, revert branch, rerun workflow, disable tool, revoke token, reset memory, escalate? |
If an option does not name an artifact or control boundary, it is probably too vague.
TOOLS: tool use and environment interaction
Official weight: 20-25%.
What the exam tests
GH-600 treats tools as permissioned capabilities inside a bounded SDLC workflow. The right answer is rarely "give the agent more tools." The right answer usually scopes the tool, narrows the environment, and preserves evidence.
Tool selection
| Scenario signal | Prefer |
|---|---|
| Agent needs normal repository, issue, PR, or code context | Built-in GitHub/Copilot context first |
| Agent needs external system data or actions | MCP server with only required tools enabled |
| Agent needs browser validation | Playwright/browser tool, with network and environment boundary checked |
| Agent needs repeated validation or policy enforcement | Hook, workflow, required check, or scan |
| Agent needs a stable role with custom instructions/tools | Custom agent profile |
| Agent fails once because a tool is missing | Classify failure before expanding permissions |
| Agent chooses noisy or wrong tools | Narrow tool list or instructions before broadening access |
MCP rules
| Need | Rule |
|---|---|
| Add external tools or data | Use MCP when built-in context is insufficient |
| Enable third-party MCP | Review trust boundary, data access, write tools, auth, logging, and ownership |
| Reduce risk | Filter by server and tool list |
| Prevent unwanted mutation | Disable write tools or place them behind approval gates |
| Debug missing MCP capability | Check repository settings, agent profile, allow list, environment, and auth |
| Agent quality drops after MCP addition | Evaluate tool usefulness and remove noisy tools |
MCP expands the agent's reach. Treat it like a production integration, not a convenience plug-in.
Environment boundaries
| Boundary | What it controls |
|---|---|
| Repository | Which code and issues the agent can read or change |
| Branch | Where code mutation can happen |
| Pull request | Review, discussion, checks, and merge governance |
| Workflow | Which automated jobs run and when |
| Runner | Runtime OS, tools, network, permissions, and installed dependencies |
| Environment | Deployment approvals and secret release |
| Secrets and variables | Sensitive values and configuration |
| Firewall/network | External endpoints the agent can reach |
| MCP tool list | External capabilities available to the agent |
Do not confuse merge controls with runtime controls. Branch protection and rulesets govern acceptance. Runners, environments, secrets, firewall rules, and MCP tool filters govern execution.
TOOLS traps
| Trap option | Better answer |
|---|---|
| Grant all MCP tools to avoid future failures | Add only the required tool and evaluate the failure first |
| Disable checks so agent work can merge faster | Keep required checks and fix the failing signal |
| Let the agent push to the default branch | Use branch and PR flow |
| Store production credentials in instructions or memory | Use approved secrets storage and scoped access |
| Retry blindly after a failure | Inspect logs, session artifacts, workflow output, and permissions |
ARCH: agent architecture and SDLC processes
Official weight: 15-20%.
What the exam tests
Agents belong in explicit SDLC steps. They need inputs, outputs, success criteria, constraints, and a review surface before they act.
SDLC placement
| SDLC stage | Agent work that fits | Artifact to inspect |
|---|---|---|
| Discovery | Summarize issue, collect context, identify constraints | Research note or plan |
| Planning | Break task into steps, define files/tools/tests | Structured plan |
| Implementation | Make bounded code or config changes | Branch, diff, PR |
| Validation | Run tests, scans, workflow checks, review criteria | Check result, workflow artifact, scan result |
| Review | Explain changes and risk | PR summary, session log, reviewer comments |
| Deployment | Prepare controlled rollout | Environment approval, deployment log |
| Incident/recovery | Classify failure and propose rollback | Logs, root-cause note, rollback PR |
Planning, reasoning, and action
| If the agent can... | Require before action |
|---|---|
| Change code | Plan, branch scope, tests, review path |
| Change permissions | Human approval and audit trail |
| Deploy | Environment gate and rollback path |
| Touch secrets | Approved secret storage and explicit access boundary |
| Write external systems | Tool allow list, approval boundary, and trace |
| Coordinate other agents | Ownership map and handoff artifact |
Planning is not ceremony. It is how reviewers detect wrong scope before the agent mutates state.
Observability and control
| Need | Control |
|---|---|
| See why an agent acted | Plan and session log |
| See what changed | Branch diff and PR |
| See whether it worked | Tests, scans, checks, workflow artifacts |
| See who initiated it | Human initiator and agent session |
| Stop unsafe work | Pause, cancel, close PR, revoke tool/token, reset memory |
| Avoid blocking low-risk work | Gate only risk-bearing actions |
ARCH traps
| Trap option | Better answer |
|---|---|
| Start coding immediately from a vague issue | Ask for or generate a structured plan |
| Make every agent step require approval | Gate risk-bearing actions, not all routine work |
| Use a manager-led multi-agent setup for a simple task | Use one agent with bounded tools |
| Treat PR review as runtime sandboxing | Use runtime controls for execution and PR controls for acceptance |
EVAL: evaluation, error analysis, and tuning
Official weight: 15-20%.
What the exam tests
Evaluation is evidence. A good answer names the signal that proves the task succeeded or identifies the artifact that explains why it failed.
Evaluation signals
| Task intent | Best signal |
|---|---|
| Code compiles and behaves | Tests, lint, build, workflow check |
| Security risk | CodeQL, secret scanning, dependency review, security review |
| Deployment safety | Environment approval, deployment log, smoke test |
| Agent followed instructions | Plan, session log, PR summary, review comments |
| Tool behaved correctly | Tool trace, MCP server log, workflow output |
| Workflow failed | Job log, run history, runner environment, permissions |
| Multi-agent work converged | Aggregated artifact, ownership map, conflict review |
| User outcome met | Acceptance criteria and domain-specific metric |
Root-cause classification
| Symptom | Classify as | First evidence |
|---|---|---|
| Agent chose the wrong API | Reasoning or missing-context error | Plan, prompt, session log |
| Agent had the right plan but could not call tool | Tool access or permission issue | Tool trace, settings, token scope |
| Workflow fails only on one runner | Environment issue | Runner logs, installed tools, network |
| Agent repeats completed work | State/drift issue | Handoff artifact, session state |
| Generated code fails CodeQL | Evaluation/security issue | Code scanning alert |
| Two agents edit same files | Coordination/isolation issue | Branch diffs, ownership map |
| Agent keeps retrying blocked deploy | Workflow/gate issue | Deployment and environment logs |
Tuning order
- Classify the failure.
- Pick the smallest useful tuning surface.
- Re-run with a signal that can prove improvement.
| Failure | Tune |
|---|---|
| Vague or wrong reasoning | Instructions, examples, success criteria |
| Wrong tool choice | Tool list, prompt routing, custom-agent profile |
| Stale assumptions | Memory reset/prune, current-file verification |
| Missing validation | Add check, scan, hook, or workflow artifact |
| Permission problem | Narrow permission correction, not broad access |
| Coordination conflict | Ownership, branch, handoff, conflict review |
EVAL traps
| Trap option | Better answer |
|---|---|
| Disable CodeQL because agent output is trusted | Fix the code or instructions and keep the scan |
| Add every missing tool after one failed run | Classify first and add only required access |
| Judge success from chat confidence | Use tests, scans, logs, PR review, and artifacts |
| Restart a partial run blindly | Inspect artifacts and recover what already succeeded |
MULTI: multi-agent coordination
Official weight: 15-20%.
What the exam tests
Multi-agent work is useful when work can be split or when specialist judgment reduces risk. It also adds coordination cost, state risk, and conflict risk. Use the simplest pattern that works.
Pattern selection
| Scenario signal | Pattern |
|---|---|
| One bounded task | Single agent |
| Ordered stages where later work depends on earlier output | Sequential |
| Independent workstreams with clear ownership | Concurrent |
| Specialist routing by task type | Handoff |
| Shared critique or consensus needed | Group chat with turn control |
| Open-ended plan with multiple specialists | Manager-led orchestration |
Isolation and conflict control
| Risk | Control |
|---|---|
| Two agents edit same files | Disjoint file/module ownership |
| Agents repeat work | Shared task board or durable state artifact |
| Contradictory recommendations | Aggregator uses evidence and acceptance criteria |
| Partial completion | Preserve artifacts and continue from completed scopes |
| Stalled agent | Escalate, replace, or reassign without losing state |
| Specialist handoff loop | Routing metadata and loop limits |
Lifecycle
| Change | Required evidence |
|---|---|
| Add an agent | Purpose, tool list, scope, validation signal |
| Update agent instructions | Reason, changed behavior, regression check |
| Replace an agent | Migration/handoff note and audit continuity |
| Retire an agent | Preserved logs, open-task transfer, permission cleanup |
MULTI traps
| Trap option | Better answer |
|---|---|
| Use multiple agents because the task is important | Use multiple agents only when decomposition helps |
| Let parallel agents share the same branch and files | Give disjoint branches/scopes and merge through review |
| Accept whichever specialist responds first | Aggregate against evidence and acceptance criteria |
| Restart all agents after one stalls | Preserve completed artifacts and recover the failed lane |
GUARD: guardrails and accountability
Official weight: 10-15%.
What the exam tests
Guardrails map autonomy to risk. The safe answer gives the agent enough room to work while preserving human judgment at the points where a mistake has real cost.
Risk and autonomy
| Action | Autonomy level |
|---|---|
| Read docs, summarize issue, draft plan | Low-risk autonomous with logging |
| Create branch, draft PR, run tests | Medium-risk autonomous with PR review and checks |
| Merge, deploy, change permissions, expose data | Human approval required |
| Touch secrets, billing, production, external communication | Human approval plus narrow permissions and audit trail |
| Delete data or disable security controls | Treat as high-risk and require explicit review |
Human gates
| Boundary | Gate |
|---|---|
| Merge | Required review, CODEOWNERS, required checks |
| Deployment | Environment required reviewers |
| Sensitive files | CODEOWNERS and rulesets |
| Tool write access | MCP tool allow list and approval |
| Secret access | Environment/secret scope and reviewer gate |
| External impact | Human approval before action |
Audit chain
A strong accountability answer names these artifacts:
- human initiator
- agent session
- repository and branch
- PR and review comments
- checks and scan results
- workflow logs and artifacts
- deployment approval if relevant
- audit log event
- rollback or revert path
GUARD traps
| Trap option | Better answer |
|---|---|
| Trust agent-generated code because it passed chat review | Require PR review and checks |
| Give broad org-level token for convenience | Scope token/tool/repo/environment access |
| Put approvals after an irreversible action | Gate before the risky action |
| Use manual review instead of scans for every security issue | Combine automated scans with human judgment |
STATE: memory, state, and execution continuity
Official weight: 10-15%.
What the exam tests
State is the difference between a useful long-running agent and a confused one. Memory must be scoped, current, inspectable, and resettable.
State choices
| Need | Use |
|---|---|
| Immediate task context | Short-term/session context |
| Stable preference or convention | Persistent memory, if safe and scoped |
| Durable progress across sessions | External artifact: issue, PR, plan, task board, session log |
| Shared state across agents | External state source or explicit handoff |
| Current repository truth | Files, branches, checks, logs, and PR state |
| Secret or credential | Approved secret storage, never memory |
Stale context handling
| Symptom | Response |
|---|---|
| Agent uses old architecture | Verify current files and prune/reset memory |
| Agent repeats completed work | Resume from durable artifact |
| Two tools disagree | Trust the authoritative external state, then update handoff |
| Persistent memory conflicts with repo instruction | Repo/project instruction wins |
| Memory contains sensitive data | Delete/prune memory and move secret to proper storage |
STATE traps
| Trap option | Better answer |
|---|---|
| Store production token in memory for reuse | Store it in approved secret storage |
| Let chat history be the only progress record | Write durable task/session artifact |
| Keep stale preference because memory is persistent | Reset or prune memory when context changes |
| Share state through informal comments across agents | Use explicit external state or handoff artifact |
Fast drill tables
If the answer says "more"
| More of what? | Usually wrong because |
|---|---|
| More tools | Access should be scoped to need |
| More agents | Coordination must earn its overhead |
| More memory | Stale or sensitive memory can harm output |
| More manual approvals | Gates should target risk, not routine work |
| More retries | Failures need classification first |
If the answer says "evidence"
| Evidence named | Usually strong when |
|---|---|
| Plan | The risk is wrong scope before mutation |
| PR/diff | The issue is inspectable code change |
| Check/workflow log | The issue is build/test/runtime behavior |
| CodeQL/secret/dependency scan | The issue is security or supply chain |
| Session log | The issue is agent reasoning or traceability |
| Audit log | The issue is accountability or admin action |
| Handoff artifact | The issue is long-running or multi-agent continuity |
Final self-test
For each prompt, answer in one sentence with actor, scope, tool/control, artifact, gate, and rollback.
- A cloud agent needs to validate a web change against a local dev server.
- A custom agent needs to call an internal ticketing API.
- A workflow fails only when the agent opens a PR from a fork.
- Two agents produce conflicting patches against the same file.
- An agent resumes a week-old task and follows stale conventions.
- A security team wants agent-generated code blocked when secrets are detected.
- A deployment requires production credentials.
- A third-party MCP server exposes both read and write tools.
- A reviewer cannot tell why the agent chose a risky API.
- An agent keeps retrying a deployment blocked by environment approval.