Claude Cowork Tutorial: Why Founding Multi-Agent Workflows Is Your Next Move

Introduction

If you have been managing AI one tab at a time, this Claude cowork tutorial will show you how to break the single-task bottleneck that keeps most founders micromanaging every response. When you run a single window, you are the constraint—watching every output and waiting for one task to finish before starting the next. The real leverage comes when you stop opening one tab and start orchestrating a coordinated system of agents that work together.

I have been building this multi-agent approach into my own business for months, and what follows is the exact breakdown I wish I had at the start. I will walk you through the setup, the logic behind the orchestration, the practical wins I’ve achieved, and the mistakes that cost me an entire weekend. By the end, you will have a working mental model and a clear next move, with no prior Claude Code experience required.

Key Takeaways

• A Claude cowork tutorial only matters if you stop treating Claude as a chatbot and start treating it as a workforce with roles.
• Multi-agent collaboration means one orchestrator plus specialist agents, not three copies of the same prompt running in parallel.
• The biggest win is asynchronous work: spawning research, drafting, and review agents while you eat lunch or take a call.
• Most founders fail at multi-agent setups because they skip the shared context layer, so each agent re-discovers the same facts.
• A working setup uses subagents for read-heavy tasks, keeps writes in the main context, and reports back to one human.
• Cost typically drops because cheaper models handle research while only the lead agent runs on premium model tokens.
• Multi-agent is half the picture. The other half is connecting it to your real business data so agents act on facts, not guesses.

What This Claude Cowork Tutorial Covers (and What It Doesn’t)

Let me kill some confusion up front, because the term “multi-agent” gets used to mean four different things, and most of them aren’t what we’re talking about here.

What this isn’t: running ChatGPT in three browser tabs. That’s not multi-agent. That’s you, multitasking badly. Each tab has no idea the others exist. You’re the integration layer.

What this isn’t: a no-code visual workflow with five LLM nodes wired up in a chain. That’s a pipeline. It runs left to right. Each step is blind to what came before unless you manually pass context. Useful for some things, but the agents don’t actually collaborate.

What this is: a setup where one main Claude agent (the orchestrator) decides what to do, then spawns specialist subagents to handle pieces of the work in parallel. The subagents have their own context, their own tools, their own scope. They run, they report back, the orchestrator takes the result and decides what’s next.

The mental model I use is a small team. One project lead who holds the goal in their head. Two or three specialists are doing focused work in their own corners. The project lead doesn’t try to do everyone’s job. They assign, wait, and integrate.

This is what Claude Code makes practical with its Agent tool, and what people loosely call “Claude Cowork” when they’re describing the experience. The Anthropic team has published their multi-agent research, and the pattern they recommend is exactly this: an orchestrator plus subagents, with the orchestrator deciding when to delegate.

A few honest scope limits before we go further. This is a working person’s tutorial, not an academic write-up. I’m not going to compare every multi-agent framework on the market. I’m not going to argue whether agents are “really intelligent” or just statistical pattern matchers. I don’t care. I care about getting work done in my business with less of me in the loop. If that’s what you’re here for, keep reading.

The Three Roles That Make Multi-Agent Collaboration Work

Every working multi-agent setup has three roles. Get one wrong, and the whole thing falls over.

Role 1: The orchestrator. This is your main Claude agent, the one you actually talk to. It holds the goal, breaks the work down, decides what to delegate and what to do itself. It’s the only agent that should be writing to your files or making committed changes. Think of it as the senior person on the team. It coordinates. It does NOT try to do everything.

The orchestrator usually runs on Claude’s strongest model (Opus, in my setup). It’s where the reasoning happens. The premium tokens are justified because this is the decision layer.

Role 2: The specialist subagents. These are the workhorses. Each one has a single, defined job and a limited toolset. A research subagent that reads files and reports back. A code-review subagent that audits a diff. A web-fetch subagent that pulls data from external pages. A search subagent that finds patterns across a codebase.

Subagents typically run on cheaper models (Haiku in mine), which is where the cost savings come from. They do high-volume read work that doesn’t need top-tier reasoning. The orchestrator only burns Opus tokens on the integration step.

The rule that matters most: subagents return summaries, not raw output. If a subagent reads ten files, it doesn’t push those ten files back to the orchestrator. It synthesises and reports the answer. This keeps your orchestrator’s context window clean and useful.

