Conductor (microsoft) — Summary

Microsoft's Conductor is a production-grade Python CLI tool (conductor run workflow.yaml) for defining and executing multi-agent workflows using YAML configuration files against GitHub Copilot SDK and Anthropic Claude APIs. It is architecturally unrelated to the CDD-methodology "conductor" variants in this batch: it is a workflow orchestration engine where agents, routing logic, and tool configurations are described in YAML, executed deterministically via Jinja2 expression evaluation (no LLM in the routing loop), and monitored through a real-time web dashboard. Key features include parallel execution (static groups and dynamic for-each fan-out), sub-workflow composition, script steps with exit-code routing, human-in-the-loop gates in-browser, and reasoning.effort configuration translated to each provider's native API. At v0.1.17, with 156 stars, 15 contributors, and an MIT license, it is maintained by a Microsoft team (Melty Labs adjacent) and ships as both a standalone CLI tool and a dual-purpose Claude Code / GitHub Copilot CLI skill that teaches the YAML schema. Compared to the CDD conductor variants, this is closest to the "MCP-anchored toolserver" archetype but implemented as a Python runtime rather than an MCP server — the defining difference from all other conductors in this batch.

Conductor (microsoft) — Overview

Origin

• Author: Microsoft (Conductor Team)
• Repo: https://github.com/microsoft/conductor
• Version: 0.1.17 (pyproject.toml)
• License: MIT
• Stars: 156 | Forks: 21 | Contributors: 15 | Last commit: 2026-05-21
• Install binary: conductor (PyPI package: conductor-cli)

Philosophy

From the README:

"Conductor makes multi-agent workflows — code review pipelines, research-then-synthesize flows, plan-then-implement loops — repeatable, deterministic, and version-controlled."

Three core principles:

1. Repeatable — Same inputs follow the same path through the same agents.
2. Deterministic — Routing uses Jinja2 templates and expression evaluation. First matching condition wins. No LLM in the orchestration loop, no tokens spent deciding what runs next.
3. Source-controlled — Plain YAML files. Diff workflows in pull requests, version them with code, run identically locally and in CI.

This is a deliberate design reaction against "LLM-decides-routing" approaches — Conductor's orchestration logic is purely deterministic (Jinja2 expressions), making it suitable for production CI pipelines.

Use cases (from examples directory)

• Code review pipelines (implement.yaml)
• Parallel research workflows (parallel-research.yaml)
• Plan-then-implement loops (plan.yaml, implement.yaml)
• Design-code-validate cycles (design.yaml)
• Multi-provider routing (multi-provider-research.yaml)
• Dialog mode for uncertainty handling (dialog-mode.yaml)
• Script steps with exit-code routing (script-step.yaml)

Dual-purpose: CLI + Claude Code / Copilot skill

The repo also ships a skill for Claude Code and Copilot CLI that teaches the agent the YAML schema and CLI commands — so the tool can be used both standalone and as an AI-assisted workflow builder.

Conductor (microsoft) — Architecture

Distribution

• Type: Python CLI tool (+ optional Claude Code / Copilot CLI skill)
• Install methods:

  # Quick install (recommended):
  curl -sSfL https://aka.ms/conductor/install.sh | sh      # macOS/Linux
  irm https://aka.ms/conductor/install.ps1 | iex           # Windows
  
  # pip/uv:
  uv tool install git+https://github.com/microsoft/conductor.git
  pip install git+https://github.com/microsoft/conductor.git
  

• CLI binary: conductor
• Required runtime: Python >= 3.12
• Package name: conductor-cli v0.1.17

Key dependencies

• typer — CLI framework
• rich — terminal output formatting
• pydantic — workflow schema validation
• ruamel.yaml — YAML parsing
• jinja2 + simpleeval — expression evaluation for routing
• anthropic>=0.77.0 — Anthropic SDK
• github-copilot-sdk>=0.3.0 — GitHub Copilot SDK
• fastapi + uvicorn + websockets — web dashboard
• mcp>=1.0.0 — MCP tool support

Source directory structure

