Skip to content
Sign in
Orchestrating Design Agent Teams

When one agent is not enough — run the team without the coordination tax eating the win.

One agent in a loop covers most design work. This course is for the cases where it does not: large surfaces, parallel workstreams, and pipelines that span research, canvas, code, and review. It covers the honest decision of when multiple agents are worth the coordination tax, the orchestration patterns that actually hold up — fan-out, pipelines, critic pairs — chaining MCP-connected design tools, running concurrent agents on a shared canvas without collisions, building canvas-to-production pipelines with gates, and operating the whole thing as a team capability with cost, governance, and review handled like any other production system.

Pay once. Yours to keep, with updates.

US$45One-time purchase

Buy courseDesigner TrackEverything bundle

Buying for a team? Team seats

Modules
6 modules
Total time
≈4h 45m
Last updated
2026-10-09

Curriculum

6 modules

Slides are the lesson; study guide and transcript come with each module.

Time commitment

≈4h 45m

About ≈5 hours across the full outline — work at your pace.

Access

US$45

Pay once. Yours to keep, with updates.

What you will build / 01

Artefacts you can take back to the team.

Honest multi-agent decisions, fan-out and critic patterns, MCP chains, concurrent canvas work, and canvas-to-production pipelines with owners on every gate.

01

A clear call on single-agent vs multi-agent for a given task

02

Fan-out, pipeline, and critic-pair patterns with merge rules

03

MCP chains across canvas, code, browser, and tickets

04

Concurrent agent runs without collisions

05

Production pipelines with gates, cost visibility, and audit trails

Four matte black notebooks linked by cobalt threads to a central cream stack with a mustard card on warm paper
Curriculum / 02

Module outline

Open the first module you have not finished. The slides are the lesson. The study guide and the transcript are the same module if you would rather read.

01

When One Agent Is Not Enough

The decision this whole course hinges on: multi-agent setups carry a real coordination tax, and most tasks do not repay it. This module covers the signals that a task genuinely splits, the costs people underestimate, and the single-agent alternatives to try first.

02

Orchestration Patterns

The three patterns that cover most real cases: fan-out for independent parallel work, pipelines for staged work with handoffs, and critic pairs where one agent produces and another reviews against the criteria.

03

MCP Chaining Across Design Tools

Single MCP connections are useful; chains are where orchestration earns its keep — research feeding a canvas, the canvas feeding code, the browser feeding screenshots back into review — with attention to credentials, scopes, and what happens when one link fails.

04

Concurrent Agent Teams on the Canvas

Multiple agents working a shared canvas or design file at the same time: zone ownership, naming and layout conventions that prevent collisions, and the review rhythm that keeps a fast-moving canvas coherent.

05

Canvas-to-Production Pipelines

The full pipeline from approved canvas design to production code: stage gates, parity checks, token sync, and the handoffs where intent historically leaked — now run as an orchestrated workflow with evidence at every stage.

06

Operating a Design Agent Team

Making the capability durable: cost visibility and budgets, permissions and audit trails, review capacity that scales with output volume, onboarding people into the system, and the governance that keeps speed from outrunning accountability.

Inside the materials / 03

Sample lesson & slide previews

Titles and diagrams from early modules — the same materials you open after checkout.

Decision diagram with a central gate panel listing three questions: can each worker's ownership boundary be stated in one sentence, do the slices avoid sharing files, components, or one taste loop, and is the task valuable enough to pay the coordination and token cost. Any answer of no leads left to the default of one well-harnessed agent, suited to coupled taste work, single surfaces, and small tasks, at the cost of longer runs, sequenced sessions, and no independent reviewer. All three answers of yes lead right to splitting across agents, suited to independent zones, parallel deadlines, and distinct expertise, at the cost of orchestration setup, duplicated context, multiplied tokens, and a mandatory merge review.Three orchestration patterns shown side by side. Fan-out with merge: an orchestrator brief with boundaries, overlaps, and gates dispatches three parallel workers, each owning one zone and one output, converging into a single merge review that resolves against the system and logs rejected options; use it when zones are independent and reading volume is the bottleneck; it fails when seams drift, signals duplicate, and the merge accepts everything. Sequential pipeline with gates: a spec stage feeds a build stage feeds a verify-and-ship stage, with an owner-approval gate and a checks-pass gate between stages; use it when each stage's output is the next stage's input and checkpoints matter; it fails when a weak early stage propagates and gates rubber-stamp. Generator-critic pair: a producer drafts against the brief and a read-only critic returns findings tied to explicit criteria with an iteration cap, ending at a human gate before shipping; use it when quality criteria can be written down and review must be independent; it fails when criteria are vague, rounds run unbounded, or the critic starts editing the work.Diagram of one agent session connected to four links: a research board (Miro or Notion) the agent reads stickies and content from and writes nothing to; a design canvas (Figma, Pencil or Paper) it reads variables, structure and screenshots from and writes frames to behind a prompt; the repository where it reads tokens and DESIGN.md and writes code on a branch; and a browser server (Playwright or DevTools) used read-only for screenshots and console output as review evidence. A band along the bottom lists the typical break points: OAuth and credential rejection on remote servers, local apps or dev servers not running, stale connections in long sessions, and context burn from screenshots and tool definitions.Flow diagram of a concurrent canvas run. An orchestrator decomposes one page into zones with single owners and a merge order decided up front. Three worker agents — hero zone, features zone, and footer zone — work their own frames in parallel, each reading the same shared system constraints: variables and tokens, the component library, and naming conventions, with constraint changes routed back to the orchestrator. Worker output flows into a merge and consistency pass owned by one merge owner, which diffs every zone against the tokens, checks spacing, type, and naming drift, snapshots the whole page, and produces one fix list per zone. A designer review then judges coherence across zones and decides to ship, run another round, or fold the work back to a single agent. A dashed feedback line returns the fix list to the owning zone only.

