TL;DR:

  • Microsoft Conductor is an open-source CLI that defines multi-agent workflows in YAML with deterministic routing — no LLM orchestrator needed
  • The coordination layer consumes zero tokens, making multi-agent pipelines cheaper and more predictable than dynamic agent-chooses-next-step approaches
  • Supports GitHub Copilot and Anthropic as providers, with MCP tool access per agent and per-agent model overrides

Most multi-agent frameworks solve the “which agent next?” problem by making the orchestrator itself an LLM. An AI decides what to do, selects tools, picks the next agent. It’s flexible, but it is also unpredictable, expensive, and difficult to test. Every orchestration decision burns tokens. Every workflow run can produce different sequences. Debugging becomes archaeology.

Microsoft’s Conductor, released as open source in May 2026, takes a different position: remove the LLM from orchestration entirely. You define the workflow in YAML. The routing is deterministic. The agents do the work; the YAML does the coordination.

What Conductor Does

Conductor is a CLI tool in the Microsoft GitHub org, MIT licensed. You write a workflow file — a YAML document that declares agents, their roles, the sequence of steps, and the conditions that route between them. Jinja2 templates handle dynamic values. Expression evaluation handles branching logic. When the workflow runs, the CLI follows the declared structure exactly.

Each agent in a workflow gets a system prompt, a provider (GitHub Copilot or Anthropic Claude), a model, and optionally a set of MCP servers that give it tool access. A research step might use claude-haiku-4.5 with a web search MCP server. A synthesis step might use claude-opus-4.6. A code review step might call the GitHub Copilot API. All of that is declared in the YAML. No agent decides to call another agent; the YAML determines what runs next.

Shell commands are first-class workflow steps. Your test suite, linters, build tools, and scripts participate in the workflow without modification. A workflow can run an agent, pipe its output to a shell command, evaluate the result, branch to a different agent based on the exit code, and continue. This is exactly how CI/CD pipelines work, which is intentional.

Why Deterministic Orchestration Matters

The case for dynamic, LLM-driven orchestration is flexibility: an autonomous agent can reason about what to do next, adapt to unexpected inputs, and handle edge cases that rigid workflows cannot anticipate. This is valuable when the problem space is genuinely open-ended — when you do not know in advance what steps will be needed.

Most enterprise workflows are not like that. A code review pipeline always runs analysis, then suggests changes, then generates a summary. A research-and-report flow always retrieves documents, then summarises, then formats. A customer triage flow always classifies, then routes, then generates a response. These workflows have known structure. Making an LLM re-derive that structure on every run adds cost, latency, and variability without adding capability.

Conductor’s position is that deterministic workflows should be deterministic. The YAML file is the workflow. It can be version-controlled, reviewed in pull requests, diffed between environments, and validated without running a model. You can read a Conductor workflow file and understand exactly what it will do, which is not something you can say about most agentic systems.

A Practical Example: Code Review Pipeline

A Conductor workflow for automated code review might look roughly like this:

name: code-review
steps:
  - name: fetch-diff
    type: shell
    command: "git diff origin/main"
    output: diff

  - name: analysis
    type: agent
    provider: anthropic
    model: claude-haiku-4-5
    system: "You are a code reviewer. Analyse the diff for bugs, security issues, and style violations."
    input: "{{ diff }}"
    output: analysis

  - name: summary
    type: agent
    provider: anthropic
    model: claude-opus-4-7
    system: "You write clear, developer-friendly code review summaries."
    input: "Analysis: {{ analysis }}"
    output: review_comment

The workflow fetches the diff with a shell command, runs a fast cheap model for analysis, then uses a more capable model for the final summary. No orchestrator LLM decides these steps. The YAML declares them. Running the same workflow twice on the same diff produces structurally identical behaviour.

MCP Integration

Each agent step can attach MCP servers to extend its capabilities beyond text generation. Web search MCP gives a research agent real-time retrieval. A documentation MCP gives an implementation agent access to API references. A code analysis MCP gives a review agent the ability to run static analysis tools.

Because MCP servers are declared per-step in the YAML, you can give different agents in the same workflow different tool access without any runtime decision-making. The analysis agent gets read-only tools. The implementation agent gets write access to the codebase. The constraints are structural, not enforced by prompting.

Who Should Use It

Conductor fits teams who want multi-agent workflows that behave like software engineering artefacts: version-controlled, testable, reviewable, and reproducible. If your workflow has a known structure that you want to codify and maintain, YAML-first orchestration is a better fit than dynamic LLM-driven planning.

It is not the right tool for genuinely open-ended agentic tasks where the steps themselves are unknown in advance — exploratory research, autonomous debugging, or tasks that require the agent to decide its own scope. For those, LangGraph, CrewAI, or similar frameworks with dynamic routing remain the more appropriate choice.

Conductor is available at github.com/microsoft/conductor under the MIT license. The README includes worked examples for code review, research synthesis, and plan-then-implement flows.

References