Microsoft Developing in Agentic AI Systems GH-600 Exam Dumps: Updated Questions & Answers (September 2026)

Target 1 → C. http

Target 2 → A. Bearer

The completed configuration is:

{

" servers " : {

" github " : {

" type " : " http " ,

" url " : " https://api.githubcopilot.com/mcp/ " ,

" requestInit " : {

" headers " : {

" Authorization " : " Bearer ${env:GITHUB_PAT} "

}

}

}

}

}

The first target must be http because the GitHub MCP endpoint is a remotely hosted MCP server accessed through an HTTPS URL. GitHub ' s MCP configuration supports remote HTTP servers using the http transport type, whereas stdio and local are intended for MCP servers launched as local processes. GitHub documentation identifies http as a valid MCP server type for remote endpoints.

The second target must be Bearer . GitHub ' s documented PAT authentication pattern places the token in the HTTP Authorization header in the form Bearer < PAT > . Therefore, the expression combining Bearer with ${env:GITHUB_PAT} supplies the credential in the expected authentication scheme without embedding the token directly in the committed workspace configuration. GitHub ' s MCP setup documentation explicitly demonstrates an Authorization header using Bearer YOUR_GITHUB_PAT for the hosted GitHub MCP endpoint.

Digest, Token, and x-api-key do not match GitHub ' s prescribed PAT authentication syntax. Likewise, local and stdio would describe a locally executed MCP server rather than the specified remote endpoint.

Study Guide Reference Topics: Implement Tool Use and Environment Interaction; configure MCP servers; remote MCP transports; secure credential handling; tool authentication.

Workflow artifacts provide the required combination of retained execution evidence and file transfer between jobs. The agent-run job uploads trace.json and plan.md, associating both files with the workflow run. Reviewers can access the resulting artifact through the run’s GitHub Actions interface, while downstream jobs download it to their own execution environments.

This is necessary because separate jobs do not automatically share a local filesystem. Declaring a dependency establishes execution order but does not transfer the generated files. The review and deployment stages therefore need explicit artifact downloads in addition to their appropriate job dependencies.

Committing transient traces and plans introduces repository changes solely to transport run-specific evidence. A network share adds external infrastructure and does not directly satisfy the requirement for standard Actions artifact access. Dependency caching is intended for reusable inputs such as downloaded dependencies; it is not the appropriate mechanism for authoritative outputs from a particular agent run.

Artifacts preserve the plan and trace that informed the review, allowing subsequent deployment activity to use the corresponding files. Relevant curriculum topics are inspectable agent artifacts, observability, and human intervention.

Requirement

Selection

To draft and open the pull request

GitHub Copilot coding agent assigned to an issue

To automate the pull request review before human review

GitHub Copilot code review on the pull request

Assigning an issue to the GitHub Copilot coding agent initiates the implementation workflow. The agent uses the issue as its task definition, works in a dedicated branch, prepares the code and tests, and opens a draft pull request. This creates a reviewable implementation boundary before changes reach the protected branch.

GitHub Copilot code review belongs on the resulting pull request because it evaluates the actual diff. Plan mode can help formulate an approach, but it neither opens a pull request nor performs an automated review of the implemented code. The correct sequence is issue assignment, implementation pull request, automated review, then human review.

This separates planning, coding, automated inspection, and human accountability. CI validates executable behavior, Copilot review identifies potential code-level concerns, and the human reviewer retains approval responsibility.

Study-guide topics: agent-driven SDLC workflows, pull-request automation, code review, and human approval.

===============

Yes, Yes, No

The first statement is Yes . --autopilot permits Copilot CLI to continue autonomously through successive task steps, while --max-autopilot-continues 10 imposes a finite continuation boundary. GitHub specifically recommends this option for programmatic autopilot execution to prevent an agent from continuing indefinitely or entering a runaway loop.

The second statement is also Yes . --yolo is an alias for --allow-all. It grants permission for all available tools, paths, and URLs, encompassing activities such as file modifications and shell execution without individual approval prompts.

The third statement is No . This command is intentionally configured for hands-off autonomous execution . Autopilot continues through multiple reasoning/action cycles, and --yolo removes normal per-action permission checkpoints. Therefore, the configuration does not provide targeted human approval at key decision points. A workflow requiring such intervention should instead retain interactive controls or separate planning/approval from execution.

This distinction directly maps to GH-600 objectives covering autonomy levels, execution controls, guardrails, and configuring human intervention without unnecessarily disrupting delivery.

Study Guide Reference Topics: Manage Memory, State, and Execution; autonomous execution boundaries; continuation controls; guardrails; human-in-the-loop intervention.

Statement

Answer

The agent responded with messages.

Yes

The agent can edit files in the repository.

No

The agent analyzed files in the repository.

Yes

The log contains successful message-return events, confirming that the agent responded. It also shows successful model activity associated with the agent session, which supports the conclusion that the agent processed available information.

The log does not provide evidence of an actual file-edit tool invocation or successful repository write. An editAgent panel label identifies the interaction context; it is not equivalent to proof that the agent had or used file-edit permissions. Therefore, the correct response for file-edit capability is No.

