Pass the Microsoft GitHub Administrator GH-600 Questions and answers with CertsForce

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 .

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

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.

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 .

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

The tasks.md file is the execution-tracking document for the upgrade scenario. It records individual tasks, their validation criteria, and their completion status. Microsoft’s upgrade walkthrough specifically directs users to review this file when checking the status of every upgrade step.

A task can include several concrete verification activities, such as restoring dependencies, building the solution, correcting compilation errors, running the test suite, and rerunning tests after fixes. Reviewing these entries reveals whether implementation has merely been attempted or has satisfied the defined checks.

The assessment identifies upgrade issues and scope; it does not serve as the live record of completed work. A plan describes intended actions and ordering, which also differs from evidence that execution and testing succeeded.

The phrase “before App1 is upgraded” requires temporal care. Before execution, tasks.md identifies the steps and checks that must be performed. It cannot prove that future tests have already passed. Completion and test results become available as the agent executes and updates the tasks.

Study-guide topics: execution validation, task status, and acceptance criteria. Reference: Microsoft Learn—Execute and verify a Copilot upgrade .

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

The agent session log is the appropriate starting point when the reported problem concerns an agent’s interaction, execution sequence, or tool activity within the development environment. It provides information closer to the failing behavior than repository-level workflow usage statistics.

A useful investigation establishes what the agent was asked to do, which operations it attempted, what responses those operations returned, and where progress stopped or diverged from the intended result. Session diagnostics can help distinguish an instruction problem from an unavailable tool, a rejected operation, or an execution error. VS Code also provides detailed chat debugging facilities for inspecting interactions and diagnosing failures.

GitHub Actions usage metrics primarily describe workflow consumption. Runner logs are relevant when evidence points to a hosted workflow or runner problem. The token permissions block becomes relevant when the failure concerns authorization to a GitHub resource. None should be assumed to be the root cause before examining the reported execution.

The PDF selects B; the underlying Dev1 incident description is not included, so this selection assumes a session-level agent issue.

Study-guide topics: diagnostic evidence, tool-call inspection, and failure localization. Reference: VS Code—Debug chat interactions .

The agents frontmatter property defines the custom agents that the current agent can invoke as subagents. It establishes the delegation boundary for an orchestrator or other coordinating agent.

The tools property grants operational capabilities such as file access, terminal commands, MCP tools, or the agent invocation tool itself. It does not identify the specific custom-agent profiles available for delegation. The mcp-servers property configures external MCP servers; it does not define subagent membership.

Handoffs are user-facing transitions from one custom agent to another. They are useful for moving a conversation from planning to implementation but are not the configuration mechanism for an agent’s available subagent array. The target field identifies an execution target or context and is unrelated to delegation membership.

For a reliable orchestration design, include only the required specialized agents in the agents list and ensure the parent agent has the appropriate agent-invocation capability.

Study-guide topics: subagent lists, delegation boundaries, orchestrator design, and multi-agent coordination.

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

Target

Correct selection

Condition identifying the pull request author

github.event.pull_request.user.login == ' github-copilot[bot] '

r.user.type ===

' User '

r.user.login !==

' github-copilot[bot] '

The first target must inspect the pull request’s author rather than the account that triggered the workflow. The expression github.event.pull_request.user.login identifies that author, whereas github.actor identifies the initiating actor and can differ during subsequent workflow activity. Using the bot identity supplied in the question, the selected condition identifies pull requests that the blocking step must reject.

The review predicate then requires an approved review, an existing reviewer object, a reviewer type of User, and a login different from the specified bot. These selections implement the intended distinction between a human approval and an automated review.

For merge enforcement, the resulting check must also be required by branch protection or a repository ruleset. A failed workflow alone does not universally prevent merging. The review-querying job additionally needs appropriate pull-request read permission. A production implementation should evaluate current effective approvals and rerun when reviews change, rather than accepting any historical approval indefinitely. It should also match the actual bot login recorded in its event payload.

Relevant curriculum topics are enforcing human review, identifying accountable actors, and implementing controls outside the model’s instructions.

Statement

Selection

The configuration of the planner agent explicitly prevents code changes from being produced in the same conversation.

Yes*

The planner agent is violating its allowed tools by attempting internet access, and removing search will resolve the issue.

No

Adding a repository-level .github/copilot-instructions.md file that requires the agent to run tests and linters will mitigate the stalled pull request that has a failing CI anti-pattern.

Yes

*Interpreting “code changes” as direct file modifications by the correctly loaded planner, not code suggestions printed in chat or changes after switching agents.

The intended first selection is Yes: the planner has a read-oriented tool set, explicit planning-only instructions, and a handoff that does not automatically submit the implementation prompt. When this profile is correctly loaded and enforced, the planner lacks an editing tool for direct file modification. However, this does not prevent it from displaying proposed code in a response, nor does it permanently restrict another agent subsequently selected in the conversation. Unexpected file edits warrant checking the active profile and actual tool availability.

The second selection is No. The configured fetch capability permits network retrieval, so an internet-access attempt does not itself demonstrate tool misuse. Furthermore, firewall failures in the GitHub coding agent environment must be investigated in that environment; removing local search capability does not address their cause.

The third selection is Yes because repository instructions can specify the commands and expectations for testing and linting, helping reduce pull requests that fail CI. This mitigation does not independently resolve blocked network dependencies.

Relevant curriculum topics are planning/execution boundaries and diagnosis of agent anti-patterns.

The filter action:artifact.destroy selects the audit event associated with manual deletion of a workflow artifact. It directly targets the activity described in the scenario, allowing the investigator to examine the recorded actor and associated event details.

A repository filter narrows the search to a particular repository but does not distinguish artifact deletion from other recorded operations. It can usefully accompany the action filter when investigating a specific project. A workflow-run action concerns workflow execution rather than the manual removal of its stored artifacts. The generic operation:remove option does not select the documented artifact deletion event.

The investigation should correlate the deletion event with its timestamp and repository information, then inspect the actor recorded for that event. This identifies the account associated with the action; additional context may be needed when an application or automated identity performed it.

Artifact retention and audit logging serve separate purposes. Retention controls how long outputs are normally preserved, while the audit log records relevant administrative and user activity. Searching the audit log does not restore deleted content.

Study-guide topics: accountability, evidence preservation, actor attribution, and audit trails. Reference: GitHub—Organization audit log events .

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.