GitHub Copilot Ships Dynamic Workflows: Multi-Agent Processes as Code

What happened

The October 1 GitHub Changelog brought a capability worth savoring: Dynamic Workflows, landing simultaneously in Copilot CLI, the Copilot app, and the Copilot SDK as a public preview. It lets you write a multi-agent process down in code, so Copilot runs the exact same steps every time instead of re-prompting an agent from scratch on each run.

GitHub's own example is incident triage: the workflow pulls logs and telemetry, assigns independent agents to analyze different systems in parallel, then merges their structured findings into a timeline and root-cause report. The same steps, on every incident — not a fresh ad hoc investigation each time.

What it actually is: a program, not a prompt

A dynamic workflow is fundamentally a program that defines how a task gets done. It mixes automated steps with the work of one or more agents: which steps run in sequence, which in parallel, when to involve agents, how to use their results — all defined in code, while agents handle only the parts needing analysis or judgment.

Technically, it lives inside a GitHub Copilot extension, so it inherits the full extensibility API surface. It can run commands, use tools, call other services; split a goal into tasks and run them in parallel; pass structured results between stages; have subagents verify each other's findings; ask you for input where the client supports it; and pause at a checkpoint so you can review results and resume when ready.

GitHub drew an explicit line against the existing /fleet command: with /fleet, Copilot itself decides on the fly how to split and coordinate subagents; a dynamic workflow executes a process fixed in code ahead of time — by a developer, or by Copilot prompted to write one. One is improvisation, the other is following the script. They complement rather than replace each other.

The recommended use cases

The changelog lists the good candidates: running release checks, having one agent assess failures, then pausing for your review before resuming; reviewing many changed files in a PR in parallel; using code to find unresolved review comments on merged PRs, then asking two models whether the comments still matter — reporting only when both agree; sweeping a large codebase for a pattern (missing tests, usages of an API being removed); research-then-plan-then-implement pipelines; and kicking off long, potentially expensive runs you may want to pause and resume.

Note the counter-advice too: for a quick answer or a simple change, normal chat mode is enough. Dynamic workflows are for processes you want to reuse, or tasks that need clear stages, checks, or limits — don't bring a cannon to a knife fight.

The on-ramp is deliberately low: author workflows yourself or have Copilot write them for you — like extensions, Copilot ships built-in authoring guidance that can teach you or generate a complete workflow. On the CLI side you need experimental mode (--experimental or /experimental on); in the app it works out of the box, on all Copilot plans.

Why this is bigger than it looks

The trend first: this is "process as code" officially entering the AI agent world. Over the past year the capability curve was "agents can do more"; the curve now is "agents can repeat reliably." As agents take on production processes — release checks, incident response, code review — "improvise every time" flips from a feature into a risk: the same input should produce the same process. Dynamic workflows pull the "how" out of the prompt and into version-controlled, reviewable, testable code. That's the inevitable path of engineering maturity.

Then the direct value for vibe coders: those checklists of prompts you keep reusing finally have a better home. The pre-release sweep you run before every deploy, the analysis routine before every refactor, the weekly dependency health check — they used to live as saved prompts; now they can become a workflow: fixed steps, parallel speedup, structured intermediate results, and a pause for your nod at the critical moment. Vibe coding's bottleneck is shifting from "can the agent do it" to "is the process trustworthy" — which is exactly the problem dynamic workflows attack.

One detail worth savoring: GitHub houses workflows inside extensions. That means your workflow automatically inherits the Copilot ecosystem — MCP tools, private data sources, enterprise policies, all available. It's not another island; it's a brick in the existing wall.

The sober part: public preview, explicitly "subject to change." Betting your core production pipeline on it today is premature — but piloting one non-critical flow (say, a weekly dependency scan) costs little and teaches you the paradigm early. When it goes GA, you'll already be someone who writes workflows.