src/conductor/
├── cli/
│   ├── app.py          # Typer app + subcommand registration
│   ├── run.py          # `conductor run` command
│   ├── validate.py     # `conductor validate` command
│   ├── update.py       # `conductor update` command
│   ├── bg_runner.py    # Background mode runner
│   ├── pid.py          # PID management for bg mode
│   └── registry.py     # Registry subcommand group
├── engine/             # Workflow execution engine
├── executor/           # Agent executor (Anthropic + Copilot providers)
├── providers/          # LLM provider adapters
├── config/             # YAML schema definitions (Pydantic)
├── gates/              # Human-in-the-loop gates
├── interrupt/          # Ctrl+C / signal handling
├── mcp/                # MCP server integration
├── web/                # FastAPI web dashboard
│   ├── server.py
│   ├── frontend/       # React/JS dashboard UI
│   └── replay.py       # Replay capability
└── registry/           # Workflow registry

Workflow YAML schema

workflow:
  name: <string>
  entry_point: <agent-name>
  runtime:
    provider: copilot | anthropic
    default_model: <model-name>
    mcp_servers:
      <name>: {command, args, tools}
  input:
    <key>: {type, required, default, description}
  limits:
    max_iterations: <int>
    timeout_seconds: <int>

parallel:
  - name: <group-name>
    agents: [<list>]
    failure_mode: halt_on_error | continue_on_error
    routes:
      - to: <agent>

agents:
  - name: <string>
    model: <model-name>
    prompt: <jinja2-template>
    system_prompt: <string>
    output:
      <key>: {type: string|json|bool}
    routes:
      - condition: <jinja2-expr>
        to: <agent-name>
      - to: $end

Target AI tools

• Primary: conductor CLI (standalone)
• Secondary: Claude Code + GitHub Copilot CLI (skill that teaches YAML schema)
• LLM providers: GitHub Copilot SDK, Anthropic Claude

Conductor (microsoft) — Components

CLI subcommands

Workflow primitives (YAML)

Web dashboard

Real-time FastAPI+WebSocket dashboard (--web flag):

• Interactive DAG graph (zoomable, draggable)
• Live agent streaming (reasoning, tool calls, outputs)
• Three-pane layout: graph / agent detail / tabbed output
• In-browser human gates (no terminal needed)
• Per-node detail: prompt, metadata (model, tokens, cost), activity stream, output
• Background mode: --web-bg + conductor stop

Example workflows (16 in examples/)

Skill (for Claude Code / Copilot)

plugins/conductor/skills/conductor/ — markdown skill teaching the YAML schema and CLI usage. Ships only markdown, no executables.

Conductor (microsoft) — Uniqueness

differs_from_seeds

Microsoft's Conductor is architecturally distinct from all seeds and all other conductors in this batch. The closest seed is claude-flow (MCP-anchored toolserver with multi-agent orchestration), but microsoft/conductor is not MCP-based and not a Claude Code plugin — it is a standalone Python CLI with its own execution runtime. The deterministic-routing principle (Jinja2 expressions, no LLM in the orchestration loop) directly contrasts with claude-flow's consensus protocols and superpowers' Iron Law skill activation. It shares the "multi-agent, parallel execution" dimension with claude-flow but implements it via declarative YAML rather than SQLite-backed skill queues. Among seeds, it is most novel: none of the 11 seeds ship a standalone CLI with a built-in web dashboard, per-agent model assignment, and parallel group orchestration — those dimensions are simply absent from the seed corpus.

What makes this conductor unique

1. Deterministic YAML-driven routing — Jinja2 expressions route agents; zero LLM tokens spent on orchestration decisions
2. Multi-model per workflow — YAML assigns different LLM models to different agents in the same workflow file
3. Built-in real-time web dashboard — FastAPI + WebSocket DAG visualization with live streaming; no other conductor variant has a local UI
4. For-each dynamic fan-out — execute one agent N times over a list, accumulating results
5. Sub-workflow composition — reusable nested workflows with input_mapping
6. Dual provider support — GitHub Copilot SDK and Anthropic in the same tool, with reasoning.effort unified across both
7. --web-bg background mode — run a workflow headlessly, stop it with conductor stop
8. Microsoft backing — institutional maintainer with SHA-256 install verification and Microsoft install CDN

Observable failure modes

1. No checkpointing: workflow failure means restart from scratch; long workflows (implement.yaml has 100 max_iterations) can lose significant progress
2. YAML complexity ceiling: the implement.yaml example with 6 agents, multi-provider MCP servers, and for-each is already complex to read/debug
3. Python >=3.12 requirement: excludes users on older systems
4. No isolation: all agents write to the same working directory; parallel agents could create conflicts

Positioning

This is the only "workflow engine" in the batch — the others are development methodology plugins. microsoft/conductor competes with LangGraph, CrewAI, and Temporal for the deterministic AI workflow orchestration niche, not with Claude Code plugin frameworks.