Role 3: The shared context layer. This is the most-skipped piece and the reason most multi-agent setups feel pointless. Your agents need to share a baseline understanding of the business: who the customer is, what’s being built, what the current goal is, and what the rules are.

In my setup, this lives in a folder of context files that every agent reads at the start of its task. Without it, each agent starts from scratch, and you spend half your time re-explaining the project. With it, every agent acts like it’s been with your business for years.

This shared context is the difference between “I’m running multiple Claudes” and “I have an AI workforce.” The first is a tool trick. The second is a system.

A Claude Cowork Tutorial for Your First Multi-Agent Workflow

Right. Hands on the keyboard. Here’s the exact sequence to set up your first working multi-agent flow, using Claude Code (the terminal version), because that’s where the tooling for this is most usable today.

Step 1: Install Claude Code and create a project folder. If you haven’t already, install Claude Code from Anthropic’s site. Create a new folder for your project. This folder becomes the workspace your agents share. Open it in your terminal and run claude to start a session.

Step 2: Build the context layer. Create a file called CLAUDE.md in the project root. This is the file every agent in the project reads automatically at the start of every task. Keep it short. Include:

• Who you are and what your business does (two or three sentences)
• The current goal of this project
• Rules the agents must follow (writing style, banned words, formatting preferences)
• Where things live (folder structure, important file paths)

Mine is about 80 lines. It loads in every session. It’s the single piece of infrastructure that turns Claude from a generic assistant into something that knows my business.

Step 3: Define your first subagent. In Claude Code, you can spawn subagents with the Agent tool. There are built-in types like the Explore agent (read-only file search) and general-purpose (full toolset for multi-step research). For your first run, stick with the built-in Explore agent. Don’t customise yet.

Step 4: Run a delegation prompt. Give the orchestrator a real task that has a natural research phase. Example: “Audit our blog folder. Find every post written in the last 90 days. Summarise the topics. List which clusters are underdeveloped.” That task has clear research work that can be split off.

In your prompt, ask the orchestrator to spawn an Explore subagent for the research, then integrate the results itself. The orchestrator will hand off the file reading, get back a summary, and write its analysis into your context window without bloating it with raw file contents.

Step 5: Watch what happens. This is the moment most founders get a small thrill. You’ll see the orchestrator say something like “I’ll spawn an Explore agent to handle this.” It runs. It comes back with a summary. The orchestrator integrates. Your context window stays clean. You got the same answer at a lower cost in less of your time.

Step 6: Add parallel agents. Once that works, try a task that splits into two independent pieces. Example: “Look at the last 30 days of our marketing analytics AND audit our blog folder. Give me a brief on where the gaps are.” The orchestrator can spawn both agents at once, in parallel. They work simultaneously. You wait once instead of twice.

Step 7: Add scope and rules. Once parallel works, start defining your own subagents. In .claude/agents/ you can create markdown files that define specialist agents (a content reviewer, a copy editor, a research summariser). Each one has a name, a description, a set of allowed tools, and a system prompt. Now your orchestrator has a real team to draw on.

Step 8: Stop watching. This is the test. Once you trust the setup, give the orchestrator a multi-step task and walk away for ten minutes. Make a coffee. Take a call. When you come back, the work is done. That’s when you realise you’ve crossed from “AI tool” to “AI workforce.”

This is the entire core loop. Everything else is variations on it: more specialists, longer tasks, richer context, deeper integration with your actual business data.

The Mistakes That Cost Me a Weekend

I’m writing this section because I made all these mistakes, so you don’t have to.

Mistake 1: Trying to make every agent write to the same files. Two agents both editing the same code file at the same time is exactly the disaster it sounds like. Subagents read. The orchestrator writes. That’s the rule. If you break it, you get conflicting edits, ghost changes and a wasted afternoon working out which version is correct.

Mistake 2: No shared context, so every agent re-discovers everything. I spent a Saturday wondering why my “team of agents” felt slower than just doing it myself. The reason was that every spawn started with zero context. The agents re-read the same files, re-asked the same questions, and re-derived the same answers. After I built the CLAUDE.md file properly, the same workflows ran in a third of the time.

