AI Agent Teams: 5 Patterns for Solo Founders

Tuesday, 11pm. A client LINEs me: “Quote the year-end event? 3 cameras, livestream, drone.” I’m in bed. Phone buzzes once. By morning there’s a draft quote in ~/tzukao_inbox/pending/ with the hourly-rate math already checked against my 2,600 NTD/hr floor. I edit two lines and send. Human time: 4 minutes.

That flow used to eat 45. What changed is not the model. What changed is how the agents are wired. One triaged the message, one drafted the quote, one checked the price, one staged the file for me. Four agents, one job, zero collision. I call this an Agent Team.

I’ve been solo since 2015. Over 18 months I rebuilt my studio into 8 agent departments (creative, social, sales, ops, finance, knowledge, trading, life). The biggest lesson: architecture beats model choice. A GPT-5 agent wired wrong loses to a Haiku pipeline wired right, every time.

This is the technical companion to Solo Stack Method. Solo Stack is the framework (Signal / Strategy / Skill / Ship). Agent Teams are the wiring diagrams inside the Skill layer. Below are the 5 patterns I actually run, when each fits, and the failure mode that will bite you.

Pattern 1: Router-Executor

One dispatch agent classifies the request, then hands off to a specialized worker. The router is small and cheap. The workers are focused and swappable.

When to use it. Inputs are varied but fall into known categories. Client messages, incoming leads, mixed asset requests. Anything where the first real question is “which pipeline does this belong to.”

Studio example. My task-dispatch skill is a router. It reads any prompt, checks 71 skills across 8 departments, declares “this belongs to X department,” then invokes the right worker (quote-brief for pricing, client-feedback for angry clients, crew-dispatch for shoot day staffing). The router is under 200 lines. Workers do the heavy work.

Skill file structure.

.claude/skills/
  task-dispatch/
    SKILL.md          # router logic, decision table
    routing_table.md  # keyword → skill mapping
  quote-brief/
    SKILL.md          # worker
  client-feedback/
    SKILL.md          # worker

Common failure. Routers drift. Six months in you have 30 workers and a router that still thinks there are 12. Fix by making the router read a routing table file, not hardcode the map. Updating the map becomes a one-line change. My meeting-notes-router in claude-code-skill-stack is a production router built this way.

Pattern 2: Pipeline

Sequential stages. Stage N’s output is stage N+1’s input. Each stage has one job.

When to use it. Content production, video breakdown, document processing. Any linear flow where each step needs a different skill.

Studio example. My short video pipeline: media-extract (pull YouTube transcript) → topic-researcher (find the angle) → copywriter (draft script) → de-ai (strip AI voice) → persona-manager (Keng-voice check) → auto-post-router (schedule to IG/Threads/FB/X). Six stages, six agents, one Reels post at the end. I trigger it with one sentence and check back in 20 minutes.

Skill file structure. Each stage is its own skill directory. The orchestrator calls them in order and passes state via files in a scratchpad:

scratchpad/
  {job_id}/
    01_transcript.md
    02_angle.md
    03_script_draft.md
    04_deai_cleaned.md
    05_persona_approved.md
    06_scheduled.json

Numbered files make debugging trivial. When stage 4 goes wrong, I open file 3 and know exactly what stage 4 received.

Common failure. Silent cascades. Stage 2 returns garbage, stages 3-6 process the garbage, you get a garbage post scheduled. Fix by adding a verification gate between stages that either signs off or halts. Fail loud, not silent.

Pattern 3: Panel-of-Judges

Multiple evaluator agents run in parallel, each with a different lens. A synthesizer combines their verdicts.

When to use it. Decisions where you want to protect against single-perspective bias. Take this client? Is this quote fair? Does this campaign concept work? Anywhere “asking one smart agent” gives you a plausible-sounding but shallow answer.

Studio example. When a new lead comes in above 200K NTD, my two-stage-review runs three judges in parallel: a skeptic (why this goes wrong), an hourly-rate auditor (does this clear 2,600/hr), a strategic fit (does this move the yearly target). A fourth agent synthesizes and gives me Go/Hold/Kill with reasoning. I’ve killed deals I would have said yes to on instinct, and taken deals I would have refused because my gut was tired.

For high-consensus moments I also run a tenth-man agent — a dedicated devil’s advocate that only attacks framings with 2+ agents already agreeing. Catches groupthink inside my own agent team.

Skill file structure.

patterns/panel-of-judges/
  judges/
    skeptic.md
    hourly_rate_auditor.md
    strategic_fit.md
    tenth_man.md
  synthesizer.md
  README.md

Common failure. Judges converge because they share context. Fix by giving each a distinct system prompt and identity, and forbid them from seeing each other’s output before the synthesizer runs. Independence is the whole point.

Pattern 4: Loop-Until-Done

A worker produces output. A verifier checks it against a spec. If the spec fails, the loop retries with the verifier’s feedback appended. Max N iterations, then escalate.

