GitHub Copilot Dynamic Workflows: Multi-Agent Processes as Code

What GitHub shipped

GitHub has added a feature called dynamic workflows to Copilot. It lets developers write a multi-agent process as code instead of having an agent work out the process from scratch in each chat session.1 The capability is available in Copilot CLI, the GitHub Copilot app and the Copilot SDK. It is labeled a public preview, and GitHub warns that its behavior and setup may still change.13 According to one report, the feature was announced on October 1.3

The basic idea is a division of labor. Deterministic code handles the parts of a job that should run the same way every time. Agents are assigned the parts that require analysis or judgment.1 Each workflow sits inside a Copilot extension, which gives it access to Copilot's extensibility APIs.1 GitHub's documentation also says a workflow can require agents to return results in a fixed format so that later steps can consume them. If an agent's output doesn't match that format, Copilot can ask it to fix the output.1

The incident-response example

GitHub's main illustration is a service incident. In that scenario, the workflow:

• gathers logs and telemetry
• sends agents to investigate the evidence
• has those agents cross-check each other's findings and challenge one another's conclusions
• assembles the verified results into a timeline and root-cause analysis
• pauses so an engineer can review the findings before any remediation begins12

The value is that the process is written once and reused, while the agents still have room to reason about the specifics of each new incident.2

Oren Melamed's announcement post describes the problem the feature addresses. Much of the industry conversation has been about multi-agent orchestration, subagents, parallel execution and handoffs between agents. His point is that asking an agent to figure out how to complete a task is different from defining how the task should be done.2 Dynamic workflows put Copilot firmly in the second camp.

How it differs from /fleet

Copilot already has a /fleet command, which delegates work to subagents in parallel and coordinates their responses. GitHub separates that from dynamic workflows, which are processes defined in code.3 In practice, /fleet is ad hoc parallelism. A dynamic workflow is a repeatable procedure that can apply checks consistently, wrap model-generated analysis in deterministic actions, and place a review gate at an exact point in the sequence.3

Getting started

Setup is light:

• Copilot app: no extra configuration is needed.
• Copilot CLI: you enable experimental features with --experimental or /experimental on.2
• Writing the workflow: you don't have to do it by hand. A developer can ask Copilot to create one, for example a workflow named review-changed that lists changed files, has an agent review them, and summarizes the results. Copilot then writes the workflow inside an extension.2
• Scope: by default, a generated workflow applies only to the current session. It can be promoted to a personal or project extension and shared with a team.2
• Running and monitoring: workflows run by name and can be watched through /workflows in the CLI or a Workflows panel in the app. Their definitions can be revised as teams learn from real runs.2

The caveats

Two of the reports emphasize the operational side. Teams adopting the feature will need to manage CLI permissions, AI credit limits and human approval checkpoints.13 That matters because a multi-agent workflow that fans out across several investigating agents can consume credits faster than a single chat. A workflow with broad tool permissions also deserves the same scrutiny as any automation script.

Why it matters

In our reading, dynamic workflows signal a shift in how AI coding assistants are being positioned. The early pitch was that a capable enough agent could handle a whole task from one prompt. Dynamic workflows quietly concede that, for many engineering processes, teams care more about predictability than improvisation. Code review, incident triage and release checks all have steps that should never be skipped and handoffs that need a consistent shape.

The approach is pragmatic. Agent judgment is confined to the steps where it adds value, and code and humans hold the guardrails. Structured output requirements and explicit review pauses tackle two of the most common complaints about agentic tools: inconsistent results and actions taken without oversight.

There are still open questions. The feature is in preview, its configuration may change, and the cost and permission trade-offs will only become clear with real-world use.13 For teams already building repeatable AI-assisted processes, though, the ability to have Copilot draft a workflow and then refine it into a shared, version-controlled procedure is a meaningful step beyond one-off prompting.2