The model responses and session activity demonstrate analysis, but they do not establish every possible capability of the agent. Effective log analysis distinguishes between evidence of observed actions and assumptions based on an agent’s name, panel, or intended role.

Study-guide topics: log interpretation, evidence-based evaluation, tool-call analysis, and capability verification.

===============

Human-in-the-loop execution provides the appropriate autonomy level because the agent’s actions affect production deployment and access to production secrets. The agent can prepare changes and perform permitted validation, while an authorized person approves the production transition. This retains useful automation while placing human judgment at the consequential execution boundary.

GitHub Actions environments support required reviewers. A job referencing a protected environment must satisfy its protection rules before proceeding. GitHub explicitly documents that when approval is required, the job cannot access environment secrets until a required reviewer approves it. The approval gate therefore controls an operational capability, rather than merely asking the model to behave cautiously.

Option A removes the oversight required by the scenario. Option B prevents the agent from performing the requested deployment work. Option D restricts execution to non-production environments and consequently does not provide a controlled route to production.

The workflow should bind deployment to the protected production environment and align reviewer permissions with organizational policy. Relevant curriculum topics are risk-based autonomy levels, explicit authorization for compliance-sensitive changes, and least-privilege execution.

Target

Correct selection

tools

[ ' search ' , ' read ' ]

user-invocable

false

The agent needs inspection capabilities without file-modification capabilities. Setting tools to [ ' search ' , ' read ' ] gives it the ability to locate relevant code and examine file contents while excluding the editing capability supplied by edit. This is appropriate for a reviewer whose output consists of findings or recommendations rather than applied changes.

The alternative list containing edit would directly contradict the requirement. The agent tool enables delegation to another agent and is not the required substitute for searching and reading repository content. Likewise, none is not the documented way to configure a useful read-only tool list.

Setting user-invocable: false independently prevents manual selection of the agent. That property governs discoverability and invocation, while tools governs available capabilities. Both settings are necessary because hiding an agent does not make its operations read-only, and restricting its tools does not automatically hide it.

The result is a specialized reviewer that can be incorporated into a controlled workflow without being offered as a normal user-selected editing agent.

Relevant curriculum topics are tool selection, least-privilege permissions, and agent invocation controls.

The correct answer is Edit mode . GitHub Copilot ' s Edit mode is designed for situations where the developer wants granular control over which files may be changed and what modifications should be applied . In Edit mode, you explicitly select the working set of files, provide natural- language instructions describing the required changes, and then review the proposed edits before accepting or discarding them. GitHub describes Edit mode as appropriate for quick, specific updates to a defined set of files and for scenarios where the developer wants tighter control over the editing process.

Agent mode differs because Copilot determines which files and tools are required, can execute terminal commands, and iterates autonomously toward completing the task. Ask mode is intended primarily for explanations, questions, and code suggestions rather than coordinated file modification. Plan mode generates an implementation strategy before execution and is appropriate when the approach must be reviewed before coding begins.

Therefore, where the requirement explicitly emphasizes selecting specific files and prescribing precise edits rather than delegating scope determination to the agent , Edit mode provides the correct level of developer control.

Study Guide Reference Topics: Prepare agent architecture and SDLC processes; selecting appropriate Copilot interaction modes; controlled code modification; human-directed versus autonomous execution.

Workflow artifacts provide an explicit mechanism for transferring serialized agent state between jobs. The producing job writes the required state to files and uploads those files as an artifact. Subsequent jobs download the artifact and load the state before continuing the integration-test workflow.

This is necessary because jobs do not automatically share process memory or a common workspace. They may execute on different runners, and even jobs assigned to similar runner types must not depend on incidental machine reuse. Uploading the state establishes a deliberate persistence boundary rather than relying on temporary execution infrastructure.

Committing state after every job introduces repository mutations merely to transport workflow data. Environment variables are also unsuitable as a general cross-job state store: setting a variable in one job does not automatically expose it in another, and complex state is better represented in structured files.

The application must serialize the information needed for continuation, such as completed steps, relevant decisions, and test progress. Uploading an arbitrary directory does not automatically restore a running agent process.

Relevant curriculum topics are durable state, cross-environment continuity, and resuming work without repeating completed steps.

The correct command is /clear . In GitHub Copilot CLI, /clear starts a fresh conversational state by removing the current chat history from the active session. This is the appropriate action when the requirement is to discard prior conversation context completely rather than compress or summarize it.

/compact is specifically designed for context management during long-running sessions. It summarizes older conversation history so that useful information can be retained while freeing context-window capacity. Because the question explicitly says “without summarization,” /compact does not satisfy the requirement.

/usage displays session consumption and usage information rather than modifying conversation state. /reset-context is not the standard slash command used for clearing Copilot CLI conversation history in this scenario.

The operational distinction is important in agentic workflows. Compaction preserves semantic continuity , while clearing abandons the prior conversational state and gives the agent a clean starting point. Clearing is therefore appropriate when accumulated context has become irrelevant, misleading, or overly large and you deliberately do not want previous reasoning, instructions, or task history carried forward.

Study Guide Reference Topics: Manage Memory, State, and Execution; conversation-state management; context-window control; session reset versus context compaction.