Microsoft Delivery Copilots

Overview

Microsoft Delivery Copilots is engineering work on Microsoft's AI-powered software delivery platform — helping teams ship at the pace of innovation while keeping delivery grounded in specs, traceable decisions, and production-ready quality.

The public expression of this work is DevSquad Copilot — an open-source delivery framework for GitHub Copilot that treats delivery as a loop, not a pipeline. A conductor agent orchestrates 13 specialized sub-agents, guiding teams from business envisioning through specification, planning, implementation, review, and refinement.

"Ship at the pace of innovation with agents that keep delivery grounded in specs, traceable decisions, and production-ready quality." — DevSquad Copilot

Public resources:

• Documentation
• GitHub Repository
• Agents Catalog

Role & Responsibilities

Senior Frontend Engineer / UI Architect at Microsoft

• Led UI architecture for delivery copilot experiences and agent workflow interfaces
• Built Fluent UI-based dashboards and interaction patterns for multi-agent orchestration
• Designed interfaces for spec review, ADR traceability, task decomposition, and implementation tracking
• Collaborated with AI platform, engineering systems, and GitHub Copilot integration teams
• Ensured accessibility, performance, and consistency across internal delivery tooling

Problem Statement

AI-assisted coding accelerates implementation, but without delivery discipline it creates hidden risks: untraceable decisions, spec drift, missing security review, and context loss across handoffs. Teams need more than code generation — they need an orchestration layer that keeps the why, what, and how aligned from business intent to merged code.

Solution

A conductor-led delivery loop where persistent artifacts — envisioning docs, feature specs, ADRs, plans, and tasks — form shared memory across developers and agents. Specs are sliced thin and revised as teams learn; implementation that reveals new understanding triggers scoped amendments rather than silent deviation.

Four Delivery Layers

The Delivery Loop

1. Envision — Surface the why: business goals and success criteria
2. Specify — Write thin vertical slices, not full-system specs upfront
3. Plan — Produce technical design and ADRs for significant decisions
4. Decompose — Break slices into single-session tasks with acceptance criteria
5. Implement — TDD discipline, impact classification, conventional commits
6. Review — Independent validation against spec, ADRs, and plan
7. Refine — Amend specs when reality shifts; scan backlog health between sprints

Agent Architecture (13 Specialists)

The devsquad conductor delegates to specialist agents by phase using a Mediated Coordinator-Worker pattern:

Coordinator agents (plan, implement, review, refine) delegate to hidden worker sub-agents with isolated context for parallel execution.

Key Features

• Conductor pattern — Single entry point routes to specialists; direct invocation also supported
• Persistent artifacts — Disk-based specs, ADRs, and plans as source of truth (git-auditable)
• Impact-scaled rigor — Low-impact changes move fast; high-impact triggers ADRs and explicit approval
• Spec amendment protocol — Mid-flight updates when implementation reveals model shifts
• TDD embedded — Test-first implementation regardless of language or AI model
• Security by phase — Architectural assessment during design; code scans during implementation
• MCP integrations — GitHub / Azure DevOps, Microsoft Learn, Azure services
• Extensibility — Custom instructions, skills, agents, hooks, and tool extensions

Four Delivery Guardrails

What separates delivery copilots from "describe everything, then let AI code it" tools:

1. Thin vertical slices — Specs written at slice scope and amended when reality shifts
2. ADRs for non-trivial choices — Reviewers and future agents read reasoning, not just code
3. Impact classification — Ceremony matches risk (low / medium / high)
4. Comprehension checkpoints — Optimizes for developer understanding, not just throughput

Tech Stack

• React.js · TypeScript · Fluent UI · Azure OpenAI
• GitHub Copilot · Agent orchestration · MCP servers
• Azure DevOps · GitHub Issues integration
• Component architecture · Design systems · REST APIs

Challenges

• Designing UI that surfaces complex multi-agent workflows without overwhelming developers
• Visualizing artifact chains (envisioning → spec → ADR → task → code) across long-running sessions
• Representing impact classification and approval gates clearly in the interface
• Keeping agent picker and conductor routing intuitive when 13+ specialists are available
• Balancing speed (low-impact fast path) with rigor (high-impact review flows) in a single UX

Learnings

• Delivery copilots succeed when artifacts are first-class — specs and ADRs are not bureaucracy, they are shared memory
• The loop model beats linear pipelines for AI-assisted work because learning mid-implementation is expected, not exceptional
• Context isolation between worker sub-agents prevents assumption contamination across phases
• Extensibility (custom skills, hooks, coding guidelines) is essential — teams won't adopt a framework that fights their stack

Business & User Impact

• Enables Microsoft engineering teams to adopt agentic delivery with production-ready guardrails
• Open-sourced as DevSquad Copilot for broader community use
• Reduces spec drift and untraceable AI-generated changes across multi-developer projects
• Integrates with GitHub Issues and Azure DevOps for real work-item tracking, not markdown-only checklists

Future Improvements

• Richer visualization of agent delegation and parallel worker execution
• Deeper Copilot Studio integration for enterprise-wide agent deployment
• Enhanced sprint and backlog health dashboards via the refine agent
• Expanded MCP connectors for additional Azure and Microsoft 365 services