Microsoft Conductor: Deterministic Multi-Agent Orchestration in YAML

Every multi-agent system eventually confronts the same question: who decides what runs next?

In LLM-driven orchestration frameworks like LangGraph, CrewAI, or Microsoft Agent Framework, the answer is "the model." An LLM reads the current state, decides the next action, and routes to the appropriate agent. This works beautifully when you need dynamic, context-dependent routing. It fails spectacularly when you need predictability, cost control, and reproducibility.

Microsoft released Conductor on May 14, 2026 as an open-source CLI (MIT license) that takes the opposite approach: define your multi-agent workflows in YAML with deterministic routing — zero tokens spent on orchestration decisions.

For teams building production agent systems, Conductor forces a fundamental architectural question: when should you let the LLM decide, and when should the routing be baked in?

The Case Against LLM-Driven Orchestration

LLM-driven routing has three problems that compound at scale:

1. Non-Determinism

Run the same workflow twice with the same input, and the LLM might route to different agents. In development, this is annoying. In production, it's unacceptable. Your compliance officer doesn't want to hear that the system "might" route to the right agent.

2. Cost

Every routing decision is an LLM call. In a 10-step workflow, you're spending 10 tokens (plus context) just on orchestration. For a pipeline that runs thousands of times daily, this adds up. The orchestration cost can exceed the actual agent work.

3. Latency

Each LLM routing decision adds 200-500ms of latency. In a sequential workflow with 5 steps, that's 1-2.5 seconds of pure orchestration overhead — before any agent has done useful work.

How Conductor Works

Conductor defines workflows as YAML files with two core sections: a workflow header and a list of agents.

Agents

Each agent is a unit of work — an LLM prompt, a script step, or a human gate:

workflow:
  name: content-pipeline
  entry_point: researcher

agents:
  - name: researcher
    prompt: |
      Research the topic: {{ workflow.input.topic }}
    output:
      findings:
        type: string
    routes:
      - to: writer

  - name: writer
    prompt: |
      Write an article based on: {{ researcher.output.findings }}
    output:
      draft:
        type: string
    routes:
      - to: $end

Routing

Deterministic routing based on conditions, defined on each agent's routes list. Jinja2 expressions evaluate at runtime — no LLM involved:

agents:
  - name: reviewer
    prompt: "Review this draft: {{ writer.output.draft }}"
    output:
      quality_score:
        type: number
    routes:
      - to: writer
        when: "{{ reviewer.output.quality_score < 7 }}"
      - to: $end
        when: "{{ reviewer.output.quality_score >= 7 }}"

First matching condition wins. The writer agent re-runs until quality passes the threshold — a built-in loop without any special loop syntax.

Script Steps

Run shell commands and route on exit code or parsed JSON stdout:

  - name: lint
    type: script
    command: "python lint.py {{ writer.output.draft }}"
    routes:
      - to: writer
        when: "{{ lint.exit_code != 0 }}"
      - to: $end

Integration

The YAML file IS the workflow. Run it with:

conductor run workflow.yaml --input topic="Azure Kubernetes Service"

The CLI handles execution, state passing between agents, and output collection.

When Deterministic Beats LLM-Driven

Content Pipeline Workflows

This is the exact pattern we use for the wenfeng.my content pipeline: Research → Strategy → Writing → SEO Review → Social Content → Publishing. The routing is fixed. The agents change based on the step. LLM-driven routing adds cost and latency without value.

Conductor handles this cleanly: each agent is an LLM call with a specific prompt and model, the routing between agents is deterministic, and the only "intelligence" is in the agent content, not the orchestration.

Data Processing Pipelines

ETL workflows where the sequence is known: Extract → Validate → Transform → Load → Verify. The data might vary, but the routing doesn't. Using an LLM to decide "should I transform next or load next?" wastes tokens on a decision that's always the same.

CI/CD Agent Workflows

Build → Test → Security Scan → Deploy → Verify. Again, fixed routing. The LLM adds value in the security scan (analyzing code) but not in deciding whether to test after building.

Compliance-Governed Workflows

When regulators need to see exactly how decisions are made, deterministic routing provides an auditable, reproducible flow. LLM routing decisions are probabilistic and difficult to explain in compliance documentation.

When LLM-Driven Routing Wins

Customer Support Triage

A customer sends a message. Should it go to billing support, technical support, or escalation? The routing depends on the message content, customer history, and context. This is genuinely dynamic and benefits from LLM judgment.

Incident Response

An alert fires. Is this a known issue (route to runbook), a new issue (route to investigation), or a security incident (route to SOC)? The routing depends on correlating multiple signals — a good use of LLM reasoning.

Adaptive Research Workflows

A researcher asks a question. The next step depends on what's found: if the answer is clear, summarize; if not, expand the search; if conflicting, compare sources. This branching is inherently dynamic.

Hybrid Architecture: The Real Answer

The most effective production systems use both patterns:

YAML Workflow (Conductor)
    ├── Agent 1: Deterministic routing
    ├── Agent 2: Deterministic routing
    ├── Agent 3: Dynamic routing (LLM decides next action)
    │   ├── Branch A: Deterministic
    │   └── Branch B: Deterministic
    └── Agent 4: Deterministic routing

Use Conductor for the fixed structure. Use LLM routing within specific agents where genuine decision-making is needed. This gives you the cost and latency benefits of deterministic orchestration with the intelligence of LLM routing where it matters.

Getting Started with Conductor

Installation is straightforward — Conductor is a Python CLI tool (Python 3.12+) installed via a one-line script:

curl -sSfL https://aka.ms/conductor/install.sh | sh
conductor run --help

Alternatively, install directly with uv:

uv tool install git+https://github.com/microsoft/conductor.git

The YAML syntax is deliberately simple. If you've written GitHub Actions workflows, Docker Compose files, or Ansible playbooks, Conductor YAML will feel familiar. The key difference: Conductor YAML is executable. It's not documentation that someone needs to translate into code — it IS the code.

For teams already running multi-agent pipelines (like the content pipeline architecture many organizations use), Conductor provides a migration path from custom orchestration scripts to a standardized, version-controlled workflow definition. The YAML file lives in your repository, gets reviewed in PRs, and runs identically in dev and production.

Key Takeaways

  1. Not every routing decision needs an LLM — deterministic YAML workflows eliminate orchestration cost, latency, and non-determinism for pipelines with fixed structure.
  1. Conductor is a CLI tool, not a framework — define workflows in YAML, run them with conductor run, and the tool handles execution. Minimal dependencies, no heavyweight runtime.
  1. Hybrid orchestration is the production pattern — use deterministic routing for fixed workflow structure, LLM routing only where genuine dynamic decision-making adds value.
  1. Cost reduction is significant — eliminating LLM routing calls per workflow execution saves substantial orchestration tokens in fixed-structure pipelines.
  1. Compliance and reproducibility improve — deterministic routing produces identical execution paths for identical inputs, which is what auditors want to see.