GH-600 Developing in Agentic AI Systems Questions and Answers

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 intended distinction is between delegating analytical work and allowing the agent to provide the final approval of its own work. Approving all Git commits would remove independent review of changes that include security-sensitive remediation and compatibility modifications across multiple projects.

Human validation of assessment.md is similarly important because the assessment determines the scope and direction of the upgrade. Incorrectly classified dependencies, missed projects, or an incomplete vulnerability analysis can propagate into the implementation plan. Microsoft’s guidance explicitly recommends reviewing the assessment for missing projects, problematic dependencies, and application-specific concerns before proceeding.

Generating the assessment and checking whether a task file exists are appropriate automated activities. An agent can also inspect the plan’s dependency relationships and flag potential ordering problems. Such assistance does not transfer final accountability for accepting the plan.

The wording should not be interpreted as prohibiting automated assessment validation. Agents can run valuable consistency checks; the unsafe delegation is treating those checks as sufficient independent approval of their own conclusions.

Study-guide topics: human oversight, independent validation, and approval boundaries. Reference: Microsoft Learn—Best practices for GitHub Copilot upgrade .

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

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.

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 .

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

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 .

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

Repository memory is supported by citations to the code that establishes the remembered fact. When a fact appears relevant to a new task, Copilot checks its supporting citations against the current branch before relying on it. This validation prevents an observation from an earlier repository state from being treated automatically as current truth.

The branch check is particularly important when work spans release branches, experimental changes, or pull requests that were never merged. A memory may have been accurate when created but no longer describe the code now being edited. If its supporting code is absent or no longer supports the claim, the remembered fact should not influence the task.

Option A incorrectly describes memory as permanently retained information requiring only manual intervention. Option B substitutes pull-request disposition for validation of the underlying evidence. Option C incorrectly treats repository knowledge as usable only by its original contributor.

The governing mechanism is evidence validation at the point of use, not an assumption that all previously stored information remains authoritative.

Relevant curriculum topics are task-relevant memory, stale-context prevention, and maintaining state consistency across branches and sessions.

Option C is the intended answer because it grants a specific tool permission associated with Git rather than enabling every tool or allowing general file modification. The -p argument supplies the prompt programmatically, making the command suitable for a script that requests a summary of recent repository activity.

Option A grants unnecessarily broad tool access. Option B denies the Git capability needed to inspect commit history. Option D authorizes file-writing functionality, which is unrelated to producing a read-only summary.

The permission boundary nevertheless requires precise interpretation. Allowing Git is not inherently equivalent to enforcing read-only behavior: Git includes commands that modify files, repository state, and remote branches. A strict implementation should authorize only the required inspection commands, such as git log, using the permission-pattern syntax supported by the installed CLI version. The prompt should request summarization, but the prompt itself is not an access-control mechanism.

Therefore, C is the narrowest relevant selection among the supplied options, while command-specific restrictions are necessary to establish a genuinely read-only execution policy.

Relevant curriculum topics are selecting required tools, configuring tool permissions, and applying least privilege to agent execution.

A repository skill stored under .github/skills/ < skill-name > /SKILL.md provides reusable, task-specific guidance that can be invoked when relevant. Because it is committed to the repository, the guidance is available in ephemeral development containers without relying on a developer’s local configuration.

Repository-wide instructions in .github/copilot-instructions.md are applied broadly and are suitable for enduring conventions, architectural rules, or team standards. They are not the best choice when guidance should apply only to a particular task or workflow.

Personal instructions are user-specific and do not provide a version-controlled, team-shared implementation. A .copilot/skills path does not represent the repository-scoped skill location required by the scenario.

Task-specific skills improve precision by supplying focused procedures, reference material, and constraints only when the related task is active. This prevents unrelated work from being burdened by instructions that do not apply.

Study-guide topics: agent skills, repository-scoped guidance, contextual instructions, and ephemeral development environments.

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

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 command is /diff . GitHub Copilot CLI provides /diff specifically for reviewing code changes directly from the terminal. GitHub ' s current CLI command reference defines /diff as a command that reviews changes in the current directory and can automatically switch to a branch comparison when the working tree is clean. This makes it the appropriate command when validating an agent-generated change set before accepting or merging the work.

The other commands serve different purposes. /context displays context-window utilization, including token allocation and remaining context capacity; it does not show code modifications. /compact summarizes conversation history to reclaim context-window space during long-running sessions. /plan creates an implementation plan before coding and restricts normal project-file modifications while the plan is being prepared.

Using /diff supports an essential human-in-the-loop control in agentic software development: generated code should be inspected before it crosses a merge or deployment boundary. Reviewing the diff exposes additions, deletions, and modifications so that unintended or unsafe changes can be identified before integration.

Study Guide Reference Topics: Implement Tool Use and Environment Interaction; agent-generated code review; human-in-the-loop validation; controlled execution and change inspection.

Selecting release/1.4 as the base branch establishes the correct repository context before the agent begins its assignment. GitHub documents that Copilot creates its working branch from the selected base branch. This ensures that the initial code, dependency declarations, and branch-specific files correspond to the release being repaired.

That distinction matters because a hotfix developed against main may depend on APIs, package versions, or build behavior that do not exist in the maintained release. Choosing the release branch at task creation removes the need for the agent to infer or subsequently correct its starting point. The task should also require validation using the release’s applicable checks.

Option A controls concurrency rather than branch selection. Option B governs review requirements for changes to main; it does not determine where the agent starts. Option C supplies a natural-language instruction but is less direct than configuring the actual base branch before execution.

The selected answer configures the execution environment through the platform’s supported task controls.

Relevant curriculum topics are branch-based scope, execution-context selection, and environment-specific constraints.

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.

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.

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.

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.

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.

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