When to use it. Quality-critical outputs where “close enough” costs money. Client-facing quotes, contracts, code that ships, translations, subtitles.

Studio example. My quote-pdf skill runs a loop: draft the PDF → verify against 12 checklist items (total math, VAT, delivery date, deliverables list, hourly-rate compliance, keng@tzukao.com in the footer, and 6 more) → if any fail, feedback goes back to the drafter with “these lines are wrong, fix.” Max 3 loops, then it stops and pings me. In 4 months of use, most quotes clear in 1 loop, some need 2, and I’ve had 3 escalations total. All 3 were cases where the client brief itself was contradictory.

Skill file structure.

patterns/loop-until-done/
  worker.md          # drafter
  verifier.md        # checklist runner
  spec/
    checklist.md     # what pass looks like
  orchestrator.md    # runs the loop, tracks iterations

Common failure. Infinite loops when verifier and worker disagree forever. Always cap iterations. Require the verifier to output structured pass/fail, not vibes. Escalate to human when the cap hits. If your verifier can’t articulate a checklist, this pattern won’t work — go to Pattern 5.

Pattern 5: Human-in-the-Loop

Agent drafts. Human approves at a defined gate. Downstream agents execute. The gate is non-negotiable.

When to use it. High-stakes actions where a wrong move costs real money or real trust. Sending emails to clients, publishing to public channels, signing anything, replying to complaints.

Studio example. My outbound sales agent drafts cold emails to a lead list, but the emails land in ~/tzukao_inbox/pending/ as staged drafts. I get a Slack ping. I approve or reject, and the auto-shipper only sends after my thumb goes up. Same for IG DMs, contract clauses, any spend above a small credit threshold. My CLAUDE.md hardcodes the rule: “never auto-send: contracts, LINE messages to important clients, quotes above 50K, new partnerships, money moves, urgent complaints.”

The gate is not a bottleneck if you set it right. Standard IG posts, routine reply drafts, quote drafts under 50K, internal notes — those auto-execute. Only the top 20% of actions hit the human gate. That’s roughly 15 minutes of my day, gating maybe 40 actions.

Skill file structure.

patterns/human-gate/
  drafter.md          # produces staged output
  staging/            # file drop, one per pending item
  approval_hook.sh    # user runs approve/reject
  shipper.md          # executes after approval

Common failure. Gate creep. You approve one thing without reading carefully, then two, then twenty, and the gate is theater. Fix by keeping each item small enough to read in under 30 seconds, and by running a monthly audit where you re-check 10 approved items. If you wouldn’t approve more than 1 today, the gate is broken.

Which pattern for which job

A decision table I keep pinned:

Situation	Pattern
Varied inputs, known categories	Router-Executor
Linear content production	Pipeline
Decisions with bias risk	Panel-of-Judges
Quality-critical output	Loop-Until-Done
High-stakes external action	Human-in-the-Loop

Most real workflows combine 2-3 patterns. My video breakdown workflow is a Pipeline whose stage 4 is a Loop-Until-Done. My lead intake is a Router-Executor whose “high-value” branch triggers a Panel-of-Judges. Composability is where the leverage compounds.

Where to go from here

The 5 patterns above are the load-bearing 20% of everything I run. The claude-code-skill-stack repo has four anonymized production skills from my studio built on these patterns. Star it if it saves you time, fork it if you want to adapt. The claude-skill-starter is a lighter template for a first skill from scratch.

For the strategic layer above these patterns — how to decide what to automate at all — read Solo Stack Method. If you’re evaluating whether this fits your business shape, the framework and ROI calculator live at /en/ai/enterprise.

FAQ

How many agents should a solo founder actually run?

Start with 3-5 total across 1-2 departments. My 8-department setup took 18 months of iteration. Every agent is maintenance cost. Add one only when the same manual task has cost you >2 hours in the last 2 weeks. If it hasn’t, you’re building infrastructure for a problem you don’t have.

Do I need Claude Code specifically, or does this work in ChatGPT/Cursor/other tools?

The patterns are model-agnostic. I run them in Claude Code because the skill file system and subagent invocation are first-class primitives, which makes Pipelines and Panels trivial to wire. You can build the same patterns in any framework with tool use and file I/O. The claude-skill-starter repo shows the file layout if you want to fork and adapt.

Which pattern breaks first when scaled?

Router-Executor. Routers get brittle as the worker count grows past 15-20. When routing errors climb, split one router into 2 domain routers (“sales router” + “creative router”) behind a top-level triage. That’s what I did at month 10.

What’s the cost of running an Agent Team all day?

My 8-department setup runs $8-15 USD/day in API costs, driving 40-60 agent-hours of work. Under $500/month for what used to require a $3,500/month virtual assistant. The math only works because I pick cheap models (Haiku) for routers and verifiers, and reserve expensive ones (Opus, Sonnet) for drafters and judges. Model dispatch is a discipline, not a default.