Agent Architecture Decision Ladder
also known as four-step architecture ladder, least-powerful-architecture rule
Pick the agent architecture from a four-step ladder. The steps are: a plain model call, a single agent, a fixed multi-agent workflow, and an autonomous multi-agent system. Pick the lowest step that solves the task. This forces a choice you can defend, instead of jumping straight to an autonomous multi-agent system out of habit. Treat architecture as a cost-versus-benefit call, with clear criteria at each step.
Methodology process overview
Intent. Make the architecture choice a deliberate climb up a four-step ladder, backed by evidence, picking the lowest step that solves the task, instead of defaulting to an autonomous multi-agent system.
When to apply. Use this at project kickoff, before any architecture is built, and again at every big capability change that might push you up a step. Don't apply it when the architecture is fixed for you, such as a vendor mandate or an existing framework that already locks the step. Skip it too when the team has no habit of measurement. Without evals to compare steps, the ladder is just opinion.
Inputs
- Task profile — What kind of task it is: text generation, taking actions, structured teamwork, or open-ended exploration.
- Determinism requirement — How much variation the stakeholders will accept in the agent's behaviour and output.
- Cost and latency budget — The limits per task: tokens, infra spend, and total response time.
Outputs
- Architecture decision — The chosen step, with the reasoning written down. It is one of: plain model, single agent, fixed multi-agent workflow, or autonomous multi-agent system.
- Escalation triggers — The named conditions that would justify climbing to the next step later.
Steps (6)
Profile the task on the ladder dimensions
Rate the task on four things: does it need to take actions, does it break into parts, how deterministic must it be, and is it more about exploring or exploiting? These ratings decide the step.
Step 1 — plain model call
If the task is text generation with no tools, no memory, and no multi-step planning, stop at the model. Wrap it in an API and ship.
Step 2 — single agent
If the task needs tools, memory, or a loop, climb to a single agent with the four-component architecture. Most production agents stop here.
Step 3 — deterministic multi-agent workflow
If the task breaks into a fixed graph of specialist steps, build a deterministic multi-agent workflow with orchestrator-workers or pipes-and-filters. The structure lives in the graph, not in the agents.
Step 4 — autonomous multi-agent system
Climb here only when the task is truly open-ended, needs emergent coordination, or gains from agents negotiating with each other. Accept the cost of nondeterminism and coordination on purpose.
Document the decision and escalation triggers
Write down which step you chose and why. Name the conditions that would justify climbing higher later, so the next move rests on evidence, not vibes.
Framework-specific instructions
Pick a framework and generate a framework-targeted rewrite of this methodology's steps.
Choose framework
AI-generated for Agent Development Kit (ADK) (Google) — verify against official docs.
Principles
- Pick the lowest step that solves the task.
- The architecture choice is a written decision backed by evidence, not a reflex.
- Each step has a defining capability and a defining cost. Know both before you climb.
- Name the escalation triggers up front. Climb on evidence, not enthusiasm.
Known failure modes (4)
- ✕Hero Agent
Stuck on Step 2 with one over-stuffed agent because the team won't climb to Step 3 even when the task is decomposable.
- ✕Unbounded Subagent Spawn
Jumped to Step 4 without escalation triggers, ending up with an autonomous MAS for a task that Step 3 would have solved deterministically.
- ✕Demo-to-Production Cliff
Picked the step that demoed well rather than the step the production task needs.
- ✕Top-Tier Model For Everything (Cost)
Treated step choice as 'always go higher' the same way teams treat model choice as 'always pick the biggest'.
Related patterns (10)
- ★★Augmented LLM
Build the foundational agent block as an LLM augmented with retrieval, tools, and memory that the model actively chooses to use, rather than a bare-model call.
- ★★Tool Use
Let the LLM produce typed calls against an external toolkit instead of producing free-form text the surrounding system has to parse.
- ★★ReAct
Interleave a single thought, a single tool call, and a single observation per step so the agent reasons over fresh evidence.
- ★★Plan-and-Execute
Plan all the steps once with a strong model, then execute each step with a cheaper model under the plan.
- ★★Orchestrator-Workers
An orchestrator dynamically breaks a task into subtasks at runtime and delegates each to a worker LLM, then synthesises results.
- ★★Pipes and Filters
Compose stream-shaped processing as a chain of small filters connected by pipes.
- ★★Prompt Chaining
Decompose a task into a fixed sequence of LLM calls where each step's output becomes the next step's input.
- ★★Hierarchical Agents
Organise agents in a tree where higher-level agents decompose tasks for lower-level agents, recursively.
- ·Swarm
Run many peer agents that interact directly without a central supervisor, achieving emergent coordination.
- ·Debate
Have multiple agents argue different positions on a question and converge through structured exchange.
Related compositions (3)
- recipe · abstract shapeModern Coding Agent
An agent that reads, writes, and runs code in a sandbox, calling tools and (optionally) sub-agents while a human approves the destructive parts. The shape that powers Cursor, Claude Code, OpenHands, Aider, Codex CLI.
- recipe · abstract shapeMulti-Agent Coordination
Several agents collaborate under a coordinator, with explicit hand-offs and a shared protocol. The shape behind LangGraph supervisor, OpenAI Swarm, AutoGen group chat, Bedrock multi-agent orchestrators.
- recipe · abstract shapeProduction LLM Platform
Stand up a production LLM/RAG system whose data pipeline, model pipeline, and inference path scale and deploy independently.
Related methodologies (2)
- Agentic Workflow Construction★★
Make agent authors name the four parts and the freedom level before they code, so a failure points to one part instead of smearing across a vague agent.
- Agent Count Escalation★
Make 'how many agents' a decision driven by evidence, and force a deliberate choice of coordination style at each step up, instead of jumping to multi-agent by reflex.
Sources (3)
Designing Multi-Agent Systems: Principles, Patterns, and Implementation for AI Agents
Ch 1 'Understanding Multi-Agent Systems' (sub-section numbering 1.7 / 1.7.1 not independently verified online — TOC excerpts list Chapter 1 without sub-section detail) “Designing Multi-Agent Systems — Principles, Patterns, and Implementation for AI Agents”
Two Years, 15 Chapters: The Multi-Agent Systems Book Is Finally Here!
“important theory in the first 3 chapters ... agents with model clients, memory, tools, structured output, and agentic memory, as well as multiagent patterns”
designing-multiagent-systems (Victor Dibia) — chapter index
“Chapter 1: Understanding Multi-Agent Systems (poet/critic example) ... Chapter 2: Multi-Agent Patterns ... Chapter 3: UX Design Principles”
Provenance
- Added to catalog:
- Last updated:
- Verification status: needs-verification