Mistake 3: Using the premium model everywhere. When I first started, I had every agent on Opus because it was “the best.” My cost tripled. The agents weren’t actually better. The work was simple research and summarisation. I switched all subagents to Haiku, and the output quality stayed identical. Cost dropped to a quarter. Match the model to the task.

Mistake 4: Trying to orchestrate too many agents at once. Five parallel agents sound impressive. In practice, it’s a mess. The orchestrator can’t keep track of five streams, and the results stop making sense. Two or three parallel agents are the sweet spot for any single task. If you need more, break the work into stages.

Mistake 5: No human in the loop on writes. Early on, I gave the orchestrator free rein to make committed changes to my codebase. It made changes I didn’t want, and I had to revert. The pattern I settled on: agents propose, I approve. The orchestrator drafts the change. I review. I either accept or send it back. For low-risk changes (formatting, copy edits), I let it run. For anything touching customer data, payment logic, or core business rules, I gate it.

Mistake 6: Treating multi-agent as a magic upgrade. Multi-agent is a multiplier on a well-defined workflow. If you don’t know what you want done, throwing more agents at it makes the confusion faster, not better. The workflow design matters more than the number of agents.

Where This Claude Cowork Tutorial Fits in Your Wider AI Setup

Multi-agent collaboration is one piece of a bigger picture. On its own, it makes you faster at the things you already do with Claude. That’s worth doing. But the bigger win comes when you connect it to the rest of your business.

The model I’ve settled on has two parts: an AI brain and an AI workforce.

The AI brain is the thinking layer. It holds your business context, watches your numbers, and briefs you every morning. When you wake up, your brain has already read every meeting transcript from yesterday, checked your sales pipeline, looked at your financial position, and written you a short summary with two or three decisions to make. You read it over coffee. You make the calls from your phone. The day starts at 7am with you fully informed instead of at 10am after you’ve finished firefighting.

The AI workforce is the doing layer. It picks up the recurring work the brain identifies. Database reactivation. Reply drafting. Lead qualification. After-hours phone answering. Quote follow-up. The things that eat your team’s hours and would happily eat yours if you weren’t careful.

Multi-agent collaboration sits inside the workforce. It’s how the workforce gets fast. A single agent handling a single task is fine. A few orchestrated agents handling a stream of tasks in parallel is where you actually get your time back.

For a sense of what the doing layer looks like in real businesses, my AI automation NZ post walks through the practical applications. For the bigger frame, the agentic workflow guide ties the moving parts together.

One client of mine, a finance broker called James, had 319 dormant contacts in his Nexus database that the team had completely written off. Multi-agent reactivation worked on the database in the background while his team carried on with new business. The result was $49,000 in recovered revenue from people the business had already paid to acquire and then forgotten. That’s what the workforce side looks like when it’s pointed at a real problem.

You don’t need to build all this at once. You don’t even need to build it yourself. But you do need to know what shape it takes, because building one piece in isolation (a single chatbot, a single automation) almost always plateaus. The compounding only happens when the pieces sit in a system.

Conclusion

A Claude cowork tutorial is only useful if it gets you to actually run multi-agent collaboration in your own work, not just understand the theory. The pattern is simple. One orchestrator. A few specialists. A shared context layer. Match the model to the task. Keep a human on the wires. Walk away while the work runs.

The bigger point is that running Claude in one window forever is a choice, not a default. Most founders do it because nobody told them the alternative was practical. It is. The setup takes a couple of hours. The payoff starts the same day. And once you’ve built the muscle for orchestrating a small AI team, the next question writes itself: what part of my business am I still doing by hand that this could be doing instead?

If you want a hand thinking that through for your specific setup, the 30-minute Discovery Call is the easiest place to start. I take fifteen minutes, ask the right questions, and tell you honestly whether a multi-agent setup would move the needle for you or whether the bottleneck is somewhere else entirely. No pitch. Just a straight read on where the time goes and where the AI brain plus AI workforce model would help. Book a Discovery Call here.

Frequently Asked Questions

About Octavius

Titus Mulquiney is the founder of Octavius AI, where he builds AI brains and AI workforces for founder-led businesses stuck running everything out of their own head. Twenty years in marketing, ex-Sony product manager, ex-GM Zeal NZ. Based in Auckland, working with operators across NZ, Australia, and the US. Connect on LinkedIn.