Copilot Agentic Workflows CLI: Building a Controlled Multi-Agent Delivery System

This project transforms GitHub Copilot CLI into a controlled multi-agent delivery system, enabling more efficient AI-assisted software development through clearly defined agent roles, skills, and workflows.

As the capabilities of AI programming assistants continue to grow, developers are gradually realizing the limits of a single AI agent. While tools like GitHub Copilot excel at code completion and simple tasks, more refined division of labor and collaboration mechanisms are often needed when dealing with complex software development tasks. ABIvan-Tech's copilot-agentic-workflows-cli project is designed to address this issue—it transforms GitHub Copilot CLI into a controlled multi-agent delivery system, enabling more efficient AI-assisted software development through clearly defined agent roles and workflows.

The design philosophy of this project is to build a control plane around Copilot CLI's existing capabilities rather than reinventing the wheel. It fully leverages Copilot CLI's native features:

• Custom Agents: Define dedicated agents for specific phases and tasks
• Built-in Agents: Leverage Copilot CLI's provided general-purpose discovery, command execution, research, and review agents
• Skill System: Extend agent capabilities through domain-specialized skills
• Hook Mechanism: Use deterministic guardrails to ensure workflows comply with policies

This design not only retains Copilot CLI's ease of use but also adds enterprise-level governance and control capabilities.

The project defines a clear system of agent roles, with each agent responsible for a specific scope of duties:

Orchestrator: As the main entry point of the system, it is responsible for routing and phase control. It is the first point of contact for user interaction and decides which agent the work should be routed to.

Planner: Responsible for transforming vague requirements into clear execution plans. It handles uncertainty, plans task paths, and sets readiness checkpoints.

Implementer: Focuses on file changes and execution-ready delivery work. It is the main agent that actually writes code.

Debugger: Specializes in reproducible bug diagnosis and minimal fixes. Unlike the Implementer, it focuses on problem localization and fix verification.

Verifier: Independently performs acceptance verification to ensure deliverables meet expectations. It provides objective quality checks and avoids the bias of self-verification by the Implementer.

Memory Curator: Responsible for updating the persistent project memory after work is completed. It ensures that valuable knowledge is accumulated for use in future tasks.

The project intentionally reuses Copilot CLI's built-in agents instead of recreating agents with similar functions:

• explore: For read-only reconnaissance to understand codebase structure
• task: For command-intensive execution, such as building, testing, etc.
• research: For external research to obtain technical documents and best practices
• code-review: For targeted code reviews
• general-purpose: As a fallback option for general experts

This reuse strategy reduces maintenance burden while ensuring compatibility with Copilot CLI.

The project introduces three planning tracks, with the appropriate path selected based on task complexity:

Quick Change: Suitable for simple, clear changes; can directly enter the implementation phase.

Feature Track: Suitable for medium-complexity feature development; requires planning but no system-level refactoring.

System Track: Suitable for major changes affecting system architecture; requires comprehensive design and verification.

Every non-trivial plan must end with "Implementation Ready: Pass or Block" to ensure all prerequisites are met before entering the execution phase.

Execution itself does not automatically close the work loop. Non-trivial work should flow through the Verifier, then to the Memory Curator when the results generate persistent knowledge. This closed-loop design ensures:

1. Quality Control: Independent verification steps prevent the inflow of low-quality code
2. Knowledge Accumulation: Valuable experiences are recorded to form organizational memory
3. Traceability: Each work item has a complete processing record

The project defines a clear set of routing rules to guide users on how to interact with the system:

• Start with the Orchestrator unless explicitly only a planning session is needed
• When scope, behavior, or verification is unclear, let the Planner resolve ambiguity before coding
• Use the Implementer for general delivery work; only use the Debugger for reproducible bugs
• Completed work is routed through the Verifier
• Persist lasting lessons through the Memory Curator instead of random recording