# Building an agent team: multiple Smith agents that hand work to each other

> How to split work across multiple Smith agents: one role each, three team patterns, and handoffs in Slack and email with people approving key steps.

- URL: https://www.smith.seattlecompute.com/blog/agent-teams
- Published: 2026-10-14
- Type: guide
- Topics: AI agent team, multi-agent workflow, AI agent handoffs, AI agents in Slack, agent orchestration
- Publisher: The Seattle Compute Company (Smith, https://www.smith.seattlecompute.com/)

One agent that does everything ends up doing nothing well. Its role gets vague, its accounts get broad, and when something goes wrong it's hard to tell which part of the job failed.

Teams of people solve this by splitting the work: a sourcer finds candidates, a recruiter screens them, a coordinator schedules. Smith agents work the same way. Each agent gets **one role**, **only the accounts that role needs**, and **clear handoffs** to the agents before and after it. Because every agent has its own Slack handle, inbox and trace, you can see exactly which one did what.

This guide covers how to split the work, the three team patterns that cover most workflows, and how to write handoffs into each agent's role so the team runs without you prompting each step.

## When to split into multiple agents

Split a job into separate agents when:

- **It needs different accounts.** Research that reads with the agent's own account and outreach that sends from yours should be different agents. The agent that sends as you should have the narrowest possible job.
- **It has a natural review point.** If a person should approve the output of step 2 before step 3 happens, that's a good boundary between agents.
- **The steps run at different times.** Something that runs every morning and something that runs when a ticket arrives are different agents.
- **You'd want to know which step failed.** Separate agents give you separate traces.

Keep it as one agent when the steps are small, use the same accounts, and always happen together.

## Three patterns

### 1. Pipeline

Each agent does one step and hands off to the next. The most common pattern.

```text
Researcher ──▶ Screener ──▶ (you approve) ──▶ Outreach
```

Example: a sourcer finds candidates, a screener scores them against the brief, you approve the shortlist, and an outreach agent sends connection requests from your account.

### 2. Lead and specialists

A lead agent takes requests, splits them up, assigns parts to specialists, and puts the results together.

```text
              ┌──▶ Market researcher ──┐
You ──▶ Lead ─┼──▶ Founder researcher ─┼──▶ Lead ──▶ You
              └──▶ Technical reviewer ─┘
```

Example: in a venture team, an analyst lead receives "diligence on Acme," hands founder background, market and technical review to three specialists, and assembles the memo.

### 3. Maker and checker

One agent produces something and a second agent checks it before a person sees it.

```text
Drafter ──▶ Checker ──▶ You
```

Example: a support agent drafts a reply, and a checker agent verifies every claim in the draft against Stripe and the docs before it's sent for approval.

You can combine patterns. A pipeline step can have a checker, and a lead can run a pipeline.

## How agents hand off

Agents hand off the same way people do: in Slack or by email.

- **A channel per workflow.** Put every agent in a workflow into one channel (#backend-search, #deal-flow, #support-queue). Handoffs happen there, so you can see the whole workflow in one place.
- **Tag the next agent.** When an agent finishes, it posts the result and @-mentions the next agent with what it needs to do.
- **One thread per item.** Each candidate list, company or ticket gets its own thread, so the context stays together as it moves between agents.
- **Approvals are a reply.** When a step needs a person, the agent tags the person and waits. A reply of "approved" (or "approved 1–5, 8") passes the work on.

Write all of this into each agent's role, so it happens without you telling them each time:

```text
Handoffs:
- Take work from: @maya, when she tags you with a candidate list.
- When done, post the shortlist in the same thread and tag @avi
  for approval.
- When @avi replies "approved", tag @iris with the approved names.
```

## Writing a good handoff

The receiving agent only knows what the handoff tells it, plus its own role. A good handoff message includes:

1. **What's being handed off**: the list, the brief, the ticket.
2. **What was already done**, so the next agent doesn't repeat it.
3. **What the next agent needs to do**, in one line.
4. **Anything unusual**: gaps, things that couldn't be verified, open questions.

Tell each agent to hand off in this format in its role, and the threads stay readable for people too.

## Guardrails for teams

- **One owner per action.** Only one agent should be able to send messages from a given account. If two agents both have your LinkedIn, you lose track of who sent what.
- **People gate the irreversible steps.** Put a human approval before anything that sends as you, spends money, or can't be undone.
- **Stop loops.** In each role, add: "If work comes back to you more than twice, stop and tag @[person]." Agents disagreeing with each other should end in a person, not a loop.
- **Separate accounts per agent.** Give each agent its own accounts where you can, so the trace shows which agent did what.
- **Start with two agents.** Get one handoff working well before adding a third.

## Examples by team

Each of these guides sets out a full team, with the role for every agent:

- [Recruiting with Smith](/blog/recruiting-with-smith): sourcer, screener, outreach
- [Venture capital with Smith](/blog/venture-capital-with-smith): scout, analyst lead with specialists, connector
- [Engineering with Smith](/blog/engineering-with-smith): ops watcher, triager, researcher
- [Customer support with Smith](/blog/customer-support-with-smith): intake, resolver, checker, insights
- [Forward-deployed engineering with Smith](/blog/fde-with-smith): one agent per customer, plus prep and reporting

## Next

- [Hiring an agent: write the role once](/blog/writing-agent-roles)
- [Research, then act](/blog/research-then-follow-up)

---
Site index for LLMs: https://www.smith.seattlecompute.com/llms.txt