Enterprise Copilot Orchestrator

Welcome to the Enterprise Copilot Orchestrator extension! This extension centralizes and packages a collection of custom GitHub Copilot chat participants specifically tailored for the Software Development Life Cycle (SDLC).

By installing this VSIX extension, all custom agent definitions, orchestrators, and prompt strategies are automatically registered into your VS Code workspace without needing to copy raw .agent.md files into your individual repositories.

🤖 Available Agents

This extension registers 35 specific SDLC agents directly into your Copilot Chat. These are mapped dynamically to optimized models (ranging from gpt-4o-mini for fast formatting tasks to gpt-4o for deep architectural analysis).

Key Agents include:

• @eco-pr-review-orchestrator: Coordinates multi-agent PR reviews dynamically.
• @eco-code-refinery: Orchestrates multi-agent pipelines using RAG, MCP tools, and DAG workflows.
• @eco-security-auditor: Performs deep security audits and vulnerability checks on code.
• @eco-architecture-design: Validates system design, C4 models, and architectural patterns.
• @eco-ui-ux-specialist: Reviews frontend code for accessibility (WCAG) and responsive design.
• @eco-database-architect: Optimizes SQL schemas, migrations, and indexing strategies.
• @eco-code-style-enforcer: Strictly enforces project linting rules and naming conventions.
• (See the full list of 35 agents in the Copilot Chat participant list by typing @eco-)

🚀 Getting Started

When you install this extension, VS Code will automatically open an interactive "Getting Started" Walkthrough.

You can access the full interactive documentation at any time by:

1. Opening the Command Palette (Cmd+Shift+P / Ctrl+Shift+P)
2. Running Enterprise Copilot Orchestrator: Open Getting Started Guide

The interactive walkthrough covers:

• Smart Routing and Orchestration
• Exporting Local Agents and creating Custom Proxy Agents
• Syncing with an Enterprise Remote Registry
• Configuring Model Overrides and Text Aliases

🔌 Model Context Protocol (MCP) Support

This extension supports the Model Context Protocol (MCP), enabling your agents to dynamically call external tools running locally or registered through an enterprise registry.

⚙️ Configuring MCP Servers

You can configure local MCP servers in your user or workspace settings (settings.json):

{
  "eco.mcpServers": {
    "sqlite-helper": {
      "command": "node",
      "args": ["/path/to/sqlite/index.js", "/path/to/db.sqlite"]
    },
    "github-tools": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "your-token-here"
      }
    }
  }
}

🏢 Enterprise Registry-Synced MCP Servers (Enterprise Only)

If you have a valid Enterprise License (eco.enterpriseLicenseKey), you can also load MCP configurations synced from your remote git registry (registry/mcp-servers.json). These remote-configured servers will be started automatically, giving your agents secure access to internal APIs and databases.

🔄 Automatic Workspace MCP Discovery (.vscode/mcp.json)

If you already have MCP servers configured for GitHub Copilot in your workspace (under .vscode/mcp.json), the Enterprise Copilot Orchestrator will automatically discover, start, and integrate those servers dynamically on startup. You do not need to duplicate these settings in eco.mcpServers.

🛠️ Using MCP Tools in Agents

To expose MCP tools to an agent, declare them in the agent's frontmatter section:

---
name: "Database Auditor"
tools: [sqlite-helper__query_db, sqlite-helper__schema_info, run-local]
---

Tools can be specified as:

• Namespaced (serverName__toolName): Target a specific MCP server (recommended).

📤 Exporting MCP Configuration to VS Code Copilot

VS Code Copilot natively supports MCP servers configured in .vscode/mcp.json. You can easily export and merge your eco.mcpServers settings into .vscode/mcp.json using the built-in command:

1. Open the Command Palette (Cmd+Shift+P on macOS or Ctrl+Shift+P on Windows/Linux).
2. Run Enterprise Copilot Orchestrator: Export MCP Configuration to Copilot (or command eco.exportMcpToCopilot).
3. The extension will automatically create or merge your current settings into .vscode/mcp.json, allowing Copilot to natively discover and call these tools.

🔍 Retrieval-Augmented Generation (RAG) Support

This extension features a lightweight, zero-dependency BM25-based semantic retrieval engine (RAG) that allows agents to automatically retrieve relevant context snippets from the codebase instead of loading entire files or relying solely on pre-compiled system prompts.

⚙️ Enabling RAG in Custom Agents

To enable codebase context retrieval for an agent, simply declare rag: true in the agent's frontmatter section:

---
name: "Clean Code Reviewer"
rag: true
---
You are a clean code reviewer...

When an agent with RAG enabled is invoked, the extension:

1. Performs a token-level sliding window scan of the active workspace (partitioning files into chunks of 40 lines with a 10-line overlap).
2. Computes the BM25 statistical relevance scores for all chunks matching terms in the user prompt.
3. Injects the top 5 highest-scoring relevant code blocks directly into the agent's query prompt.

🏢 Enterprise Registry-Synced RAG (Enterprise Only)

By default, RAG indexes files in local workspace folders. If a valid Enterprise License (eco.enterpriseLicenseKey) is configured, RAG also indexes registry-synced assets under the remote git registry folder (globalStorageUri/registry). This allows agents to retrieve shared company standards, playbooks, guidelines, and schemas seamlessly.

⛓️ Structured Output & Multi-Agent DAG Workflows

The extension includes a Directed Acyclic Graph (DAG) workflow execution engine. This allows custom agents to coordinate complex, multi-agent operations sequentially or conditionally (e.g., Code Gen $\rightarrow$ Test Gen $\rightarrow$ Code Review $\rightarrow$ Auto-Fix) based on structured JSON decisions from preceding agents.

⚙️ Configuring Workflows in Frontmatter

To define a workflow, add a workflow block inside your custom agent's frontmatter section (in JSON format):

---
name: "Audit and Fix Pipeline"
workflow: {
  "startNode": "security-audit",
  "maxIterations": 10,
  "nodes": [
    {
      "id": "security-audit",
      "agent": "security-auditor",
      "promptTemplate": "Analyze the following code for vulnerabilities: {{userPrompt}}",
      "router": {
        "decisionField": "hasVulnerabilities",
        "routes": {
          "true": "auto-fix",
          "false": "done"
        },
        "defaultRoute": "done"
      }
    },
    {
      "id": "auto-fix",
      "agent": "developer",
      "promptTemplate": "Suggest fixes for the vulnerabilities found in this report: {{security-audit.output}}",
      "router": {
        "decisionField": "dummy",
        "routes": {},
        "defaultRoute": "done"
      }
    }
  ]
}
---
Welcome to the Audit and Fix pipeline...

🧬 Workflow Features

• Template Interpolation: Node prompts can dynamically reference the user's initial input via {{userPrompt}} or output from previous nodes via {{nodeId.output}}.
• Structured Routing: By declaring a router configuration, the engine extracts JSON decisions from the agent output and maps specific values to the next execution node.
• Resilient Parsing: The execution engine extracts JSON payloads even if the LLM wraps them in markdown-fenced blocks (e.g., ```json ... ```) or conversational conversational prose.
• Loop Protection: You can restrict max execution steps via the optional maxIterations property (defaults to 10) to guard against infinite loops.

🏢 Licensing Strategy

• Local Workflows (Free): Any workflow configured within a local custom agent (located under .github/agents/ in your workspace) or standard built-in agent can execute free of charge.
• Registry Workflows (Enterprise): Loading and executing workflows synced from your remote git registry (located under the global storage registry folder) is gated behind a verified Enterprise License (eco.enterpriseLicenseKey).

Available Agents