Playbook · Build an agent team — no code

Build an agent team.

One agent is a helper. Four agents passing work between each other is a workflow. The jump from one to many is where most "agent" content waves its hands — because the moment there's more than one agent, three new design questions show up that you didn't have before. Four design decisions. One worked example. Foundations that apply to every team you'll build after this one.

// A note on currency Built on Claude.ai's Skills, Projects, Connectors, and Memory — current as of May 2026. Agent-team tooling is moving fast. The four design decisions in this playbook will keep applying even when the buttons change. Pairs with Playbook 07 — build the single agent there before the team here.

// Who it's for

Anyone who's built one agent already

// Time investment

~4 hours to build · keep refining

// You'll need

Playbook 07's single agent

// You'll walk away with

A working four-agent weekly pipeline

01 —

// The working example

The weekly digest pipeline.

Every individual contributor has a "what happened this week, who needs to know" job they either do badly or skip. The weekly digest team is four agents that turn that job into a Friday-afternoon review session instead of an empty Sunday-night ritual.

// AGENT 01

The scanner

Reads your project channels, shared docs, and emails from the week. Pulls highlights, decisions, open items.

OUT — structured weekly findings

// AGENT 02

The drafter

Turns the findings into a digest draft in your house style. Lead with what changed, what's next, what's stuck.

IN — findings · OUT — digest draft

// AGENT 03

The tailor

Adapts the digest for different recipients. Short and decisions-led for your manager. Action-oriented for your team. Narrative for a stakeholder.

IN — draft · OUT — tailored versions

// AGENT 04

The scheduler

Drops the tailored drafts into your Monday morning review slot. Reminds you on Friday afternoon if you haven't run the scan yet.

IN — tailored drafts

// Foundation, not novelty

The weekly digest is the worked example. The real outcome of this playbook is the four design decisions below — and those decisions apply to every agent team you build after this one. Board paper pipelines, customer success digests, project status rollups, recruiting pipelines, expense triage. Same four decisions, every time.

02 —

// The four design decisions

Decision one. The split.

Before building any team, decide whether the work actually wants to be a team. Some jobs split cleanly into different agents. Some don't — and forcing the split creates handover failures that wouldn't exist if you'd kept it as one agent used more often.

The first design decision is whether to split at all. A team adds setup cost, handover failures, and review surface. The team has to do something a single agent can't, or it's overhead masquerading as sophistication. The honest test: does the work naturally have different jobs with different inputs and outputs? If yes, split. If no, don't.

// The decision

// Split when

The work is a chain — output of one step is input of the next
Each step needs different tools (one reads, one drafts, one schedules)
Each step has a different shape of "good" — drafting is judged differently than scheduling
You'd benefit from review checkpoints between steps, not just at the end

// Don't split when

The "team" is really one job, you just want to feel sophisticated
The agents would all read the same inputs and produce variations of the same output
You haven't used the single agent enough to know its limits
The handover between agents is harder than just keeping it as one prompt

// Working example · why the weekly digest is a real team

Different jobs

Scanning (find what happened) and drafting (write it up) need different prompting patterns. Tailoring for an audience is different again — same content, different shape per recipient. Scheduling is mechanical. Each step has its own definition of "good".

Different tools

Agent 1 reads channels and email. Agent 2 reads style guides and examples. Agent 3 reads recipient profiles. Agent 4 reads the calendar. No agent needs all four tools. Tool minimisation per agent is a security and reliability win.

Review points

You'd want to see the scan before drafting (to add anything missed) and the draft before tailoring (to fix the framing once, not three times). Splitting creates the natural pause points.

★

// Where you add value

Deciding whether the work actually wants to be a team.

The agent team won't tell you it's overkill. You will. The discipline of splitting only when there are genuinely different jobs is what separates a useful pipeline from a Rube Goldberg machine. When in doubt, default to one agent. Add the second only when the single agent is clearly hitting a limit it can't solve by being smarter.

What does Agent 1 hand to Agent 2 — and in what shape? This is where teams quietly fail. Loose handovers — "give the next agent whatever feels relevant" — produce inconsistent inputs and unpredictable outputs. Tight handovers — a defined shape, a known structure, the same fields every time — make the chain debuggable.

// The principle

Each handover should look like a form Agent 1 filled in for Agent 2. Same fields every time. Missing fields marked Not stated, not invented. A consistent shape that Agent 2 can rely on. Think of handovers as the contracts between your agents — and write them in plain English in each Project's instructions.

// What good handovers look like

// Working example · the handover shapes in the weekly digest team

1 → 2