When One Agent Is Not Enough · concept

The coordination tax

When One Agent Is Not Enough · concept

Signals a task genuinely splits

When One Agent Is Not Enough · checklist

Signals it does not split

When One Agent Is Not Enough · concept

Single-agent alternatives to exhaust first

When One Agent Is Not Enough · diagram

The decision map

When One Agent Is Not Enough · comparison

Honest cost accounting from real runs

Audience and outcomes / 04

By the end of this course you can…

Design leads, design engineers, and staff designers who already run single-agent workflows comfortably and are hitting their limits — or who have been asked to make agentic design work for a whole team.

01

Decide when a task genuinely needs multiple agents and when one agent with a better harness wins.

02

Apply fan-out, pipeline, and critic-pair patterns with clear boundaries and merge rules.

03

Chain MCP-connected design tools so canvas, code, browser, and tickets participate in one workflow.

04

Run concurrent agents against a shared canvas or codebase without collision and rework.

05

Build canvas-to-production pipelines where every stage has a gate and an owner.

06

Operate an agent team: cost visibility, permissions, audit trails, and review capacity that scales with output.

Who it is for

This is for you if…

  • Design leads, design engineers, and staff designers past comfortable single-agent work
  • People asked to operationalise agentic design for a team
Who should skip it

This is not for you if…

  • Designers still learning their first agent loop — take Fundamentals and Claude Code first
  • Anyone chasing multi-agent demos without a merge and review plan
Why register now

The practice compounds. Waiting does not.

01

Parallel workstreams and large surfaces are where single-agent loops stall.

02

Coordination tax is real — the course starts with when not to multi-agent.

03

Leads are already asked to make agentic design work for a whole team.

Price and checkout

Pay once. Keep the course, with updates.

Prefer the full designer catalogue, or designer plus leadership? Upsell paths use the same checkout you already trust.

Pay once. Yours to keep, with updates.

US$45One-time purchase

Buy courseDesigner TrackEverything bundle

Buying for a team? Team seats

FAQ

Before you register

Is multi-agent always better?

No. The first module is the decision: when one agent with a better harness wins. Multi-agent is for the cases where it does not.

Is this a subscription?

Pay once. Yours to keep, with updates. There is no renewing membership for new purchases.

What do updates cover?

All edits and new lessons in an owned course, for the life of the course. Bundles include new courses added to that track for 12 months.

What if a course is retired?

Course retirement gives access to its replacement.

Related material / 05

The sources behind this course.

The course teaches the practice; the books and articles carry the depth, sources, and worked runs it draws on.

The Agentic Designer

The operating model for product designers, design leads, and builders who need to understand what changes when agents join design work.

Leading a Design Organization with Agents

The three leadership courses are sold together for US$300. Designer courses and bundles don't include them, except the Everything bundle, which does. This purchase doesn't open the designer courses.

View course

When to Use Multiple Design Agents

A practical decision guide for splitting design work across agents — with a small, real orchestration trace, the briefs and merge log it produced, sourced cost numbers, and clear examples of when a single agent is the better choice.

Read article

Connected Canvases: Designing with Paper and Pencil from the Terminal

A practical guide to design canvases an agent can read and write directly — Paper's HTML/CSS canvas and pen.dev's repo-resident .pen files — including MCP setup, a worked landing-section round trip, and where Figma still wins. Prices and platforms re-read 9 October 2026.

Read article

MCP for Designers: Connecting Figma, Miro and Your Canvas to an Agent

A plain-language guide to the Model Context Protocol for designers: what it is, which design servers are worth connecting, how to configure them on Claude Code, Codex CLI, OpenCode, and Antigravity CLI, and the permission hygiene that keeps a write tool behind a prompt. Re-read 9 October 2026.

Read article

From Canvas to Production: The Design-to-Code Pipeline, Honestly

What stands between a designed section and a shipped page: the export step, the gates that make it shippable, and a case study from 1 June 2026 that records what each gate caught. Tool status was re-read on 9 October 2026. The case study was not re-run.

Read article

Orchestrating a Design Team of Agents: Patterns, Costs and Merge Pain

How to actually run a team of design agents once you have decided to split the work — decomposition patterns, what agent teams, subagents, worktrees, and concurrent canvases support today, a five-surface orchestration run executed for this article, and the complexity tax with the run's own numbers.

Read article