One Agent
can't finish anything worth shipping.

• CEILING · 01 · CONTEXT DRIFT

  Past 50 steps, the original instructions get diluted by new content

  You give the agent a system prompt + a goal, let it run 80 steps. By step 50, the agent can barely see the original system prompt anymore — it's drowning in its own recent outputs + tool results. Symptom: opens strong, then drifts, forgets rules, answers the wrong question. No stronger model fixes this — it's a physical limit of attention + context length.

• CEILING · 02 · TOOL OVERLOAD

  One Agent with 20+ tools — the routing decision falls apart

  As you add more tools to an agent (Gmail, Calendar, Notion, SQL, Web search, custom APIs…), every decision becomes "pick one of N tools" — pick wrong and it drifts. Measured in production: above 15 tools, tool-selection accuracy drops linearly; above 30, it's basically unusable. More tools, less competence — this is a structural problem with Function Calling, not something prompt-tuning can fix.

• CEILING · 03 · ERROR COMPOUNDING

  Single-thread tasks: one wrong step poisons everything downstream

  The agent misreads a customer name at step 12. Every action from step 13 on (lookup, draft reply, send email) is based on the wrong name, but the agent can't see this — there's no second pair of eyes on its intermediate results. By step 30 you notice, dig through the log, trace it back to step 12 — but it already happened in production. This is the most common incident pattern in single-agent setups.

• CEILING · 04 · ROLE COLLAPSE

  Asking it to "do + check + report" at once — none of them done well

  You write a giant prompt: research the market, draft copy, critically review it, output a markdown report. The agent skims every role — it can't actually switch reasoning modes within one inference pass. Especially "Drafter + Critic" — without separation it always rationalizes its own work: the writer and the critic are the same reasoning stream.

One test for "is this real multi-agent": are the two agents' context windows genuinely independent? If it's just "you are agent A… you are agent B" inside one system prompt, that's role-play — not multi-agent.

Real multi-agent has 4 archetypal collaboration patterns. They solve different problems, at different complexity levels. Most production systems combine them.

• PATTERN · 01 · MANAGER–WORKER

  One Manager splits the task, N Workers each execute a slice

  The most common, easiest to grasp. The Manager agent receives a big task, splits it into N subtasks, dispatches them to specialized Worker agents, each worker runs its slice in an independent context, reports back, and the manager aggregates and produces the final output.

  USE50-page research report · Manager–Worker implementation

  ·MANAGERsplit into 8 chapters → assign to 8 Researchers

  ·WORKER ×8each independently researches and writes their chapter · no interference

  ·MANAGERcollect 8 chapters → unify voice → write intro + conclusion

  WHEN TO USEtask splits statically · subtasks have no hard dependencies
• PATTERN · 02 · PIPELINE

  Agent A → Agent B → Agent C — each finishes, hands off downstream

  Assembly-line style. Each agent owns one stage of transformation, the previous agent's output = the next agent's input. Difference from Manager–Worker: a pipeline is serial and single-track, with no central dispatcher.

  USEContent production · Pipeline implementation

  01RESEARCHERmine 10 viral pieces from the niche → extract common patterns

  02IDEATORbased on research → produce 7 topic ideas + outlines

  03WRITERwrite the full draft

  04EDITORcopyedit, adjust to voice corpus

  05PUBLISHERformat + multi-platform adapt + schedule

  WHEN TO USEtask is a linear chain · each stage needs a different specialty
• PATTERN · 03 · SPECIALIST ROUNDTABLE

  Multiple expert Agents look at the same problem in parallel, one Synthesizer combines

  "Three doctors in consultation" mode. The same input goes simultaneously to multiple expert agents, each looks through their own professional lens and produces an independent verdict; a final synthesizer merges the perspectives. Key point: parallel — the experts don't talk to each other, to avoid cross-contamination.

  USEStock decision · Roundtable implementation

  ·QUANTtechnicals (MA crossover, RSI, volume/price) · independent score

  ·FUNDAMENTALearnings, industry, valuation · independent score

  ·SENTIMENTnews, social, institutional moves · independent score

  ·RISKposition size, volatility, correlation · independent score

  ·SYNTHESIZERaggregate 4 independent verdicts → produce a recommendation

  WHEN TO USEyou need multiple independent perspectives · afraid of single-track thinking