Scanner → Drafter. A structured findings list. Fields: theme · what happened · who's involved · source · decision/action/FYI. If a theme has no source, the Scanner writes Source: Not found — flag for review. The Drafter never invents context — it only works from filled fields.

2 → 3

Drafter → Tailor. The digest in three sections: what changed · what's next · what's stuck. Each bullet ≤2 lines. Lead-with-the-headline format. The Tailor's job is shape-shifting, not content-changing — same facts, different framing per recipient.

3 → 4

Tailor → Scheduler. A short manifest: recipient · draft length · review-by date. The actual draft attached. The Scheduler doesn't read the draft — it just routes it into your Monday review slot. Tool minimisation again.

// The safety net

// The "don't guess" rule extends to handovers

Per Playbook 01 (Pattern 04) and Playbook 07 (Step 4): each agent's instructions must say "if a field is missing from your input, write Not stated and pass it through — do not infer or invent." Without this rule, errors compound across the chain. Agent 1 guesses, Agent 2 builds on the guess, Agent 3 presents the guess as fact. By the time you see it, the original miss is buried three steps back.

★

// Where you add value

Designing the contracts between agents.

The handover shapes are the architecture of the team. You design them. The agents don't know what the next agent needs — only you know that, because only you see the full chain. Spend time on the handover shapes before you write a single agent's instructions. A clean handover makes the next agent easy to build. A messy handover makes every agent harder to debug.

Once there's a team, something has to decide what runs in what order. Three real options — and for a non-technical team, two of them are mostly fine. The third is where agents start running unattended, and that's a different playbook than this one.

// The three options

// How a team gets orchestrated

Human

You trigger each agent. "Run the scan." Review. "Now draft." Review. "Now tailor." You stay in the loop at every step. Slowest. Safest. Best for the first few weeks of any team. This is where you start.

Chained

Each agent triggers the next at the end of its turn. Scanner finishes, drafts a "ready for drafting" message to you, you OK it, Drafter runs automatically. Faster. Still has review checkpoints. Move here once the handovers are stable.

Scheduled

The whole chain runs on a clock — Friday afternoon, the Scanner kicks off, then the Drafter, then the Tailor, all without you. Fast. Risky without earned trust. Requires Cowork or scripting and isn't the default for this playbook.

// The rule of escalation

// Earn the right to step back

Start with human-triggered. Run the chain manually for at least four weekly cycles. Watch where it fails. Sharpen the handovers. Only then move to chained, with checkpoints. Scheduled is the version where the chain runs while you sleep — and the version where mistakes compound silently. Don't go there until the chain has been boring for two months.

// Working example · how the weekly digest gets conducted

Weeks 1–4

Human-triggered. Friday afternoon, you open the Scanner Project, type "run the weekly scan", read the findings, fix what's wrong, then open the Drafter Project and pass the findings in. Slow but visible. You're learning where each agent breaks.

Weeks 5–8

Chained. The Scanner ends its turn with: "Findings ready. Want me to hand to the Drafter? (yes / fix this first)". You say yes. The Drafter picks up automatically. Same pattern for Drafter → Tailor → Scheduler. You're still the conductor, but you're tapping a baton, not playing every instrument.

Week 9+

Possibly scheduled, possibly not. By now the chain has been boring for two months. If you want to move to a scheduled run via Cowork, you've earned it. If you're happy with chained-with-checkpoints, stay there. There's no prize for going faster.

★

// Where you add value

Deciding when to hand control over.

The agents will run as fast as you let them. You decide the speed. Most professionals get more value from a chain that runs at human speed with full visibility than from one that runs autonomously with hidden failures. Speed isn't the goal — quality drafts you'd put your name on is the goal. Conduct from the front for as long as the chain is still teaching you something.

One agent fails visibly — you see the bad output, you fix the prompt. A team can fail invisibly. Agent 1 quietly drops a finding, Agent 2 builds a clean draft from incomplete inputs, Agent 3 polishes it, and the digest that lands on Monday is missing the most important thing that happened all week. The view is how you stay close enough to the chain to catch this.

// Three things to make visible

// What you need to see, every week

Inputs

What did each agent receive? The Scanner's "I read these channels and these emails" report is your first checkpoint. If a project channel you care about isn't in the list, the chain is already wrong — and you'd never know from the final digest.

Decisions

What did each agent choose? The Drafter chose which findings to lead with. The Tailor chose what to cut for the manager version. Each agent should end its turn with: "Here's what I included and what I left out, and why." That visibility is the difference between trust and blind faith.

Misses

What did each agent flag as uncertain? Per the "don't guess" rule, agents should mark uncertainty rather than smooth over it. The Monday review starts with: "Here are the eleven flagged items the chain wasn't sure about." You decide each one. The chain doesn't decide for you — it surfaces decisions you'd otherwise miss.

