Microsoft GH-600 Dumps

The first statement is Yes . When an MCP server is configured for a repository, GitHub Copilot cloud agents can use the enabled MCP tools autonomously during assigned tasks. GitHub specifically notes that Copilot does not request interactive approval before invoking configured MCP tools, making careful tool allowlisting and credential protection important.

The second statement is No . For repository-level MCP integration, Copilot cloud agent currently supports MCP tools , but it does not support MCP resources or MCP prompts exposed by the server. Resources and prompts are available in other MCP-capable Copilot experiences, such as IDE chat, but they are not consumed by the cloud coding agent in this configuration.

The third statement is Yes under the planned configuration. Litware requires agent1 to access all available tools . GitHub custom-agent configuration supports this by omitting the tools property or specifying tools: [ " * " ]. Likewise, an MCP server can use " * " to expose all of its tools. Consequently, newly introduced MCP1 tools fall within that wildcard authorization and become available without individually adding each tool name.

Study Guide Reference Topics: MCP tool integration, custom-agent tool configuration, autonomous tool invocation, MCP capability boundaries, and least-privilege agent execution.

Separate branches isolate each agent’s proposed changes and allow the team to inspect them independently. Adding a required status check for file-level overlap detects conflicting modifications before either pull request is merged, preventing one agent’s work from silently overwriting another’s changes.

A read-only tool configuration prevents both agents from making required changes, so it avoids conflict by eliminating implementation capability rather than controlling it. CODEOWNERS approval adds review accountability for a specific file but does not automatically detect overlap between independent agent outputs. A single concurrency group serializes entire workflows and reduces throughput even where the agents work on unrelated files.

The selected solution maintains parallel development while creating a merge-time control for the actual risk: overlapping file changes. It also produces reviewable evidence of the overlap check in pull request status results.

Branch isolation does not eliminate semantic conflicts, such as incompatible API assumptions. Teams should therefore combine overlap detection with normal pull request review and integration testing.

Study-guide topics: parallel agent coordination, branch isolation, merge controls, and conflict detection.

A fine-grained PAT restricted to product-api provides an enforceable repository-level authorization boundary for agent1. GitHub fine-grained personal access tokens can be limited to selected repositories and assigned only the repository permissions required by the workload. Consequently, even if agent1 attempts to access billing-service or infra-terraform, the credential does not authorize access to those repositories. GitHub specifically recommends fine-grained PATs when repository access must be restricted to particular repositories.

This directly aligns with the GH-600 objective to configure an agent ' s scope to a specific repository and define execution boundaries through repository context and permissions. Microsoft Learn defines execution context as including the repository an agent can access and emphasizes that repository scope is the first boundary limiting agent behavior.

Option A provides behavioral guidance but is not a security authorization boundary. Option B controls the permissions available to the workflow token but does not, by itself, establish the required cross-repository credential restriction. Option D only prevents certain push operations; it does not stop agent1 from reading or otherwise accessing the other repositories.

Study Guide Reference Topics: Implement Tool Use and Environment Interaction → execution context and boundaries; repository-specific agent scope; tool permissions; least-privilege authentication.

The mcp-servers property connects a custom agent to the Model Context Protocol servers required for its planned work. MCP configuration makes defined external tools and services available to the agent in a controlled, declarative manner.

Adding a broad natural-language instruction such as “Use all available tools” does not configure a server connection, authenticate a tool, or define which external capabilities are available. It is also poor least-privilege design because it encourages unrestricted tool use without establishing a technical permission boundary.

Setting tools: [] removes all configured tools and would prevent the agent from using required capabilities. Deleting the tools line could cause the agent to inherit or expose a broader default tool set than intended. Repository-wide instructions can guide behavior, but they do not replace the agent-specific configuration needed to associate MCP servers with that agent.

A well-designed configuration identifies only the MCP servers necessary for the role, supplies secrets through approved environment mechanisms, and limits the resulting tools to the agent’s defined task.

Study-guide topics: MCP integration, agent tool configuration, and least-privilege environment access.

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

The API key should be stored as a secret in the Copilot environment and referenced by name from the MCP configuration. This keeps the secret value out of repository files, agent prompts, pull requests, and ordinary workflow output while allowing the MCP server to receive the required credential at runtime.

