How to Build Your Multi-Agent System in Claude in 1 Hour and 6 Steps

By the end of this hour you'll have a working multi-agent system: one coordinator that breaks a task apart, hands the pieces to specialist agents, checks what comes back, and gives you a single finished result.

Follow my Substack to get fresh AI alpha: substack.com/@0xMortyx

Not a chatbot you babysit. A small team you brief once and let run. And you'll build it without writing a single line of code, without a terminal, and without paying for anything beyond your existing Claude plan. The whole thing lives inside the Claude apps you already have.

The trick most people miss: a multi-agent system isn't ten chat windows you juggle. It's one coordinator and a few focused specialists, each doing one job well. Build that shape once and it runs itself. Here's the hour, step by step.

What "agent" means here, honestly: Not a robot running on its own server. In the no-code Claude apps, an "agent" is a focused role you've configured: a clear job, its own instructions, and the right context. The "system" is how you wire those roles together so one coordinates the rest. That's enough to do real work, and you can build it in an hour.

1. Map the Team Before You Build It

Decide the 3 or 4 roles your system needs. This is the whole design.

10 min

Don't open anything yet. First decide who's on the team. A good multi-agent system has a few focused roles that hand off to each other, not one do-everything agent. Pick a real recurring task you do, then name the roles it naturally breaks into.

For content, that's usually: a researcher, a writer, an editor, and a checker. For a different job the roles change, but the pattern holds: each agent owns one stage, and the output of one feeds the next.

DESIGN YOUR TEAM (PEN AND PAPER IS FINE)
Pick one recurring task ("turn my notes into a published post")
List the stages it goes through (research, draft, edit, fact-check)
Each stage becomes one agent with one job
Keep it to 3-4 roles. More than that and you're managing, not building

✓ You have a team on paper: a few roles, each owning one clear stage

2. Build Each Specialist as Its Own Agent

One focused set of instructions per role. This is where the team comes alive.

20 min

Now you create each role. In Cowork, the no-code agent app, you define specialists in plain English: name, one job, and how it should behave. No code, just instructions. (No Cowork? You can do the same with a separate Project per role, each with its own custom instructions.)

The rule that makes specialists work: each one does exactly one thing. A narrow agent with a tight job beats a broad one every time, because it can't drift into the next stage's work.

A SPECIALIST'S INSTRUCTIONS (REPEAT PER ROLE)
ROLE: Researcher

YOUR ONE JOB: gather and organize facts for a post.
- Find the key facts, figures, and sources on the topic
- Output a clean brief: claims + where each came from
- Do NOT write the post. Hand the brief to the writer.

RULES:
- Flag anything you're unsure about instead of guessing
- Keep it to facts, no opinions or styling

Do this 3-4 times, once per role.Writer: turns the brief into a draft in my voice. Editor: tightens the draft, no new facts. Checker: verifies every claim against the brief. Same shape each time, just a different one job.

✓ Each role now exists as its own focused agent, ready to do one job well

3. Connect Them to Your Actual Work

An agent that can't see your stuff is useless. Plug in your real context.

10 min

A multi-agent system that works on generic inputs is a toy. To make it useful, give the agents your real context: your notes, your past work, your tools. In the Claude apps this is Connectors (link your Drive, Gmail, Calendar, Notion and more) plus the files you upload.

Now the researcher can pull from your real sources, the writer can match your past posts, and the checker can verify against your actual documents. Same agents, suddenly working on your world instead of a blank one.

GIVE THE TEAM YOUR CONTEXT
Turn on the Connectors you need (Drive, Notion, Gmail, etc.)
Upload reference files: past work, style samples, source docs
Tell the writer to match the voice in your samples
Tell the checker to verify only against trusted sources you provide

✓ The team now works on your real notes, files, and tools, not a blank page

4. Wire the Coordinator

One agent that takes your brief, delegates to the specialists, and assembles the result.

10 min

This is the piece that turns a pile of agents into a system. The coordinator is the one you talk to. It takes your single brief, decides which specialist does what and in what order, passes each one's output to the next, and hands you the finished result. You stop juggling windows, you brief one agent.

In Cowork you set this up by describing it: the coordinator's job is to route, not to do the work itself. It calls the specialists, in order, and only it talks to you.

THE COORDINATOR'S INSTRUCTIONS
ROLE: Coordinator. You run the team. You don't do their work.

WHEN I GIVE YOU A TASK:
1. Send it to the Researcher, get the brief
2. Pass the brief to the Writer, get a draft
3. Pass the draft to the Editor, get a clean version
4. Pass that to the Checker, get it verified
5. Give ME the final result, plus a one-line note on what each did

Only you talk to me. Handle the handoffs between agents yourself.

✓ You now brief one coordinator instead of running four agents by hand

5. Add a Checker So the System Verifies Itself

The one agent that makes the output trustworthy instead of just fast.

5 min

A team that only produces is a team that ships mistakes fast. The checker is what makes the system safe to trust. Its only job is to verify the final output against the facts the researcher gathered, and flag anything that doesn't hold up. Crucially, it's a separate agent from the writer, because the agent that wrote something is a poor judge of whether it's right.

THE CHECKER'S INSTRUCTIONS
ROLE: Checker. You verify, you don't rewrite.

- Compare every claim in the final draft to the researcher's brief
- Flag anything unsupported, exaggerated, or contradicted
- If something fails, send it back to the Editor with the specific issue
- Only approve when every claim checks out

You did not write this. Judge it like a skeptical outsider.

✓ Nothing reaches you until a separate agent has verified it holds up

6. Run It Once, Then Save It

Give it a real task, watch it flow, then reuse it forever.

5 min

Now run the whole thing on a real task. Brief the coordinator once ("turn these notes into a post") and watch it route the work through researcher, writer, editor, and checker, then hand you the finished piece. The first run is also your test: if a handoff is fuzzy, tighten that one agent's instructions.

Once it works, you never rebuild it. The coordinator and its specialists stay set up. Next time, you just give it a new brief and the whole team runs again.

The payoff:
You spent an hour once. Now every future run of this task is a single brief to one coordinator, and a finished, checked result comes back. That's the difference between using AI and operating a system that uses itself.

✓ A reusable multi-agent system, built in an hour, that runs on one brief

The Honest Limits

So you're not surprised, here's what this no-code build does and doesn't do:

The honest takeaway:You won't get a sci-fi swarm of autonomous robots from an hour of no-code setup. You'll get something better for most people: a small, reliable team that turns one brief into a finished, checked result, built entirely inside the Claude apps you already pay for.