• PATTERN · 04 · ADVERSARIAL

  Drafter writes, Critic tears it apart, iterate until convergence

  Adversarial. One agent produces (Drafter), another agent exists to find problems (Critic). They go back and forth until the Critic has nothing left or the iteration limit hits. The core problem it solves: a single agent reviewing its own work always rationalizes.

  USECode Review · Adversarial implementation

  01DRAFTERread issue → write implementation + tests → submit v1

  02CRITICtear it apart (edge cases, security, perf, readability) → list fixes

  03DRAFTERapply feedback → submit v2

  04CRITICre-review → until approved or 3 rounds done

  WHEN TO USEoutput quality is non-negotiable · wrong = expensive (code / contracts / legal opinions)

• LEVEL · 01 · SINGLE AGENT

  Can your task finish in 10 steps and won't recur?

  If yes: don't reach for Skill, definitely not Multi-agent. All you need is a ChatGPT / Claude window + a prompt. Skills and Multi-agent both carry maintenance cost — don't build infrastructure for a one-off.

  Trigger signal: ad-hoc tasks that happen 0-1×/week · single function · no parallelism needed
  Real example: writing one-off email / researching an ad-hoc question / looking up a reference
• LEVEL · 02 · SINGLE AGENT + SKILLS

  Does the same Agent need to handle 5+ task types, or is one workflow segment reused everywhere?

  If yes: add Skills, but you don't need Multi-agent yet. Skills lets one Agent operate like a team — same context, callable modular capabilities. Moderate maintenance cost: you write SOPs, but only one agent runs.

  Trigger signal: same agent handles 5+ task types · one workflow segment reused across places · team needs to collaborate on prompts
  Real example: personal assistant (email + calendar + Notion + memos) / all-in-one support (multi-class tickets + knowledge base + escalation)
• LEVEL · 03 · MULTI-AGENT

  Any of: context overload / need independent reviewer / need real parallelism?

  If yes: go Multi-agent. But be ready to spend 5-10× more on protocol design, debugging the chain, monitoring state. Multi-agent isn't "the more advanced version" — it's the choice when you have no option but to divide labor.

  Trigger signal: single agent drifts past 50 steps · must have independent eyes critiquing · 4+ subtasks parallelizable · context can't hold the full schema
  SUB-CHOICEHow to pick among the 4 patterns

  ·MANAGER-WORKERtask splits statically · subtasks independent

  ·PIPELINEtask is sequential transformation · each stage needs a specialty

  ·ROUNDTABLEneed multiple independent perspectives · afraid of groupthink

  ·ADVERSARIALquality is non-negotiable · wrong = expensive (code / contracts)

  REMEMBERmost production systems are 2-3 patterns nested together

• OBSERVATION · 01 · LANGGRAPH WRAPPER

  "Multi-agent Platform / OS"

  2024-2026 produced a flood of "Multi-agent OS / platform" startups. Most are LangGraph + a UI layer, with no genuinely independent contexts between agents. The test is simple: ask "what does each of your two agents see in their system prompt?" — if they can't name specific boundaries, it's a wrapper.

• OBSERVATION · 02 · MORE TOOLS > BETTER AGENT

  "Our Agent has 100+ Skills"

  "Number of Skills" gets pitched as a selling point, but the Tool Overload ceiling from §02-02 applies to skills too — the more you load in, the worse the agent's skill-selection gets. Production measurement: past 15-20 skills, recall accuracy falls off a cliff. 10 sharp Skills > 50 noisy ones.

