Skip to content

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 coldSearchable if available
Official domain weightsExact current page headings
Actor, scope, tool, artifact, gate, rollback parserUI paths and setting labels
Built-in tool vs MCP vs custom agent vs hookExact MCP configuration file/schema details
Repository, branch, workflow, runner, environment, secret, network boundariesProduct-specific availability limits
Planning vs reasoning vs actionExact tutorial wording
Session log, PR, check, scan, workflow artifact, audit eventExact audit event names
Single, sequential, concurrent, handoff, group, manager-led patternsSDK method names
Memory vs session state vs external state vs secretsExact 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.

SlotQuestion to answer
ActorWho acts: user, cloud agent, custom agent, workflow, MCP server, external system, reviewer?
ScopeWhat boundary matters: org, repo, branch, PR, issue, workflow, environment, secret, token, network?
ToolWhich mechanism is needed: built-in Copilot tool, MCP tool, hook, GitHub Actions, scan, review, custom agent?
ArtifactWhat proves progress: plan, diff, PR, check, workflow log, trace, session log, audit event?
GateWhere should humans decide: before mutation, before merge, before deploy, before secret, before external impact?
RollbackHow 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 signalPrefer
Agent needs normal repository, issue, PR, or code contextBuilt-in GitHub/Copilot context first
Agent needs external system data or actionsMCP server with only required tools enabled
Agent needs browser validationPlaywright/browser tool, with network and environment boundary checked
Agent needs repeated validation or policy enforcementHook, workflow, required check, or scan
Agent needs a stable role with custom instructions/toolsCustom agent profile
Agent fails once because a tool is missingClassify failure before expanding permissions
Agent chooses noisy or wrong toolsNarrow tool list or instructions before broadening access

MCP rules ​

NeedRule
Add external tools or dataUse MCP when built-in context is insufficient
Enable third-party MCPReview trust boundary, data access, write tools, auth, logging, and ownership
Reduce riskFilter by server and tool list
Prevent unwanted mutationDisable write tools or place them behind approval gates
Debug missing MCP capabilityCheck repository settings, agent profile, allow list, environment, and auth
Agent quality drops after MCP additionEvaluate 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 ​

BoundaryWhat it controls
RepositoryWhich code and issues the agent can read or change
BranchWhere code mutation can happen
Pull requestReview, discussion, checks, and merge governance
WorkflowWhich automated jobs run and when
RunnerRuntime OS, tools, network, permissions, and installed dependencies
EnvironmentDeployment approvals and secret release
Secrets and variablesSensitive values and configuration
Firewall/networkExternal endpoints the agent can reach
MCP tool listExternal 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 optionBetter answer
Grant all MCP tools to avoid future failuresAdd only the required tool and evaluate the failure first
Disable checks so agent work can merge fasterKeep required checks and fix the failing signal
Let the agent push to the default branchUse branch and PR flow
Store production credentials in instructions or memoryUse approved secrets storage and scoped access
Retry blindly after a failureInspect 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 stageAgent work that fitsArtifact to inspect
DiscoverySummarize issue, collect context, identify constraintsResearch note or plan
PlanningBreak task into steps, define files/tools/testsStructured plan
ImplementationMake bounded code or config changesBranch, diff, PR
ValidationRun tests, scans, workflow checks, review criteriaCheck result, workflow artifact, scan result
ReviewExplain changes and riskPR summary, session log, reviewer comments
DeploymentPrepare controlled rolloutEnvironment approval, deployment log
Incident/recoveryClassify failure and propose rollbackLogs, root-cause note, rollback PR

Planning, reasoning, and action ​

If the agent can...Require before action
Change codePlan, branch scope, tests, review path
Change permissionsHuman approval and audit trail
DeployEnvironment gate and rollback path
Touch secretsApproved secret storage and explicit access boundary
Write external systemsTool allow list, approval boundary, and trace
Coordinate other agentsOwnership map and handoff artifact

Planning is not ceremony. It is how reviewers detect wrong scope before the agent mutates state.

Observability and control ​

NeedControl
See why an agent actedPlan and session log
See what changedBranch diff and PR
See whether it workedTests, scans, checks, workflow artifacts
See who initiated itHuman initiator and agent session
Stop unsafe workPause, cancel, close PR, revoke tool/token, reset memory
Avoid blocking low-risk workGate only risk-bearing actions

ARCH traps ​

Trap optionBetter answer
Start coding immediately from a vague issueAsk for or generate a structured plan
Make every agent step require approvalGate risk-bearing actions, not all routine work
Use a manager-led multi-agent setup for a simple taskUse one agent with bounded tools
Treat PR review as runtime sandboxingUse 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 intentBest signal
Code compiles and behavesTests, lint, build, workflow check
Security riskCodeQL, secret scanning, dependency review, security review
Deployment safetyEnvironment approval, deployment log, smoke test
Agent followed instructionsPlan, session log, PR summary, review comments
Tool behaved correctlyTool trace, MCP server log, workflow output
Workflow failedJob log, run history, runner environment, permissions
Multi-agent work convergedAggregated artifact, ownership map, conflict review
User outcome metAcceptance criteria and domain-specific metric

Root-cause classification ​

SymptomClassify asFirst evidence
Agent chose the wrong APIReasoning or missing-context errorPlan, prompt, session log
Agent had the right plan but could not call toolTool access or permission issueTool trace, settings, token scope
Workflow fails only on one runnerEnvironment issueRunner logs, installed tools, network
Agent repeats completed workState/drift issueHandoff artifact, session state
Generated code fails CodeQLEvaluation/security issueCode scanning alert
Two agents edit same filesCoordination/isolation issueBranch diffs, ownership map
Agent keeps retrying blocked deployWorkflow/gate issueDeployment and environment logs

