Bearlow's Exam Prep

bearlow./GH-600/Summaries

Prepare agent architecture and SDLC processes · 15-20%

Implement tool use and environment interaction · 20-25%

Manage memory, state, and execution · 10-15%

Perform evaluation, error analysis, and tuning · 15-20%

Orchestrate multi-agent coordination · 15-20%

Implement guardrails and accountability · 10-15%

65 summaries

summary

Add agents to existing multi-agent workflows

Overview

Within the 'Orchestrate multi-agent coordination' section of GH-600, adding agents to an existing multi-agent workflow means extending a running pipeline with new specialized participants without rebuilding the pipeline from scratch. GitHub Copilot supports this through two complementary mechanisms: the Copilot SDK's Microsoft Agent Framework (MAF) integration, and the custom agent profile system used by Copilot cloud agent. The MAF integration (available via the `GitHub.Copilot.SDK` and `Microsoft.Agents.AI.GitHub.Copilot` packages for .NET, and equivalent Python packages) wraps a Copilot SDK client as a first-class MAF agent using the `AsAIAgent()` method. Because MAF defines a standard interface for all agent providers, a newly wrapped Copilot agent is interchangeable with Azure OpenAI, Anthropic, or any other MAF-compatible provider in the same orchestrator. Existing `SequentialOrchestrator` or `ConcurrentOrchestrator` pipelines accept the new agent by adding it to the agent array, without requiring changes to the other agents in the workflow. For Copilot cloud agent on GitHub.com, a new agent is added by committing a `.agent.md` file to the `.github/agents` directory (repository scope) or to the root `agents` directory in a `.github-private` repository (organization or enterprise scope). The profile's YAML frontmatter specifies the agent's `name`, `description`, `tools`, `mcp-servers`, and optionally a `model` or `target` environment. Once the file is merged into the default branch, the agent appears automatically in the cloud agent dropdown for task assignment, issue handling, and CLI invocation via the `/agent` slash command. No restart or redeployment of the existing workflow is required. Best practice when adding an agent is to give it a focused role with non-overlapping instructions. Errors from a newly added agent should be caught at the orchestration level so that one agent's failure does not block the entire pipeline.

Key Points

A Copilot SDK client is added to an existing MAF multi-agent workflow by calling `copilotClient.AsAIAgent()` and passing the resulting `AIAgent` object to the orchestrator's agent array alongside other provider agents.

MAF integration packages for .NET are `GitHub.Copilot.SDK` and `Microsoft.Agents.AI.GitHub.Copilot --prerelease`; TypeScript and Go developers use the Copilot SDK directly without the MAF wrapper.

A custom Copilot cloud agent is introduced into an existing workflow by committing a `.agent.md` file to `.github/agents` (repository level) or to the `agents` directory in a `.github-private` repository (organization or enterprise level), and merging it into the default branch.

The YAML frontmatter of a custom agent profile supports `name`, `description`, `tools`, `mcp-servers`, `model`, and `target` properties, while the Markdown body defines the agent's behavioral instructions up to a maximum of 30,000 characters.

MAF orchestrators support both sequential pipelines (`SequentialOrchestrator`) and concurrent pipelines (`ConcurrentOrchestrator`), allowing a newly added agent to be inserted at a specific position in the chain or run in parallel with existing agents.

When Copilot cloud agent completes a pull request using a custom agent, it records which custom agent handled the task in the pull request description, providing an audit trail consistent with the lifecycle management requirements of the parent section.

source →

Common Pitfalls

Practitioners assume that MAF integration packages are available in all languages, so they attempt to use `AsAIAgent()` in TypeScript.

MAF integration packages exist only for .NET and Python; TypeScript and Go developers must use the Copilot SDK directly, which provides tool calling, streaming, and custom agent support without the MAF wrapper.

Developers believe that setting `onPermissionRequest` to always return `{ kind: 'approved' }` is safe for production multi-agent workflows because it simplifies orchestration.

Always-approved permission requests expose the workflow to prompt injection attacks; production use requires policy-based approval logic that evaluates the requested tool and its parameters before granting permission.

Teams expect that a newly committed `.agent.md` file at the repository level is also automatically available across the entire organization or enterprise.

Repository-scoped agents are defined in `.github/agents` and are available only within that repository; organization- and enterprise-scoped agents must be placed in the root `agents` directory of a `.github-private` repository by an organization or enterprise owner.