• OBSERVATION · 03 · ACADEMIC vs PRACTICAL

  "Multi-agent is the path to AGI"

  This is an academic debate 20 years old (agent-based modeling, swarm intelligence, multi-agent reinforcement learning…) — it has nothing to do with you building a system that actually handles support tickets today. This grand narrative gets used to dress up simple LangGraph demos — when you hear it, remember: however grand, it still has to handle a ticket.

• OBSERVATION · 04 · PROPRIETARY FRAMING

  "Skill is an Anthropic-proprietary feature"

  Wrong. Skill isn't any vendor's feature — it's a design pattern. OpenAI Custom GPT Actions, LangChain Tools, your own modular prompt files, even Unix tools + a README — they're all the same thing at the core: package reusable capability into a unit that's discoverable and callable. Who packages it cleanest is a separate question, but the concept doesn't belong to anyone.

• OBSERVATION · 05 · WRONG ORDER

  "Complex tasks require Multi-agent"

  Usually said backwards. The first thing to do with a complex task is turn it into an SOP — break it into repeatable steps with explicit input/output per step. After the SOP, most tasks' "complexity" drops to where single agent + skills handle it; only what truly remains — the parts needing parallelism or independent review — goes multi-agent. Reverse the order — stack multi-agent first — and you're using expensive coordination cost to mask the fact you haven't thought through the workflow.

• WEEK 1 – 2 · FIND CANDIDATES

  List the 3 highest-frequency subtasks in your workflow

  Not "things I want to replace with AI" — things you do "5+ times a week, almost the same steps each time." These are the natural Skill candidates. Write them down: name / frequency / input / output / current time spent. Failure signal: can't list 3 — your workflow isn't regular enough yet, go back to Ep 01. What to do: spend another week doing it purely manually, jotting down every task as you do it.

• WEEK 3 – 4 · WRITE THE FIRST SKILL

  Pick the most painful candidate — write it as SKILL.md and run it

  Write a standalone file with the 4 parts from §03 (DESCRIPTION / CONTRACT / PROMPT / TOOLS). Hook it into Claude Code or your own agent and run it for a week — every time the task comes up, just call it, never hand-write the prompt. Failure signal: by end of Week 4 you're still frequently editing the prompt inside SKILL.md. What to do: it's not Skills failing — your task isn't SOP-ready. Go back and decompose it further.

• WEEK 5 – 8 · FILL UP ONE AGENT

  Write 3-5 Skills and load them into the same Agent

  Turn the other 2-4 tasks from Week 1-2 into Skills too. Your agent should now handle 5 different task types in a single context — experientially, it goes from "generalist assistant" to "colleague with real expertise". Failure signal: agent routinely picks the wrong Skill / mixes logic from two Skills. What to do: you loaded too many — trim back to the 3 highest-frequency, save the rest for the Multi-agent phase.

• WEEK 9 – 12 · FIRST DIVISION OF LABOR

  Pick a complex task that won't run, design a 2-3 agent collaboration

  Find a task that actually hits a §02 ceiling — single agent breaks past 50 steps, or needs an independent critic, or needs parallel processing. Pick one of the 4 patterns in §04 and build a minimal viable multi-agent system. Don't go big, don't aim for complete — just make the simplest version that runs end-to-end. Failure signal: by Week 12 you're still tweaking prompts / protocols, end-to-end doesn't run. What to do: usually the system you designed is too complex — strip it down to two agents, then ask which one really needs to be independent.

After 12 weeks, you should be able to answer: "Which part of my daily work is one Agent calling a set of Skills? Which part is multiple Agents collaborating?"

If you can point to both, with outputs and logs — you've crossed the Ep 01 → Ep 02 boundary. If you can't — you're still working out of "one ChatGPT window," not "building a system."

← EP 01 · What is AI Agent　·　EP 02 (you are here)　·　EP 03 (coming)