A plaintext key in a configuration file is unacceptable because repository history, forks, logs, and code review systems can expose it. A Codespaces user secret is scoped to a user development environment and does not provide the intended runtime secret for the Copilot agent environment. A GitHub Actions secret is useful for workflow expressions, but the scenario requires the key to be available to the MCP server configuration itself.

The prefixed environment-secret approach creates a clear boundary: the configuration references an identifier, while the secret value is resolved only in the authorized execution environment. This supports rotation without changing tracked configuration content.

Study-guide topics: MCP authentication, secrets management, secure environment configuration, and credential isolation.

Repository custom agent profiles belong in .github/agents/ and use Markdown files with agent configuration and instructions. When the intended changes concern the agents’ roles, available tools, or operating guidance, these profiles are the appropriate implementation point.

An agent profile provides a durable definition that can be shared with other repository contributors. Keeping that definition under version control makes changes reviewable and enables the team to associate a particular agent configuration with the code revision used during evaluation. This is useful when diagnosing why an agent’s behavior changed after its instructions or capabilities were modified.

Editor settings and MCP connection settings address different concerns. They can affect the environment in which an agent operates, but they do not replace the agent’s own profile. Changing a server connection is appropriate for transport or authentication requirements; changing an agent profile is appropriate for agent behavior and capability selection.

The source selects C. Its applicability depends on the omitted planned changes actually concerning custom agent configuration.

Study-guide topics: agent profiles, configuration management, and SDLC traceability. Reference: GitHub—Creating custom agents .

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

Copilot memory is an organization-level capability. Configuring it through the organization’s Copilot settings establishes the governance boundary, availability, and policy controls consistently for the developers and repositories covered by that organization.

Personal settings are unsuitable because they create inconsistent behavior between developers and do not provide centralized administration. A repository-level configuration can supply repository instructions and scoped context, but it does not replace the organization-level control that enables and governs the memory capability. An individual agent profile defines role behavior, tool access, prompts, and delegation settings; it is not the tenant-level location for enabling Copilot memory.

Organization configuration is particularly important when agents must retain approved context, recurring preferences, and workflow guidance across sessions without each developer configuring behavior independently. Central governance also allows administrators to maintain predictable controls over which organizational information is available to Copilot.

Study-guide topics: organizational governance, persistent context, and centralized agent configuration.

Yes, Yes, Yes

Comprehensive and Detailed 150 to 250 words of Explanation From Agentic AI Developer/Course Guide/topics:

All three statements are supported by explicit operational signals in the supplied logs.

The first statement is Yes . Each relevant session records Passing 1 MCP server(s) to SDK: [github] followed by github: type=http. These entries show that the GitHub MCP server is being supplied to the agent session as an available remote MCP integration. The CLIMCPServerEnabled=false entry concerns the separate CLI MCP configuration flag and does not negate the subsequently logged GitHub server passed to the SDK.

The second statement is Yes . The logs explicitly state workspace isolation mode selected for session and indicate that worktree creation is skipped. Therefore, the selected session isolation mechanism is workspace isolation rather than a separate Git worktree.

The third statement is Yes . Two distinct entries identify new Copilot CLI sessions with isNewSession: true: one beginning with session ID de04f0fe... and another with 6852c5dc.... Later MCP/configuration events do not contain another isNewSession: true record, so the evidence shows exactly two newly started sessions.

This type of log interpretation directly maps to the GH-600 requirement to identify failures and execution characteristics by analyzing logs, traces, outputs, and workflow artifacts , and to use operational signals when evaluating multi-agent behavior.

Study Guide Reference Topics: Perform Evaluation, Error Analysis, and Tuning; log and trace analysis; execution-context evaluation; MCP observability; multi-agent session analysis.

The selected location is appropriate when the planned developer changes concern repository-defined custom agents. Files under .github/agents/ define reusable agent roles that can be stored and reviewed alongside the application code. Their .agent.md format combines YAML configuration with Markdown instructions describing the agent’s responsibilities and expected behavior.

This arrangement allows the team to maintain specialized planning, implementation, and review roles consistently. Changes to an agent’s instructions or configuration can pass through the repository’s normal pull request process, providing a record of how the development workflow evolves.

The alternative locations serve different configuration purposes. .vscode/mcp.json configures MCP server connections for the workspace. .vscode/settings.json contains editor settings. Neither is the primary location for defining a repository’s custom agent profile.

