👥

Chapter 25 · 12 min read

From Solo Agent to Agent Team

When one brilliant employee isn't enough, build a department

You've built one agent and it's incredible. It handles your morning briefing, writes content, monitors markets, and keeps your memory organized. But now you're hitting a wall: one agent can't do everything well. It's like having one employee who's your receptionist, accountant, marketer, and developer. Eventually, they start dropping balls.

🍕 Real-life analogy

Think of it like a restaurant. When you first open, the owner does everything — cooking, serving, cleaning, managing. It works when you have 5 tables. But at 50 tables? You need a chef, servers, a dishwasher, and a manager. Not because the owner got dumber — because the workload exceeded what one person can context-switch between. Agents hit the same wall.

When to Go Multi-Agent (Decision Framework)

Don't add agents just because you can. More agents = more complexity = more cost = more things that can break. Add another agent only when you hit one of these triggers:

🚨 Trigger 1: Context Overflow

Your agent's instructions + memory + current task exceed the context window. It starts "forgetting" parts of its job because there's too much to hold at once.

⚠️ Trigger 2: Conflicting Personalities

Your agent needs to be both a careful analyst AND a creative writer AND a blunt code reviewer. These personalities fight each other in a single system prompt.

📊 Trigger 3: Parallel Workloads

You need things done simultaneously: research happening while content is being written while code is being reviewed. One agent means sequential, not parallel.

💰 Trigger 4: Cost Optimization

Some tasks need GPT-4/Claude Opus (complex reasoning). Others work fine with GPT-4o-mini/Haiku (simple extraction). One agent = one model tier for everything.

⚖️ The Rule of Thumb

If your single agent is handling 3+ unrelated domains (e.g., trading + content + DevOps), it's time to specialize. If it's handling 3+ related tasks in one domain (e.g., research + draft + edit for content), keep it as one agent.

Shared vs. Private Memory

The most critical decision in multi-agent setups: what can each agent see?

Memory boundaries

workspace/
├── shared/              # All agents read/write
│   ├── MEMORY.md        # Shared long-term memory
│   ├── inbox/           # Cross-agent communication
│   │   ├── research-to-writer.md
│   │   └── analyst-to-chief.md
│   └── knowledge/       # Shared knowledge base
│
├── agents/
│   ├── researcher/      # Only the researcher sees this
│   │   ├── SOUL.md
│   │   ├── memory/
│   │   └── scratch/     # Working drafts, raw data
│   ├── writer/          # Only the writer sees this
│   │   ├── SOUL.md
│   │   ├── memory/
│   │   └── drafts/
│   └── analyst/         # Only the analyst sees this
│       ├── SOUL.md
│       ├── memory/
│       └── data/

Shared memory contains facts everyone needs: project status, user preferences, completed decisions. Private memory contains agent-specific working state: raw research data, draft iterations, intermediate analysis. Think of shared memory as the company wiki and private memory as each employee's notebook.

Communication Patterns

Agents need to talk to each other. There are two main patterns, and they have very different tradeoffs:

📁 File-Based Communication (Recommended)

Agents write to a shared inbox/ folder. Other agents check the inbox periodically. Async, debuggable, auditable. Like internal memos.

💬 Direct Messaging (Use Sparingly)

One agent spawns or invokes another directly with a prompt. Faster but harder to debug. Like a phone call — no paper trail unless you create one.

Agent thinking...

▊

Specialization Patterns

The four agent archetypes that cover 90% of use cases:

🔍 The Researcher

Searches the web, reads documents, summarizes findings. Optimized for breadth and accuracy. Model: can use cheaper models for bulk search, expensive for synthesis.

✍️ The Writer

Takes research and turns it into content — blog posts, tweets, reports, emails. Optimized for tone, style, and persuasion. Needs the strongest language model.

📊 The Analyst

Crunches numbers, spots patterns, makes recommendations. Optimized for accuracy and structured reasoning. Lives in spreadsheets and data files.

⚙️ The Operator

Executes tasks: deploys code, sends emails, updates databases, runs cron jobs. Optimized for reliability and tool use. Needs the highest trust level.

The "Chief of Staff" Pattern

The most powerful multi-agent pattern is deceptively simple: one main agent that delegates to specialized sub-agents.

🍕 Real-life analogy

Think of a CEO with a Chief of Staff. The CEO (you) says "I need a market analysis and a blog post about it." The Chief of Staff (main agent) breaks that into tasks: tells the Researcher to gather data, tells the Analyst to crunch numbers, tells the Writer to draft the post, then compiles everything into a final deliverable. You never talk to the sub-agents directly. The Chief of Staff manages the workflow.

Chief of Staff pattern

# Main agent (Chief of Staff) receives:
"Analyze the AI agent market and write a blog post about it"

# It breaks this into sub-tasks:
1. → Researcher: "Find top 10 AI agent frameworks, their pricing,
     user counts, and key differentiators. Output to
     shared/inbox/research-ai-agents.md"

2. → Analyst: "Read shared/inbox/research-ai-agents.md. Compare
     frameworks on cost, capability, and ease of use.
     Score each 1-10. Output to shared/inbox/analysis-ai-agents.md"

3. → Writer: "Read research and analysis files. Write a 1500-word
     blog post titled 'Best AI Agent Frameworks in 2026'.
     Match our brand voice in SOUL.md.
     Output to shared/inbox/draft-ai-agents-blog.md"

4. Chief compiles, reviews, delivers to human.

Avoiding "Too Many Cooks"

More agents doesn't always mean better results. Here are the failure modes:

💥

Write conflicts — two agents editing the same file simultaneously. Solution: each agent owns specific files.

🔄

Infinite loops — Agent A asks Agent B for input, B asks A for clarification, repeat forever. Solution: set max delegation depth.

💸

Cost explosion — 5 agents each using GPT-4 = 5x the cost. Solution: use cheap models for simple tasks, expensive for complex.

🤷

Responsibility diffusion — when nobody owns a task, nobody does it. Solution: explicit ownership in each agent's SOUL.md.

Real Example: Three Agents in Parallel

Here's a real setup running in production:

📊 Market Analysis Agent (runs 6 AM daily)

Scans Twitter sentiment, pulls price data, generates trading plan. Writes to shared/market-briefing.md. Cost: ~$0.80/day (GPT-4o-mini for scraping, Claude for analysis).

✍️ Content Agent (runs 8 AM daily)

Reads market briefing + trending topics. Drafts 3-5 social posts. Writes to shared/content-drafts.md. Cost: ~$0.50/day (Claude Sonnet).

💡 Idea Validator (runs weekly)

Mines Reddit/Twitter for pain points, validates against market briefings, scores opportunities. Writes to shared/ideas-scored.md. Cost: ~$2/week.

Total cost: ~$11/week for three specialized agents running autonomously. They share a knowledge base but each has private working space. The human reviews outputs for 15 minutes a day.