GH-600 Developing in Agentic AI Systems Questions and Answers

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 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 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 .

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 .

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.

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 .

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

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.

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

A preToolUse hook is a possible cause because it evaluates a proposed tool invocation before execution. Such a hook can inspect the tool name and arguments, identify a prohibited operation, and deny permission. A shell command containing recursive, forced deletion of an infrastructure directory is an appropriate target for this type of preventive rule.

The decisive evidence is the statement that the command was blocked because a destructive operation was detected. This describes a decision about the proposed command rather than a failure to reach a network destination. Copilot firewall controls address network access; they do not ordinarily classify local filesystem deletion commands. A postToolUse hook runs after a tool operation and therefore does not provide the same pre-execution interception.

An application installation policy governs application access or installation rather than this command-level decision. The surrounding script can treat a denied operation as a task failure and escalate it for human review, producing the displayed exit status.

The answer identifies a plausible enforcement mechanism; the log does not establish its exact implementation.

Study-guide topics: preventive guardrails, tool authorization, destructive-action detection, and escalation. Reference: GitHub Copilot—Hooks reference .

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

tools: [ ' search ' , ' read ' , ' fetch ' ]

send: false

The completed configuration is:

name: planner-agent

description: Planning

tools: [ ' search ' , ' read ' , ' fetch ' ]

handoffs:

- label: Start Implementation

agent: implementer

prompt: Now implement the plan outlined above.

send: false

The planner must be restricted to read-only capabilities, so [ ' search ' , ' read ' , ' fetch ' ] is the correct tool set. search locates repository information, read inspects file contents, and fetch retrieves supporting information without modifying source files. The other available tool combinations contain write-capable operations such as edit, commit, push, merge, or publish, which would violate the requirem ent that the planner must not alter the repository before approval. VS Code custom agents explicitly support scoping tools so that planning agents can be constrained to research and analysis capabilities.

The send property must be false. A handoff appears as an interactive transition after the planner produces its response. With send: false, selecting the handoff switches to the implementation agent and pre-fills the implementation prompt, but the prompt is not automatically submitted. This provides the necessary human approval gate: the plan can be reviewed before implementation begins. By contrast, send: true immediately submits the handoff prompt after the transition.

Study Guide Reference Topics: agent role separation, least-privilege tool assignment, planning versus execution, multi-agent handoffs, and human approval gates.

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

Answer area

Correct selection

To draft and open the pull request, use

GitHub Copilot coding agent assigned to an issue

To automate the pull request review before the human review, use

GitHub Copilot code review on the pull request

The workflow requires two distinct capabilities: implementing the requested change and reviewing the resulting change. Assigning the issue to the Copilot coding agent supplies the implementation task. The agent can inspect the repository, modify code, add or update tests, and open a pull request for review. This matches the requirement to turn an assigned issue into a proposed implementation. GitHub—Use Copilot cloud agent on GitHub .

Copilot code review examines the pull request and produces review feedback. It therefore belongs after the implementation has produced a reviewable diff and before the workflow requests the intended human review. The automation must request or configure this review at the appropriate stage; assigning an issue alone does not establish the complete review sequence.

CI, automated code review, and human review provide complementary checks. CI validates executable requirements such as tests and lint rules. Automated review highlights potential code issues. Human reviewers retain responsibility for assessing the proposed change and satisfying applicable approval requirements. GitHub—Copilot code review .

Study-guide topics: agent integration into the SDLC, issue-to-pull-request workflows, automated validation, and human review.

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

Answer Area

Correct Selection

When a previous prompt is no longer relevant

Delete the irrelevant request from the conversation.

To keep Copilot Chat focused in the IDE

Open related files.

For the first selection, Delete the irrelevant request from the conversation is the most precise action. GitHub Copilot Chat incorporates conversation history when constructing context for subsequent prompts. GitHub ' s documented best practice states that when a particular request is no longer useful context , that request should be deleted. Starting an entirely new chat is appropriate when none of the current conversation remains useful, but it would unnecessarily discard relevant history in this scenario.

For the second selection, Open related files . GitHub recommends opening files relevant to the current task and closing irrelevant files when working with Copilot in an IDE. In VS Code, relevant files, selected code, explicit file references, and workspace context help Copilot concentrate on the code associated with the current work item.

Changing to agent mode does not remove irrelevant conversational context; it changes the execution capability and autonomy level. Disabling Copilot for the repository would prevent use entirely and therefore fails the requirement.

The combination of removing stale conversational content and presenting only pertinent workspace context minimizes effort while keeping the model ' s effective context focused.

Study Guide Reference Topics: Manage Memory, State, and Execution; conversation-history management; context-window relevance; explicit IDE context; minimizing stale state.

Automatic compaction occurs when the conversation approaches the context-window threshold. The system summarizes or compresses earlier context so that the session can continue without exceeding the model’s available context capacity.

Compaction is driven by conversational context volume, not by the size of a local state file or elapsed session duration. It also does not mean that the agent switched models. The purpose is to retain the most relevant working information while reducing the amount of prior detail that must remain in the active context.

For long implementation sessions, developers should preserve important decisions in durable artifacts such as repository files, task lists, plans, issues, and commits. This reduces reliance on the conversation retaining every implementation detail verbatim. After compaction, the developer should verify the current plan, changed files, and pending tasks before authorizing consequential operations.

