GH-600 Exam Dumps and Practice Questions

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.

Workflow artifacts provide the required combination of retained execution evidence and file transfer between jobs. The agent-run job uploads trace.json and plan.md, associating both files with the workflow run. Reviewers can access the resulting artifact through the run's GitHub Actions interface, while downstream jobs download it to their own execution environments.

This is necessary because separate jobs do not automatically share a local filesystem. Declaring a dependency establishes execution order but does not transfer the generated files. The review and deployment stages therefore need explicit artifact downloads in addition to their appropriate job dependencies.

Committing transient traces and plans introduces repository changes solely to transport run-specific evidence. A network share adds external infrastructure and does not directly satisfy the requirement for standard Actions artifact access. Dependency caching is intended for reusable inputs such as downloaded dependencies; it is not the appropriate mechanism for authoritative outputs from a particular agent run.

Artifacts preserve the plan and trace that informed the review, allowing subsequent deployment activity to use the corresponding files. Relevant curriculum topics are inspectable agent artifacts, observability, and human intervention.

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.

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.

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.