AI PM Ready

Multi-agent systems

How to design, own, and ship products where multiple AI agents collaborate — and what breaks when you don't.

Orchestration Layer

Authority Hierarchy

Every multi-agent system needs a chain of command. Without one, agents deadlock waiting for peers to resolve ambiguity — or two agents issue contradicting instructions to a third and the system produces garbage output with no error. The authority hierarchy defines which agent can instruct which. It is a PM-owned document, not an emergent engineering decision.

LevelAgentWhat it does
L1Orchestrator AgentReceives the task, maintains state, delegates to domain agents, assembles final output.
L2Domain Agents (Research, Writer, Reviewer)Executes a scoped subtask, returns structured result to orchestrator.
L3Tool WorkersCalls a specific API or tool (web search, database query, code runner), returns raw result.

The hard rule: an agent must receive instructions from exactly one parent. Two domain agents cannot both delegate to the same worker simultaneously — the orchestrator gates those calls sequentially, or you get race conditions in the output.

Warning: Peer-to-peer delegation — two domain agents instructing each other — is the most common hierarchy violation in MAS design. It creates circular dependency chains that are nearly impossible to debug in production.

Agent Design

Context vs. Stateless Agents

The distinction between context-carrying and stateless agents is the most consequential design decision in a MAS — and most PMs leave it to engineers. A context agent maintains the running task state across every step. A stateless agent receives a self-contained instruction packet, executes exactly that, and returns a result with no memory of prior calls.

Context AgentStateless Agent
MemoryMaintains full task historyOnly what's in the handoff payload
CostHigher — more tokens per callLower — minimal context per call
DebugHard — failure depends on accumulated stateEasy — reproduce by replaying the payload
Blast radiusEntire task if it failsSingle subtask only
Default choiceOrchestrator onlyAll subagents

Rule of thumb: Default every subagent to stateless. The orchestrator pays the cost of knowing everything so the subagents don't have to. Stateless subagents are also easier to swap — if your Research agent underperforms, you can replace it without touching anything else in the pipeline.

Agent Specification

Agent Scoping

An unscoped agent is a liability. Given an out-of-scope request, a specialist agent will not return an error — it will try to answer anyway, hallucinate, and pass the result upstream with no flag that it was operating outside its domain. Scope must be explicit, not implicit.

Checklist — what a well-scoped agent spec must define
Role: One sentence. What is this agent's single job?
Tools: Explicit list of tools this agent may call. No tools not on the list.
Input format: Schema of the handoff payload it accepts. Reject malformed inputs.
Output format: Schema of the result it returns. Structured, not prose.
Max steps: Hard cap on tool calls per invocation. Prevents runaway loops.
Scope rejection criteria: What inputs trigger an "out of scope" return signal, and what that signal looks like.
Escalation path: If the task exceeds scope or max steps, which agent or human does it notify?

Warning: "The agent will just know what it can't do" is not a scoping strategy. Models will attempt tasks they shouldn't. Scope rejection must be an explicit, enforced behavior — a structured response like { status: "out_of_scope", reason: "..." } — so the orchestrator handles it without treating it as a crash.

PM Artifact

The Agent Spec

The Agent Spec is the PM's primary deliverable in MAS — what you write before engineering designs anything. Without a spec, the system has no reference for correct behavior. When an agent misbehaves in production, you need to compare what it did against what it was supposed to do. If the spec doesn't exist, that comparison is impossible.

Minimal Agent Spec template
Agent Name:      [e.g., Research Agent]
Role:            [One sentence — what is its single job]
Authority Level: [L1 Orchestrator / L2 Domain / L3 Tool Worker]
Parent Agent:    [Which agent delegates to this one]
Tools Allowed:   [Explicit list — e.g., web_search, read_file]
Input Schema:    [Fields the handoff payload must contain]
Output Schema:   [Fields the result must contain]
Max Steps:       [Hard cap on tool calls per invocation]
Failure Behavior:[What it returns on error — structured, not an exception]
Escalation Path: [Which agent or human receives the escalation signal]
Scope Rejection: [What inputs trigger a rejection and what the signal looks like]

Good practice: Treat the Agent Spec like an API contract. Engineers don't change the input/output schema without a versioning discussion. PMs don't change the scope without updating the spec. Both treat the spec as the source of truth.

Orchestration Patterns

Choosing a Pattern

Pattern selection is a product decision with direct consequences for cost, speed, auditability, and output quality. The PM owns this choice; engineering implements it.

Orchestrator → Subagent

A planning agent receives the task, maintains context, breaks work into subtasks, and delegates to stateless specialist agents. The orchestrator holds state; subagents execute and return results.

Orchestrator assigns web research to Search Agent, report writing to Writer Agent, and fact-checking to Review Agent. Each specialist runs blind to the others.
Sequential Pipeline

Agents run in a fixed chain — output of Agent A feeds input of Agent B. No parallelism, but fully auditable. Every step is logged, reviewable, and reproducible.

Klarna's support system — Triage Agent routes → Resolution Agent resolves → Confirmation Agent closes. Compliance teams can replay any conversation step by step.
Parallel Fan-out

Multiple agents execute independent subtasks simultaneously. A synthesizer agent merges and deduplicates results. Fastest pattern for work that can be split without dependencies.

Three Research Agents each query a different data source simultaneously. Synthesizer Agent merges findings, removes duplicates, and returns a unified result to the orchestrator.
Peer Review Loop

Agent A produces output; Agent B critiques against a quality rubric; Agent A revises. Loop continues until a quality threshold is met or a max iteration count is hit.

Code Agent writes a function, Test Agent runs it and returns failing assertions, Code Agent fixes and resubmits. Max 3 iterations, then escalates to human.

The tradeoff: Sequential gives you an audit trail but no speed. Parallel gives you speed but adds a synthesizer failure point. Peer review improves quality but multiplies cost.

Try It Yourself
Spec writing

You're the PM for a content pipeline with an Orchestrator, a Research Agent, and a Writer Agent. Write the Agent Spec for the Research Agent using the template above.

Authority hierarchy

A colleague says 'the agents will figure out who delegates to whom at runtime.' Write a one-paragraph rebuttal explaining why authority hierarchy must be defined in the spec — with a concrete example of what breaks when it isn't.

Scope rejection

Your Research Agent is returning out-of-scope results into the pipeline. You don't have a scope rejection mechanism. Design one — what signal does it return and how does the orchestrator handle it?

Key Takeaways
Authority flows one way

Every agent has exactly one parent. Peer-to-peer delegation creates circular dependencies that are undebuggable in production.

Default to stateless subagents

The orchestrator holds state so subagents don't have to — this contains blast radius and makes individual agents swappable.

Scope rejection is a feature, not an edge case

An agent that returns a structured "out of scope" signal is safer than one that tries to answer and hallucinates.

The Agent Spec comes before engineering

If the spec doesn't exist before the orchestration layer is designed, you'll pay to rewrite both when behavior needs to change.

Pattern choice is a PM tradeoff

Sequential pipelines are auditable. Parallel fan-out is fast. Peer review loops improve quality but multiply cost. These are product decisions with business consequences — not engineering preferences.

Was this page useful?