Study-guide topics: context-window management, compaction, durable state, and long-running agent sessions.

CodeQL findings and secret-detection results are the intended selections. CodeQL analyzes code for patterns associated with vulnerabilities and programming errors. Secret scanning identifies sensitive material, including supported credential and token patterns, that may have been introduced into the generated changes. Both provide concrete security evidence that a reviewer can evaluate alongside the proposed fix.

Linting generally evaluates coding conventions and selected correctness rules; a generic linting failure is not necessarily a security finding. Median time to merge measures delivery performance rather than the security of a particular change.

The wording of option D creates an important technical distinction. Dependency vulnerability detection is also a genuine automated security signal. GitHub explicitly documents dependency analysis alongside CodeQL and secret scanning in the coding agent’s security checks. Repository-level dependency alerts, however, may concern existing vulnerabilities rather than changes introduced by this pull request. B and C are the clearest intended pair, but D cannot be dismissed as unrelated to security.

Reviewers should determine whether each finding applies to the proposed changes and whether the underlying vulnerability has actually been resolved.

Relevant curriculum topics are automated evaluation signals, security scanning, and evidence-based assessment of agent outputs.

Order

Action

1

In the product-api repository settings, create a GitHub Actions environment named plan-review and add SG_Review as the required reviewers.

2

To the agent1 workflow, add a plan job that runs first and uploads the plan output as a workflow artifact.

3

Add an execute job that has needs: [plan] and environment: plan-review.

The review environment must exist before a workflow job can reference it. Required reviewers on plan-review establish the approval gate that protects execution of the agent’s proposed plan.

The workflow then requires a plan job that runs before execution and uploads the plan as an artifact. This creates a durable review object rather than requiring reviewers to approve an undocumented or transient agent decision. The artifact is available for inspection during the approval stage and for later audit.

Finally, the execute job declares needs: [plan] to enforce sequencing and targets the plan-review environment. When that job reaches the protected environment, required reviewers must approve it before the protected execution can proceed. This creates a contro lled sequence: generate evidence, review evidence, then authorize execution.

Branch-protection rules and automatic advancement are not substitutes for environment-based approval of the execution job.

Study-guide topics: human-in-the-loop approvals, protected environments, artifacts, and staged agent execution.

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

GitHub Copilot repository memories can be removed manually and through automatic retention cleanup . Repository owners or administrators can review repository-level facts under the repository ' s Copilot Memory settings and delete stored facts that are obsolete, misleading, or no longer appropriate. This makes A a valid deletion mechanism.

D is also correct. GitHub applies an inactivity-based retention policy: a stored repository fact or user preference that goes unused for 28 days is automatically deleted . The 28-day period can restart when Copilot successfully validates and uses that memory, so this should be understood as an unused-memory expiration period rather than an unconditional deletion exactly 28 days after creation.

Deleting the source code referenced by a memory does not directly delete that memory. Repository-level facts retain citations and are validated against the current branch before use; if the supporting information is no longer valid, Copilot does not use the fact. Likewise, archiving a repository or merging a pull request is not documented as an automatic memory-deletion event.

Study Guide Reference Topics: Manage Memory, State, and Execution; repository memory lifecycle; memory validation; memory retention and deletion; persistent agent knowledge.

Signal

Execution context

The eyes emoji reaction appears on the issue.

The agent acknowledges the assignment and will create the draft pull request.

The pull request timeline shows Copilot started work.

The agent session is actively running and generating live logs.

A draft pull request exists, but GitHub Actions checks are not running.

A human must manually approve and run the workflows.

The eyes reaction signals that Copilot has acknowledged the issue assignment. It is an early lifecycle indicator that the coding agent accepted the work and will begin its workflow.

A pull-request timeline event showing that Copilot started work indicates an active session. This is the appropriate place to observe ongoing status updates and session activity while the agent creates or revises the draft pull request.

When the draft pull request exists but its workflows have not started, the likely state is pending manual authorization. GitHub can require a user with write access to approve and run workflows associated with the pull request, especially where the workflow originates from an untrusted context or requires explicit approval.

These indicators are complementary: issue reactions establish acknowledgement, timeline events show active execution, and inactive checks can identify an approval gate rather than an agent failure.

Study-guide topics: asynchronous coding agents, execution signals, workflow approval, and pull-request observability.

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

Audit log streaming is the correct choice because it exports audit events to an external destination where the organization can apply its required two-year retention policy. This captures agent-initiated activity as part of the organization’s auditable GitHub events.

Standard audit-log retention in GitHub may not meet a long-term evidence requirement on its own. Streaming allows the organization to store and search the exported events in a SIEM, data lake, or logging platform with retention controls aligned to compliance policy.

Log forwarding is not the required GitHub audit mechanism in this scenario. Enabling Git events can increase event visibility, but it does not independently provide the requested long-term retention of all relevant agent-initiated actions.

The external destination should preserve actor details, timestamps, repository identifiers, action types, and correlation information needed to reconstruct agent activity during an investigation.

Study-guide topics: accountability, audit log streaming, retention, and agent activity traceability.