The question’s planned changes are not reproduced in its supplied statement. Therefore, B is the source-selected answer under the custom-agent interpretation; a requirement specifically about MCP connectivity would require different configuration.

Study-guide topics: custom agent architecture, repository-scoped configuration, and version-controlled development workflows. Reference: VS Code—Custom agent file locations and structure .

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

Statement

Answer

The .github/upgrades folder contains all the required reports.

Yes*

The tasks.md file contains all the changes and their implementation status.

Yes

The assessment.md file lists all the breaking changes and their implementation status.

No

*For the standard upgrade-generated reports, including their scenario subfolder.

GitHub Copilot upgrade stores its generated workflow state under .github/upgrades/{scenarioId}. This includes the assessment, plan, task tracking, and related scenario records. Consequently, the parent .github/upgrades folder contains the standard upgrade reports through its scenario subdirectories. The PDF’s marked “No” for the first statement conflicts with that documented storage structure unless an additional, unstated reporting requirement applies.

The tasks.md file tracks execution progress. It identifies the upgrade tasks and records their implementation status as work proceeds. In this context, “all the changes” means the tracked upgrade tasks, rather than a complete line-by-line replacement for the Git diff.

The assessment has a different purpose. It describes the application’s compatibility issues, breaking changes, dependencies, and upgrade scope. It is not the authoritative execution-status record. Identifying a breaking change in an assessment does not establish that its remediation has been implemented or validated.

These files collectively separate the original findings, planned response, and execution progress, making the upgrade reviewable across sessions.

Study-guide topics: durable workflow state, progress tracking, and generated artifacts. Reference: Microsoft Learn—GitHub Copilot upgrade state management .

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

Target

Selection

Dropdown 1

' search '

Dropdown 2

' read '

The visible configuration describes an implementation planner. Providing search and read supports the information-gathering work needed to produce a technically grounded plan: locating relevant code and inspecting its contents. The listed documentation tools supplement repository context with external technical reference material.

This tool selection also establishes a practical boundary between planning and implementation. A planner can explain proposed changes and produce Markdown in its response without needing permission to modify repository files. Granting editing or command-execution capabilities would expand its authority beyond the visible planning role.

The distinction between generating Markdown and saving a Markdown file is important. The selected tools support producing a plan in conversation. If the requirements instead demanded that the planner write that plan directly into the repository, an appropriate file-writing capability or a separate persistence step would be necessary.

Tool names must also resolve to capabilities available in the configured environment. Merely listing a documentation tool does not install or authenticate its MCP server.

Study-guide topics: tool selection, least-privilege planning, and environment capabilities. Reference: VS Code—Use tools with agents .

A preToolUse hook evaluates the proposed command before the shell tool executes it. The hook can inspect command arguments and return permissionDecision: " deny " when a pattern indicates a high-risk operation, while allowing low-risk commands to continue automatically.

This is the correct enforcement point because the requirement is preventive. A policy banner only informs the user or agent; it cannot block execution. Logging submitted prompts provides audit information but does not evaluate the actual shell command. Ignoring the hooks directory simply removes the repository-scoped enforcement mechanism.

The hook should use precise matching rules. For example, it can deny sudo, destructive recursive deletion, and piping untrusted remote content into a shell, while allowing commands such as git status, package metadata inspection, and test execution. Rules should avoid broad string matching that blocks harmless commands merely because they contain similar text.

Study-guide topics: pre-execution guardrails, shell-command approval, policy enforcement, and autonomous tool safety. Reference: GitHub Copilot—Hooks reference .

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

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.

D is the best answer among the available choices. The key detail is that Summarizer is explicitly listed in Orchestrator ' s agents property. Current VS Code agent orchestration behavior states that explicitly listing a custom agent in the parent ' s agents array overrides disable-model-invocation: true for that coordinator. Therefore, option A does not explain the failure in this scenario.

Likewise, user-invocable: false does not prohibit programmatic or subagent invocation. It merely prevents users from manually selecting that agent from the agent picker; this setting is commonly used specifically for worker agents that should only operate as subagents.

Option C is also incorrect because Summarizer ' s function is to produce a summary, not modify repository content. It therefore does not inherently require editing tools.

