PACE Agent Wrapper POC

This POC demonstrates a VS Code wrapper for dynamically chained PACE agents with local telemetry.

It is designed for a GitHub Pro / VS Code / Copilot Chat style workflow where GitHub enterprise Copilot metrics may not be available. The wrapper therefore owns the execution record and writes local telemetry.

What this POC shows

The chain is no longer hardcoded as Agent 1 → Agent 2 → Agent 3. Instead, each agent run writes a structured completion manifest:

product-specs/{request-id}/.pace/agent-completion.json

The wrapper reads the manifest and decides the next agent.

Example dynamic chain:

REQ-01 → TDD-01 → DEV-01 → DEV-02 → DEV-02 → DEV-02 → DONE

DEV-02 can loop until work is complete, or until the max-iteration guard sends the chain to HUMAN_REVIEW.

Agents included

Files created in your test repo

When you run the wrapper in a target repo, it creates:

.pace/
  current-session.json
  sessions/{request-id}.json
  telemetry/events.ndjson

product-specs/
  index.md
  {request-id}/
    req01_spec.md
    tdd01_test_plan.md
    dev01_build_plan.md
    dev02_iteration_1.md
    dev02_iteration_2.md
    dev02_iteration_3.md
    .pace/agent-completion.json

How to load the POC in VS Code

1. Unzip this project.
2. Open the unzipped folder in VS Code.
3. Press F5.
4. VS Code opens a second window called Extension Development Host.
5. In that second window, open a test repository.
6. Open the Command Palette with:

Ctrl + Shift + P

On Mac:

Cmd + Shift + P

Main commands

Search for PACE Wrapper in the Command Palette.

Recommended demo path

Option A: step-by-step chain

1. Run:

PACE Wrapper: Start REQ-01

2. Enter product and task.
3. When complete, run:

PACE Wrapper: Start Next Agent

4. Repeat until the next agent is DONE.

Option B: full automated chain

Run:

PACE Wrapper: Run Dynamic Agent Chain

This automatically runs:

REQ-01 → TDD-01 → DEV-01 → DEV-02 → DEV-02 → DEV-02 → DONE

DEV-02 simulates 3 iterations. Iteration 1 and 2 loop; iteration 3 returns DONE.

Optional Copilot Chat entry point

The extension also contributes a simple @pace chat participant, if your VS Code build supports the Chat Participant API.

Example:

@pace /req01 product=demo-product task="Build a dynamic agent-chain telemetry POC"

Then:

@pace /next

Or run the whole chain:

@pace /chain product=demo-product task="Build a dynamic agent-chain telemetry POC"

Completion manifest example

Each agent writes:

{
  "schema_version": "pace.agent-completion.v0.2",
  "request_id": "demo-product-build-a-dynamic-001",
  "execution_id": "uuid",
  "agent_id": "dev02",
  "agent_version": "0.2.0",
  "status": "completed",
  "iteration": 2,
  "outputs": [
    "product-specs/demo-product-build-a-dynamic-001/dev02_iteration_2.md"
  ],
  "outcome": {
    "tests_passed": false,
    "open_work_items": 1
  },
  "next": {
    "agent_id": "dev02",
    "reason": "1 simulated work item remains; continue DEV-02 iteration.",
    "input_files": [
      "product-specs/demo-product-build-a-dynamic-001/dev01_build_plan.md"
    ]
  },
  "generated_at": "2026-06-11T10:00:00.000Z"
}

The wrapper validates next.agent_id before running the next step.

Telemetry events

Telemetry is appended to:

.pace/telemetry/events.ndjson

Example event types:

agent.chain.started
agent.execution.started
agent.tool_call.completed
agent.completion_manifest.written
agent.execution.completed
agent.chain.completed

Each event includes useful fields such as:

request_id
execution_id
agent_id
stage
iteration
user
github remote / branch / commit
output_file
completion_manifest
estimated_tokens
next_agent
next_reason

Token usage is estimated using character length divided by 4. This is intentional for the POC because GitHub Pro/Copilot Chat does not provide a clean per-agent token-cost API.

Why this pattern matters

For real PACE agents, the recommended contract is:

Agent writes durable output files
Agent writes .pace/agent-completion.json
Wrapper validates next-agent decision
Wrapper records telemetry
Wrapper starts/prepares the next agent

This avoids relying on a single long Copilot Chat session and reduces role bleed/context overload.

GitHub Pro impact

This POC does not depend on GitHub Enterprise Copilot metrics. It uses:

• local workspace context
• Git remote/branch/commit metadata
• local telemetry files
• completion manifests
• optional GitHub API enrichment later

For exact model token/cost telemetry, a future version should move governed agent execution into a PACE-owned backend/model call. For this POC, token usage is a local estimate.