This is a great question. That's the reason why the new coordinator-subagent pattern was made in the first place.

I'll just give my own two cents; you could try building a hierarchical team using the .agent.md format:

• Create a primary agent (e.g., architect.agent.md) and use the agents YAML to define its "subordinates." This way, you're only talking to the architect, and it delegates tasks to the "researcher" or "coder" agents automatically.
• Use MCP Servers if your skills need to interact with external data, (though this is basic knowledge.)
• With the recent VS Code updates, you can now prompt your lead agent to "parallelize" tasks. This is a game-changer for speed—one subagent handles the logic while another simultaneously writes the unit tests.
• A great practice is keeping an AGENTS.md file in your root directory. Most modern agents are trained to look for this to understand project-wide patterns, which keeps everyone on the same page
• Since agent context is ephemeral per session, force an agent to maintain a .github/ai-state.json or MEMORY.md. Have it write atomic updates on architectural decisions after every task (or much better to have it write after every session). Subsequent agents can use this to maintain consistency on your projects across long time periods of development.
• Use the handoffs frontmatter to create a logic gate and define your specialist agents (Security, Style, Documentation) with user-invocable: false in their .agent.md.

I’d highly recommend checking out the Chat Customizations editor to manage the handoffs between these agents visually!

Hope this helps! :)

Hi @florencia-oviedo👋

Thanks for raising this excellent question! Orchestrating multiple agents/skills in GitHub Copilot Chat (VS Code) can quickly become messy if you rely on scattered prompts or isolated tools. The goal is to create a clean, scalable system where agents collaborate efficiently — like a well-organized development team.

Here are battle-tested best practices that many teams are adopting in 2026:

1. Adopt the Coordinator-Subagent (Hierarchical) Pattern

This is the most recommended architecture for complex workflows:

• Create a lead agent (e.g., architect.agent.md or coordinator.agent.md) in your project root.
• Define specialized sub-agents for focused roles:
  • Researcher
  • Coder
  • Tester
  • Reviewer
  • Documenter

The lead agent automatically delegates tasks, reviews outputs, and ensures consistency.

How to implement it:

• Use the .agent.md file format for each agent.
• In the lead agent's file, define handoffs and delegation rules.
• Enable parallelization by prompting the coordinator:
  "Break this task into subtasks and assign them to the appropriate sub-agents in parallel where possible (e.g., one handles logic, another writes tests)."

2. Project-Wide Context Files (Essential for Consistency)

Keep these files in your repository root:

• AGENTS.md — Documents all agents, their responsibilities, and interaction rules. Modern Copilot agents automatically discover and respect this.
• MEMORY.md or .github/ai-state.json — Stores persistent architectural decisions, past learnings, and project conventions. Agents reference and update this across sessions.
• Use handoff frontmatter in .agent.md files to create logic gates (e.g., route security-related tasks to a specialist with user-invocable: false).

3. Leverage Built-in VS Code Tools

• Open the Chat Customizations editor (available in recent Copilot updates) — it provides a visual interface to manage agents, handoffs, and workflows without editing files manually.
• For external data or tools, integrate MCP Servers (Model Context Protocol) to give agents safe access to APIs or databases.

4. Pro Tips for Smooth Orchestration

• Start simple: Begin with 2–3 sub-agents and expand as needed.
• After each major session, instruct the lead agent to write an atomic summary/update to MEMORY.md.
• Test handoffs frequently — ask the coordinator to explain its delegation decisions.
• For large projects, combine this with Copilot's Agents tab in the repository for tracking sessions visually.

This approach turns chaotic multi-agent chats into a structured, repeatable system that scales with your project.

If you're just getting started, I recommend checking the official Copilot documentation on custom agents and the .agent.md specification. The single existing comment also touches on similar ideas — combining both should give you a very robust setup.

Would this work for your use case? Feel free to share more details about your workflow (e.g., what kinds of tasks you're orchestrating), and I can help refine the .agent.md examples further!