// A simple way to keep the view

// The single-page weekly receipt

Ask the final agent (the Scheduler) to produce a short receipt at the end of each run — half a page, no more. Sections: What was scanned · What was included in the digest · What was cut · What was flagged as uncertain · What the chain wants you to confirm. Read this before you read the drafts themselves. The receipt is your view of the whole team in one place.

★

// Where you add value

Keeping the chain visible.

An invisible team is a dangerous team. You design the visibility. The receipt isn't bureaucracy — it's the only thing standing between you and a quietly-degrading pipeline that produces plausible outputs every week while missing the actual signal. Read it. Update the agents based on it. Treat the receipt as the most important output of the team — because over time, it is.

The agents do the chain. You stay the conductor.

03 —

// Common pitfalls

Four ways the team goes wrong.

A team fails in different ways than a single agent. These are the four I've seen most — each one tied to one of the four design decisions. Watch for them in the first month, before they become baked into the chain.

// Pitfall 01

The fake team.

Four agents that all do versions of the same job. Or four agents that should really be one with a longer prompt. The team adds setup, handover, and review surface without earning it. After a month, you stop using it because it's slower than just doing the work.

The fix Re-apply Decision 1. If each agent isn't a genuinely different job with different inputs, different tools, and a different shape of "good", collapse the team back to a single agent. There's no shame in this — a single agent used often beats a four-agent team used reluctantly.

// Pitfall 02

The loose handover.

Each agent improvises what to pass to the next. Some weeks the Drafter gets a structured list, some weeks it gets prose, some weeks it gets a half-finished table. The chain produces inconsistent outputs and you can't tell where the variance came from.

The fix Write each handover as a contract. Same fields every time. Missing fields marked, not invented. Paste the handover shape into both agents' Project instructions — the producer and the consumer — so they share the same expectation.

// Pitfall 03

The runaway chain.

You moved to scheduled or fully-chained orchestration too fast. The whole pipeline runs while you're not watching. After a few weeks something quietly breaks — a stale Connector, a changed channel, a shifted file — and the digest is wrong for a month before anyone notices.

The fix Stay human-triggered or chained-with-checkpoints. There's no prize for going faster. The cost of a wrong digest landing in your manager's inbox every week for a month is much higher than the cost of clicking "go" on Friday afternoon.

// Pitfall 04

The black-box team.

You only see the final output. No receipt, no flagged items, no record of what each agent included or cut. The chain produces a plausible digest every week, but you can't tell what's missing — and increasingly, you stop being able to verify it.

The fix Build the weekly receipt. Sections: what was scanned, what was included, what was cut, what was flagged. The receipt is more important than the drafts themselves — it's the only artefact that lets you keep trust in the team over time.

04 —

// The series so far

Eight playbooks. One stack.

This playbook closes the individual upskilling track. From a single prompt to an agent team in eight steps. Each playbook builds on the ones before — and each one is independently useful if that's all you need.

// 01

Six patterns

The language inside every Skill, agent, and instruction.

// 02

Memory and context

Four layers of what Claude knows. Stop re-explaining yourself.

// 03

Build a Skill

Teach Claude how to do a recurring task. The loop.

// 04

Connect MCP

Give Claude access to the tools and data it needs. The reach.

// 05

Run evals

Know if it works. Earn trust through evidence, not optimism.

// 06

Roll out to your team

Spread capability without becoming the help desk.

// 07

Build an agent

One agent. One job. Five build steps. No code.

// 08 — YOU ARE HERE

Build an agent team

Four design decisions. Foundations for every team you'll build.

Using this in practice?

The weekly digest team is the worked example. The four design decisions are the real takeaway. Split when work has genuinely different jobs. Make the handovers contracts, not improvisations. Conduct from the front for as long as the chain is still teaching you something. Build a view that catches silent failures.

Those four decisions apply to every agent team you'll build after this one — board paper pipelines, recruiting workflows, customer success rollups, project status reports, expense triage. Different content. Same four questions. The foundation travels.

This playbook closes the eight-part series for individuals. The thread running through all of it: AI compresses the work between your decisions so you spend more time deciding and less time typing. The agents do the chain. You stay the conductor. From Playbook 01 to Playbook 08, that's the bargain — and it's the one that lasts when the tooling moves underneath you.

Build an agent team.

The weekly digest pipeline.

Decision one. The split.

When work wants to be a team.

The handover.

The conductor.

The view.

Four ways the team goes wrong.

The fake team.

The loose handover.

The runaway chain.

The black-box team.

Eight playbooks. One stack.

Using this in practice?