GH-600 Exam Dumps - Developing in Agentic AI Systems

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 .

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

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.

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.

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

The artifact.destroy audit log event records manual deletion of workflow artifacts. It provides the event data needed to identify the actor responsible for the deletion and the time at which it occurred.

Pull-request comments and descriptions can describe review activity, but they are not authoritative evidence of artifact deletion. Merge commits only establish repository-history changes and do not record deletion of workflow artifacts. A checks-related log event is unrelated to artifact lifecycle management.

Audit records should be correlated with the affected repository, workflow run, artifact name, and timestamp. This produces a traceable explanation of why evidence from a particular run is no longer present. Where long-term retention is required, the organization should combine artifact policies with external audit-log retention or streaming.

Study-guide topics: artifact accountability, audit events, evidence retention, and workflow investigation.

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

Unassigning and reassigning the issue is GitHub’s documented retry action for an issue-driven agent session that remains stuck and times out. The troubleshooting guidance states that a persistently stuck session times out after an hour. At 70 minutes with no continuing activity, the scenario therefore calls for a fresh execution trigger rather than indefinite waiting.

Reassignment reissues the task through its original issue context. This makes C the appropriate selection among the available actions. The issue should contain current requirements so that the retry begins with the intended scope rather than repeating an outdated assignment.

Option B is incorrect because a draft pull request should not be merged simply to restart implementation, and Copilot does not respond to new mentions on merged or closed pull requests. Option D authorizes repository workflow execution rather than restarting the agent.

For operational precision, reassignment is a documented retry mechanism, not a universal guarantee that every retry reuses the same pull request. Where preserving a particular pull-request branch is essential, an authorized @copilot comment on that open pull request directly targets it.

Relevant curriculum topics are timeout recovery, task reinitialization, and preserving execution continuity.

An environment variable mapping connects the defined environment secret to the exact environment variable required by the MCP server at startup. This allows the MCP server to receive the API key without embedding the secret’s value in repository configuration.

A default environment variable is not sufficiently targeted because it can expose data more broadly than necessary. An Actions repository secret is a secret storage mechanism, but the scenario already uses an environment secret and requires controlled injection into the MCP server process. The JSON configuration should reference the mapping or variable name; it must not contain the raw key value.

The mapping provides the least-privilege boundary: only the intended secret is made available, under the expected variable name, to the MCP process that needs it. It also supports credential rotation because the stored secret can be replaced without modifying committed MCP configuration.

Study-guide topics: MCP credential injection, environment secrets, least privilege, and secure tool startup.

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

A is the intended answer among the supplied choices , because the required control is a Copilot-specific content exclusion mechanism rather than Git authorization or branch governance. The important technical concept is excluding the sensitive directory from Copilot ' s usable context and suggestions.

Current GitHub documentation implements this through Copilot Content exclusion settings at repository, organization, or enterprise scope. Administrators can specify exact files, directory paths, and patterns to exclude. For excluded content, GitHub states that inline suggestions are unavailable in the affected files, excluded file content does not inform suggestions elsewhere, and the files are excluded from supported Copilot responses and code review.

Neither CODEOWNERS nor branch protection prevents Copilot from reading or generating suggestions for a particular directory. CODEOWNERS establishes reviewers/ownership, while branch protections and rulesets govern repository operations such as pushes, merges, and review requirements. Those mechanisms operate too late in the lifecycle to satisfy a requirement concerning Copilot ' s access to sensitive file content.

For exam purposes, therefore, A maps to the content-exclusion concept . In current GitHub administration, implement the control through Settings → Copilot → Content exclusion and specify the sensitive directory path.

Study Guide Reference Topics: Implement Guardrails and Accountability; sensitive-context exclusion; least exposure; repository security boundaries.

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.