The agents property establishes which subagents the coordinator is permitted to invoke; it does not itself define the sequence of workflow transitions. Handoffs are the mechanism for defining explicit guided transitions between agents. If the workflow expects Summarizer to run as the next defined phase but no corresponding transition/invocation exists, the missing handoff can explain why execution stops after Modifier.

Study Guide Reference Topics: Orchestrate Multi-Agent Coordination; custom subagents; agents restrictions; agent invocation controls; sequential handoffs and workflow transitions.

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

The most effective intervention occurs before the issue becomes an executable assignment. Acceptance criteria define the observable conditions that constitute success, while implementation directions establish boundaries and clarify how the work should proceed. Providing both before assignment reduces the need for the agent to infer missing requirements during planning.

Applied to this scenario, the issue should distinguish required outcomes from optional improvements and identify constraints that the implementation must respect. Where steps are ambiguous, the author should resolve the ambiguity or explicitly require clarification before execution. Reviewable criteria also give the agent and maintainers a shared basis for evaluating whether the resulting changes satisfy the original request.

Options A and D intervene after assignment or execution has begun. They may support later correction, but they do not prevent the initial plan from being based on unclear directions. Option C addresses dependency availability, which is a separate environmental concern.

The governing design principle is to make the task sufficiently definite before delegating action. Relevant curriculum topics include defining inputs and success criteria, validating agent plans, and separating preparation from execution.

C is the closest available classification because the explicit failure occurs during a tool invocation. The log identifies the Microsoft documentation search tool and records a JavaScript TypeError involving an undefined object’s invoke property. The preceding successful model requests do not establish successful tool execution; model generation and external tool invocation are separate operations.

For an operational report, the more precise description is tool invocation or integration failure . The evidence does not prove that the agent selected an inappropriate tool or supplied invalid arguments. An undefined invocation object can also result from an extension defect, stale tool registration, or another runtime integration problem. Therefore, “tool misuse” should be understood as the question’s broad tool-related category rather than a proven agent-behavior defect.

A network classification would require supporting evidence such as connection failure, DNS errors, or an HTTP response. A reasoning or context classification would require evidence that the agent’s interpretation or supplied information caused the failure.

The next diagnostic step is to inspect the MCP server’s output and registration state.

Relevant curriculum topics are classifying failure causes and distinguishing model behavior from tool and environment failures.

Statement

Answer

agent1 and agent2 jobs will run in parallel.

Yes

If the agent2 job fails, the workflow will fail.

Yes

GitHub Actions jobs run in parallel by default when no needs dependency establishes an execution order. Therefore, if agent1 and agent2 are independent jobs in the same workflow, they can begin concurrently when runners are available.

A job failure normally causes the workflow to be marked as failed. The workflow can be configured differently through conditional execution, continue-on-error, or dependent job logic, but no such exception is indicated here. An agent2 failure therefore results in a failed workflow outcome under standard behavior.

The environment: agent-sandbox setting identifies an environment associated with agent1. It does not itself create a dependency between agent1 and agent2, nor does it establish workspace isolation between them. Parallel execution requires separate coordination controls if both jobs can modify shared external resources or deploy to the same target.

Study-guide topics: parallel execution, job dependencies, workflow failure propagation, and execution environments. Reference: GitHub Actions—Workflow syntax .

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

Target 1 → E. needs

Target 2 → A. [spec_analyzer, risk_reviewer]

Target 3 → B. concurrency

The relevant completed section is:

plan_merger:

runs-on: ubuntu-latest

needs: [spec_analyzer, risk_reviewer]

steps:

- name: Merge executor outputs into a single plan

run: ./executors/plan_merger.sh

- name: Publish merged plan

run: echo " publish plan artifact "

concurrency:

group: multiagent-${{ github.ref }}

The plan_merger job must use needs: [spec_analyzer, risk_reviewer] . GitHub Actions jobs run in parallel by default when no dependency exists. Therefore, spec_analyzer and risk_reviewer can execute concurrently, implementing the fan-out phase. The needs array then establishes the fan-in dependency: plan_merger does not start until both upstream jobs complete successfully. GitHub explicitly defines jobs. < job_id > .needs as the mechanism for declaring jobs that must complete before another job runs.

The final blank is concurrency , because the following line already defines group: multiagent-${{ github.ref }}. GitHub ' s concurrency key groups workflow jobs or runs under a shared key so that overlapping executions for the same reference can be controlled. This is separate from the parallelism of the two specialized analyzer jobs.

