Microsoft Developing in Agentic AI Systems GH-600 Exam Questions

Page: 1 / 14
Total 106 questions
Question 1

You have a GitHub Enterprise Cloud organization that uses a custom coding agent to run GitHub Actions workflows that create branches, open pull requests, and merge changes after required checks pass.

You need to log all agent-initiated actions and ensure that the logs are retained for two years.

What should you do?



Answer : A

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.


Question 2

You have a GitHub repository that uses the GitHub Copilot coding agent to run agent plans for assigned issues.

You discover that some issues contain ambiguous implementation steps.

You need to reduce the likelihood that Copilot executes plans based on ambiguous implementation steps.

What should you do?



Answer : B

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.


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

Question 3

You have a GitHub repository that contains an agent named Orchestrator. Orchestrator delegates work to the following specialized subagents:

Planner reviews issues and creates a plan of action.

Implementer writes code based on the plan of action.

Reviewer reviews the code.

You create a new agent named Summarizer that produces a concise summary of the work performed by the other agents.

You need to ensure that Orchestrator can invoke Summarizer as part of its workflow.

What should you do?



Answer : A

The configuration must be changed on the agent that performs the delegation. Orchestrator is responsible for coordinating the workflow, so its allowed subagent list must include Summarizer. Adding the new agent to that list makes it an available delegation target alongside Planner, Implementer, and Reviewer.

An agent's agents property identifies the custom agents it can invoke as subagents. The tools property serves a different purpose: it identifies available capabilities such as reading files, editing code, or invoking agents. Adding a custom agent's name to the tools list does not register that agent as a callable subagent. The agent invocation tool must also be available; the scenario already establishes that Orchestrator delegates to other subagents.

Changing Reviewer's configuration would enable a relationship originating from Reviewer, rather than the requested direct invocation by Orchestrator. A handoff also represents a different interaction pattern from having the orchestrating agent invoke a subagent and receive its result.

Availability does not force execution on every task. Orchestrator's instructions should indicate when a summary is required and what information it should contain.

Study-guide topics: delegation permissions, orchestrator responsibilities, and specialized subagents. Reference: VS Code---Subagents.

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


Question 4

In Microsoft Visual Studio Code, you are using GitHub Copilot Chat to generate documentation for a new feature.

Earlier in the day, you used Copilot Chat extensively for an unrelated refactoring task.

You discover that the Copilot responses for the new documentation task are influenced by the earlier conversation.

You need Copilot to focus only on the current task and avoid using prior conversational context. The solution must NOT affect other conversations.

What should you do?



Answer : D

Starting a new Copilot Chat conversation establishes a separate conversational context for the documentation task. The unrelated refactoring exchanges remain in their original conversation instead of continuing to influence the new thread. This directly addresses the requirement to separate tasks while preserving other conversations.

Conversation history contributes information beyond the latest prompt. Earlier instructions, assumptions, terminology, and design decisions can continue to affect subsequent responses within the same session. A fresh conversation provides a clear task boundary, allowing the developer to supply the feature requirements and relevant documentation context explicitly.

Changing from sidebar chat to inline chat changes the interaction surface; it does not provide the same explicit separation of conversational history. Referencing a file supplies relevant context but does not reliably remove earlier instructions. The maximum requests setting governs agent execution limits rather than conversation isolation. Clearing history is also unnecessary when the previous work can remain available in its own session.

A new conversation can still receive applicable repository instructions and deliberately supplied context; it is the previous conversation that is separated.

Study-guide topics: conversational state, context isolation, and task boundaries. Reference: VS Code---Manage agent sessions.

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


Question 5

You have a GitHub repository that uses the GitHub Copilot coding agent to resolve issues in an ephemeral GitHub Actions environment.

Builds fail unless an environment variable named NPM_TOKEN is available, because the repository depends on a private package registry.

A workflow named .github/workflows/copilot-setup-steps.yml was added but was merged into a non-default branch and does NOT run when new agent sessions start.

You need to ensure that for every new agent session, the setup steps run, and the private registry token is available as NPM_TOKEN, without hardcoding secrets in the repository.

What should you do?



Answer : B

The Copilot setup workflow must be present on the repository's default branch to be used for new coding-agent sessions. Moving .github/workflows/copilot-setup-steps.yml there ensures the setup procedure is discoverable for every newly created agent environment.

The package-registry credential should be stored as an environment secret in the Copilot environment and exposed using the required variable name, NPM_TOKEN. This permits package installation without committing the token into workflow YAML, instructions, source code, or pull requests.

Disabling network controls does not resolve missing credentials and expands risk unnecessarily. Repository instructions can describe setup expectations but cannot safely substitute for an injected runtime secret. Adding the raw token to YAML permanently exposes it to repository history and anyone with repository access.

Study-guide topics: ephemeral environments, setup workflows, environment secrets, and secure dependency access.

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


Question 6

You have a GitHub Enterprise organization that has Copilot memory enabled.

You create a new repository.

What are two ways that memories will be deleted from the repository? Each correct answer presents a complete solution.

NOTE: Each correct selection is worth one point.



Answer : A, D

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.


Question 7

You have a GitHub Copilot coding agent named Orchestrator that runs a multi-phase workflow by using the following subagents:

Explorer gathers context by using read-only tools.

Modifier applies focused edits.

You are adding a new agent named Summarizer that generates a concise summary after modifications are complete. Summarizer includes the following YAML frontmatter:

---

name: Summarizer

description: Produce a concise summary of recent changes

tools: ['fetch']

user-invocable: false

disable-model-invocation: true

---

The Orchestrator agent lists all three agents in its agents property.

After adding the Summarizer agent, Orchestrator successfully runs Explorer and Modifier but fails to run Summarizer.

What is a possible cause of the failure?



Answer : D

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.

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


Page:    1 / 14   
Total 106 questions