Tuning order ​

  1. Classify the failure.
  2. Pick the smallest useful tuning surface.
  3. Re-run with a signal that can prove improvement.
FailureTune
Vague or wrong reasoningInstructions, examples, success criteria
Wrong tool choiceTool list, prompt routing, custom-agent profile
Stale assumptionsMemory reset/prune, current-file verification
Missing validationAdd check, scan, hook, or workflow artifact
Permission problemNarrow permission correction, not broad access
Coordination conflictOwnership, branch, handoff, conflict review

EVAL traps ​

Trap optionBetter answer
Disable CodeQL because agent output is trustedFix the code or instructions and keep the scan
Add every missing tool after one failed runClassify first and add only required access
Judge success from chat confidenceUse tests, scans, logs, PR review, and artifacts
Restart a partial run blindlyInspect 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 signalPattern
One bounded taskSingle agent
Ordered stages where later work depends on earlier outputSequential
Independent workstreams with clear ownershipConcurrent
Specialist routing by task typeHandoff
Shared critique or consensus neededGroup chat with turn control
Open-ended plan with multiple specialistsManager-led orchestration

Isolation and conflict control ​

RiskControl
Two agents edit same filesDisjoint file/module ownership
Agents repeat workShared task board or durable state artifact
Contradictory recommendationsAggregator uses evidence and acceptance criteria
Partial completionPreserve artifacts and continue from completed scopes
Stalled agentEscalate, replace, or reassign without losing state
Specialist handoff loopRouting metadata and loop limits

Lifecycle ​

ChangeRequired evidence
Add an agentPurpose, tool list, scope, validation signal
Update agent instructionsReason, changed behavior, regression check
Replace an agentMigration/handoff note and audit continuity
Retire an agentPreserved logs, open-task transfer, permission cleanup

MULTI traps ​

Trap optionBetter answer
Use multiple agents because the task is importantUse multiple agents only when decomposition helps
Let parallel agents share the same branch and filesGive disjoint branches/scopes and merge through review
Accept whichever specialist responds firstAggregate against evidence and acceptance criteria
Restart all agents after one stallsPreserve 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 ​

ActionAutonomy level
Read docs, summarize issue, draft planLow-risk autonomous with logging
Create branch, draft PR, run testsMedium-risk autonomous with PR review and checks
Merge, deploy, change permissions, expose dataHuman approval required
Touch secrets, billing, production, external communicationHuman approval plus narrow permissions and audit trail
Delete data or disable security controlsTreat as high-risk and require explicit review

Human gates ​

BoundaryGate
MergeRequired review, CODEOWNERS, required checks
DeploymentEnvironment required reviewers
Sensitive filesCODEOWNERS and rulesets
Tool write accessMCP tool allow list and approval
Secret accessEnvironment/secret scope and reviewer gate
External impactHuman 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 optionBetter answer
Trust agent-generated code because it passed chat reviewRequire PR review and checks
Give broad org-level token for convenienceScope token/tool/repo/environment access
Put approvals after an irreversible actionGate before the risky action
Use manual review instead of scans for every security issueCombine 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 ​

NeedUse
Immediate task contextShort-term/session context
Stable preference or conventionPersistent memory, if safe and scoped
Durable progress across sessionsExternal artifact: issue, PR, plan, task board, session log
Shared state across agentsExternal state source or explicit handoff
Current repository truthFiles, branches, checks, logs, and PR state
Secret or credentialApproved secret storage, never memory

Stale context handling ​

SymptomResponse
Agent uses old architectureVerify current files and prune/reset memory
Agent repeats completed workResume from durable artifact
Two tools disagreeTrust the authoritative external state, then update handoff
Persistent memory conflicts with repo instructionRepo/project instruction wins
Memory contains sensitive dataDelete/prune memory and move secret to proper storage

STATE traps ​

Trap optionBetter answer
Store production token in memory for reuseStore it in approved secret storage
Let chat history be the only progress recordWrite durable task/session artifact
Keep stale preference because memory is persistentReset or prune memory when context changes
Share state through informal comments across agentsUse explicit external state or handoff artifact

Fast drill tables ​

If the answer says "more" ​

More of what?Usually wrong because
More toolsAccess should be scoped to need
More agentsCoordination must earn its overhead
More memoryStale or sensitive memory can harm output
More manual approvalsGates should target risk, not routine work
More retriesFailures need classification first

If the answer says "evidence" ​

Evidence namedUsually strong when
PlanThe risk is wrong scope before mutation
PR/diffThe issue is inspectable code change
Check/workflow logThe issue is build/test/runtime behavior
CodeQL/secret/dependency scanThe issue is security or supply chain
Session logThe issue is agent reasoning or traceability
Audit logThe issue is accountability or admin action
Handoff artifactThe 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.

  1. A cloud agent needs to validate a web change against a local dev server.
  2. A custom agent needs to call an internal ticketing API.
  3. A workflow fails only when the agent opens a PR from a fork.
  4. Two agents produce conflicting patches against the same file.
  5. An agent resumes a week-old task and follows stale conventions.
  6. A security team wants agent-generated code blocked when secrets are detected.
  7. A deployment requires production credentials.
  8. A third-party MCP server exposes both read and write tools.
  9. A reviewer cannot tell why the agent chose a risky API.
  10. An agent keeps retrying a deployment blocked by environment approval.

Personal study notes written from official documentation. Not affiliated with Microsoft or GitHub. Contains no exam questions.