This architecture directly implements a multi-agent orchestration pattern: independent specialized executors operate concurrently, their outputs converge at a deterministic coordination point, and execution boundaries are managed explicitly. The GH-600 study guide specifically requires candidates to apply orchestration patterns, configure parallel agent execution, and detect or prevent conflicts among concurrently operating agents.

Study Guide Reference Topics: Orchestrate Multi-Agent Coordination; fan-out/fan-in orchestration; parallel execution; dependency management; agent isolation and conflict control.

The correct answer is /context when the requirement is to verify the current token usage of the active context window . GitHub documents /context as the command that displays the active model and the number of tokens currently in use relative to the model ' s total context capacity. It also provides a breakdown across the system prompt, custom instructions, built-in tools, MCP tools, conversation messages, free space, and reserved buffer.

This is distinct from /usage . /usage reports broader session statistics , including AI Credits consumed, session duration, lines edited, and per-model token totals. Therefore, /usage is appropriate when reviewing cumulative session consumption, but /context is the more precise answer to a question asking for the current token usage of the working context.

/compact reduces context pressure by summarizing earlier conversation history; it does not merely report the current token state. /diff reviews code changes and is unrelated to context or token accounting.

Study Guide Reference Topics: Manage Memory, State, and Execution; context-window monitoring; token-budget management; maintaining effective long-running agent sessions.

Branch protection rule (main) – Require pull request before merging

Enabled

Workflow trigger for validation checks

on: pull_request

The branch protection setting must be Enabled . GitHub branch protection can require all changes to main to arrive through a pull request and can additionally require a defined number of approving reviews. For this scenario, the repository should require a pull request before merging and configure the required number of approvals to one . This creates a controlled merge boundary while leaving the coding agent free to create its own working branches and submit pull requests. A bypass for direct pushes would violate the requirement because it would provide a path for changes to reach main without review.

The validation workflow should use on: pull_request . GitHub Actions runs workflows for pull_request activity, with opened, synchronize, and reopened among the default triggering activities. Consequently, validation begins when the agent opens the pull request and reruns as the proposed change is updated.

This design separates autonomous low-risk actions —branch creation and PR creation—from the higher-risk operation of modifying the protected default branch. That is precisely the guardrail model tested by GH-600: maximize useful agent autonomy while requiring controlled authorization for consequential changes.

Study Guide Reference Topics: Implement Guardrails and Accountability; human-in-the-loop workflows; protected execution paths; explicit authorization; autonomous branch and pull-request operations.

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

The correct selection is --allow-all . GitHub Copilot CLI uses a permission model for potentially consequential operations such as invoking tools, modifying files, accessing filesystem paths, running shell commands, and reaching external URLs. Normally, these operations can require explicit approval. The --allow-all startup option grants all available permissions for the session, allowing Copilot to execute those operations without prompting for approval on each individual action. GitHub also provides --yolo as an alias for the same permission configuration.

This option is appropriate only when the execution environment is sufficiently isolated and trusted. GitHub specifically recommends using broad permissions in a sandbox or similarly disposable environment because the agent can modify or delete files and execute commands autonomously once approval barriers are removed.

/compact manages conversation context rather than permissions. --agent=Task selects an agent profile and does not globally pre-authorize tool execution. The GH-600 study guide explicitly assesses configuring agent tools, tool permissions, execution contexts, and safe autonomous actions , making permission scoping a core operational skill.

Study Guide Reference Topics: Implement Tool Use and Environment Interaction; configure agent tool permissions; evaluate execution context; safe autonomous execution.

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

The /compact command reduces the active conversation context while preserving a condensed summary of the important work completed so far. It is designed for long-running agent sessions that approach the context-window limit.

/clear would remove the session context rather than preserve the useful implementation history. This creates a sharper loss of continuity and does not meet the requirement to retain prior progress. /yolo concerns approval behavior, not context reduction. /context is used to inspect or manage context information but does not perform the required compaction.

Compaction is most effective when durable project state already exists in repository artifacts: source changes, commits, task files, plans, and test outputs. The summarized context can then retain decisions and current goals while the repository continues to hold the detailed implementation record.

Study-guide topics: context compaction, long-running sessions, durable state, and execution continuity.

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