Agent Pipeline — Multi-Agent Workflow

A VS Code extension that bootstraps a custom multi-agent development workflow (BA → Architect → Developer → Lead → QA, plus on-demand domain-expert and story-analyzer) in any project. It uses GitHub Copilot to analyze your codebase and fill agent-config.json, then visualizes per-ticket pipeline progress in a live webview.

What it does

1. Bootstrap (Initialize Project) — Inspects your repo (frameworks, source layout, tests, lint, git), then asks Copilot to:
   • Fill in agent-config.json with project metadata, tech stack, layered architecture, hard rules.
   • Suggest skill references (*.SKILL.md) for the frameworks it detected.
   • Suggest domain-knowledge files (loaded on demand by domain-expert).
   • Generates starter content for each knowledge and skill file so the agents have something concrete to read from day one.
2. Install agent definitions — Copies the 7 agent definitions into .github/agents/ (Copilot custom agents) and .claude/agents/ (Claude Code subagents) so both runtimes can drive the same pipeline.
3. Run the pipeline — From the webview, create a ticket (or fetch it from JIRA) and click Start Pipeline. The extension composes the kickoff prompt and sends it to Copilot Chat (or a Claude Code terminal).
4. Show live progress — Watches each <ticket-id>/pipeline-state.md file. The pipeline stepper turns green stage-by-stage as the agents complete their work.

Commands

What gets created on Initialize

<workspace>/
├── .github/
│   ├── agents/
│   │   ├── agent-config.json          ← single source of truth
│   │   ├── agent-config.schema.json   ← JSON Schema
│   │   ├── agent-config.md            ← human-readable pointer
│   │   ├── pipeline-state.template.md ← per-ticket state schema
│   │   ├── frontend-ba.agent.md       ← Copilot custom agents
│   │   ├── frontend-architect.agent.md
│   │   ├── frontend-developer.agent.md
│   │   ├── frontend-lead.agent.md
│   │   ├── qa-engineer.agent.md
│   │   ├── domain-expert.agent.md
│   │   ├── story-analyzer.agent.md
│   │   └── knowledge/                 ← domain knowledge files (LM-seeded)
│   │       ├── <topic-1>.md
│   │       └── …
│   └── skills/                        ← skill references (LM-seeded)
│       ├── <framework>/SKILL.md
│       └── …
└── .claude/
    └── agents/                        ← Claude Code subagents (same pipeline)
        ├── frontend-ba.md
        ├── frontend-architect.md
        └── …

Nothing existing is overwritten. The init step is idempotent — re-running offers to overwrite only the agent-config.json itself.

The Pipeline

5 sequential stages, each backed by an agent that reads agent-config.json and writes its output into the per-ticket folder.

Supporting agents (off the critical path):

• domain-expert — Loaded on demand by BA / Architect for domain concepts the code can't answer alone.
• story-analyzer — Pre-pipeline. Pulls JIRA ticket + linked context, generates clarifying questions for stakeholders.

Every ticket maintains a <ticket-id>/pipeline-state.md for resumability and session isolation. The extension watches this file and re-renders the stepper as the agents update it.

Visual Pipeline Progress

The panel shows:

• Project header — name, ticket count.
• Ticket list — tiles, each showing the active stage as a colored badge.
• Pipeline stepper — 5 circles connected by lines, animated for the active stage:
  • ⚪ pending · 🔵 in_progress (pulsing) · 🟢 done · 🟡 changes_requested · 🔴 halted
• Stage detail table — clickable output filenames open the file alongside.
• Actions — Resume current stage · Open ticket folder · Refresh.

Setup

Install (from VSIX)

cd tools/code-intake
npm install
npx @vscode/vsce package --no-dependencies --allow-missing-repository

In VS Code: Cmd+Shift+P → Extensions: Install from VSIX… → select the generated .vsix → reload.

Development (symlink)

ln -s "$(pwd)/tools/code-intake" ~/.vscode/extensions/code-intake

Settings

All settings are under the codeIntake namespace.

How Initialization Decides

The LM is given:

1. The output of static inspection (package.json, source directories, framework signals, lint config, git HEAD).
2. The agent-config.schema.json it must validate against.
3. The starter template with the portable pipeline sections already filled.

It returns a complete agent-config.json covering:

• project.{name, description, ticketIdPrefixes, defaultBranch}
• techStack (with concrete commands like npm test -- <pattern>)
• architecture.{layers, hardRules} — 2-5 layers with dependency direction, 5-12 hard rules tied to the detected frameworks (e.g. "For React: never use class components for new code", "For AngularJS: never use $rootScope.$broadcast — use a proper event service").
• skills.items — pointers to the skill files the agents may need.
• domainExpert.knowledgeFiles — pointers to the knowledge files the domain-expert can load on demand.

After the JSON is written, the extension uses Copilot once per knowledge file and once per skill to generate starter content — concrete headings, example shapes, and [TODO] markers for the team to fill in.

JIRA integration

Optional. If codeIntake.jira.baseUrl and a token are set, the panel's "Fetch from JIRA" button loads the ticket's summary, description, labels, status, and acceptance criteria into the description field. If you click "Start Pipeline" with an empty description, JIRA is fetched automatically as a fallback.

Atlassian Cloud: set jira.email + jira.apiToken (Basic auth). Jira Server / Data Center: set jira.apiToken only (Bearer token).

For security, prefer:

export JIRA_API_TOKEN="your-token-here"

Requirements

• VS Code 1.90.0 or later
• GitHub Copilot extension (for analysis + agent kickoff via Copilot Chat)
• Claude Code CLI (optional — only if you set codeIntake.agentRunner to claude)
• JIRA access (optional — for ticket fetching)