用 Claude 构建你的第一支 AI Agent 团队（完整课程）

Most people are using Claude to answer one question at a time.

Save this :)

A small group of people are using Claude to run an entire team of agents that research, write, code, review each other's work, and ship finished output while they sleep.

The difference between those two groups is not intelligence.

It is orchestration.

A single agent is an assistant. A team of agents is a workforce. One Claude instance answering your prompt is useful. Five Claude instances, each with a defined role, handing work to each other and checking each other's output, is a system that does in twenty minutes what used to take you a full day.

And right now almost nobody knows how to build this properly.

That is the opportunity. Multi-agent systems sound like something that requires a PhD and a research lab. They do not. With the tools available in 2026, you can build your first working agent team this week, with zero machine learning background, using nothing but Claude and a clear head.

Here is exactly how to do it, from the ground up.

First, Kill the Mental Model That's Holding You Back

The reason most people never build an agent team is that they think of Claude as a chat window.

You type, it responds, you type again. That is the consumer experience, and it caps you immediately.

Here is the better model. Think of Claude as a brain you can spin up as many times as you want. Each copy can be given a different job, a different personality, a different set of instructions, and a different set of tools. One copy never has to know what the others are doing. You, the orchestrator, decide who talks to whom and in what order.

That is all a multi-agent system is. It is not magic. It is a group of specialized Claude instances, plus a plan for how work flows between them.

Once that clicks, everything else is just plumbing.

The Three Roles Every Agent Team Needs

Before you build anything, understand the three core roles. Almost every useful agent team is some combination of these.

The Orchestrator. This is the manager. It takes your goal, breaks it into tasks, decides which specialist handles each task, and assembles the final result. It does not do the deep work itself. It delegates and integrates. In a well-built system, this is the only agent you talk to directly.

The Specialists. These are the workers. Each one is narrow and excellent. A research specialist that only gathers and verifies facts. A writer that only turns research into prose. A coder that only writes and tests code. A designer that only produces layout and visual specs. The narrower the role, the better the output, because a focused instruction beats a vague one every time.

The Critic. This is the role almost everyone skips, and it is the one that separates amateur systems from professional ones. The critic's only job is to review the specialists' output against a standard and send it back if it falls short. A team without a critic produces fast garbage. A team with a critic produces work you can actually ship.

Get these three roles right and you have the skeleton of every agent team worth building.

Your Build Path: Five Stages

You do not build a five-agent system on day one. You build one agent, then two, then a team. Here is the path.

Stage 1: Build a Single Excellent Agent

Before you orchestrate anything, you need one agent that does one job extremely well.

Open a Claude Project. This is your walled-off workspace. Drop in the instructions, reference files, and examples that define the job. A Project keeps context isolated so the agent does not get confused by unrelated conversations.

Now write the system instruction. This is the single most important thing you will do in this entire course. A weak instruction produces a weak agent no matter how many of them you stack. A strong instruction defines the role, the standard, the format, and the boundaries.

Here is the structure of a strong agent instruction:

• Role: "You are a research specialist. Your only job is to gather and verify factual claims on a given topic."

• Standard: "Every claim must be supported by a credible source. If you cannot verify a claim, you mark it as unverified rather than including it."

• Format: "Return findings as a numbered list. Each item: the claim, the source, a confidence level."

• Boundaries: "You do not write prose. You do not give opinions. You gather facts and hand them off."

What to Do This Stage

• Pick one real task you do often that involves a clear, repeatable process

• Build a single agent in a Claude Project with a full role/standard/format/boundaries instruction

• Test it on ten real inputs and refine the instruction until the output is consistent

• Save the final instruction as a reusable template

Stage 2: Add a Second Agent and Pass Work Between Them

Now you learn the core move of all multi-agent work: handoff.

The simplest two-agent team is a worker and a critic. The worker produces a draft. The critic reviews it. If it passes, you keep it. If it fails, it goes back with specific feedback.

You can run this manually at first. Open two conversations. Paste the worker's output into the critic. Paste the critic's feedback back into the worker. Watch the quality climb with each loop.

This feels clunky by hand, and that is the point. Feeling the friction teaches you exactly what you will later automate. You will understand viscerally why the handoff format matters, why structured output beats free text, and why a vague critic is worse than no critic at all.

What to Do This Stage

• Build a worker agent and a critic agent, each in its own Project or conversation

• Define the exact format the worker outputs and the critic consumes

• Run five full worker-critic-worker loops by hand on a real task

• Write down every point of friction. Those are your future automation targets

Stage 3: Give Your Agents Tools

An agent that can only talk is a chatbot. An agent that can act is a worker.

This is where Claude's connectors and the Model Context Protocol come in. MCP is an open standard that lets Claude connect to external tools and data sources through a single consistent interface. In practice, it means your agent can read your documents, search your files, query a database, pull from an API, or take an action in another app.

With connectors enabled, your research agent can search the web and read your own files instead of relying only on what it already knows. Your writing agent can pull from a shared style guide. Your coding agent can read your actual repository.

Tools are what turn a clever conversation into real work. The moment an agent can fetch its own inputs and act on its own outputs, you stop being a copy-paste middleman and start being a manager.

A word of caution that the hype crowd skips: an agent with tools can take real actions, so you give it the narrowest set of tools it needs and you keep a human in the loop for anything irreversible. Reading a file is safe. Sending an email on your behalf is not something you let an agent do unsupervised on day one.

What to Do This Stage

• Enable the connectors your agents actually need, one at a time, per conversation

• Give your research agent web search and file access and watch its output quality jump

• Connect one agent to one real data source you use daily

• Test what happens when a tool returns nothing or an error, and instruct the agent how to handle it

Stage 4: Automate the Orchestration

Now you stop being the middleman.

You have felt the friction of manual handoffs. You know the formats. Now you build the orchestrator, the manager agent that does the passing for you.

The orchestrator's instruction looks different from a specialist's. It is about delegation and assembly, not execution:

• "You are the orchestrator. You receive a goal. You break it into subtasks. You assign each subtask to the correct specialist. You collect their outputs. You send drafts to the critic. You return the final assembled result only when the critic approves."

In 2026 you have two clean ways to run this. Inside Claude's agentic tooling, you can set up sub-agents that the main agent spawns and coordinates for parallelizable work, with the orchestrator splitting a job across several workers at once and stitching the results together. Or, if you are comfortable with a little code, you call the Claude API directly, sending the orchestrator's plan to each specialist as a separate request and feeding the responses back in.

You do not need both. Pick the one that matches your comfort level and ship it.

What to Do This Stage

• Write an orchestrator instruction focused purely on delegation and assembly

• Wire it to your existing specialists and critic

• Run one full goal end to end without touching anything between input and output

• Add one rule that pauses the system and asks you before any irreversible action

Stage 5: Make It Reliable and Repeatable

Anyone can get an agent team to work once. Professionals make it work the hundredth time.

This stage is about durability. You add three things.

Evaluation. Build a small set of test inputs with known good outputs. Run your whole team against them after any change. If quality drops, you catch it before your users do. This is the single habit that separates a toy from a tool.

Memory. Give your team persistent context so it does not start from zero every session. With Claude's project memory and the persistent storage now available in artifacts, your team can remember decisions, preferences, and past work across sessions.

Failure handling. Decide in advance what happens when a specialist returns garbage, a tool fails, or the critic and worker get stuck in a loop. A professional system has a defined escape hatch. An amateur one just breaks and you find out from an angry user.

What to Do This Stage

• Build a ten-case evaluation set and run it after every change to your system

• Add persistent memory so the team carries context between sessions

• Define explicit failure behavior for each agent: what to do when inputs are bad

• Set a hard limit on critic-worker loops so the team never spins forever

A Real Example: The Content Team

Let me make this concrete with a team you could build this weekend.

Say you want to produce researched, written, fact-checked articles on autopilot. Here is the team:

The orchestrator takes a topic and a target length. The research specialist searches the web, gathers verified facts, and returns a structured brief. The writer turns that brief into a full draft in your voice, pulling tone from a style guide you connected as a file. The critic checks the draft against three standards: factual accuracy versus the research brief, adherence to your style guide, and structural completeness. If anything fails, it goes back to the writer with specifics. Only an approved draft reaches you.

You give the orchestrator one line: "Write a 1,500 word article on X." Twenty minutes later you get a draft that has already been researched, written, and reviewed twice. You do final edits and ship.

That is not a fantasy. Every piece of that is buildable today with the stages above. The only thing standing between you and that team is sitting down and building it one stage at a time.

The Mistakes That Kill Agent Teams

A few traps catch almost everyone. Skip them and you will move twice as fast.

Building five agents before one works. You will be tempted to design the whole org chart first. Do not. One excellent agent beats five mediocre ones wired together. Earn each new agent.

Vague roles. "Help with research" is not a role. "Gather and verify factual claims, return as a structured list, never write prose" is a role. Specificity is everything.

No critic. A team that only produces and never reviews produces fast, confident garbage. The critic is not optional.

Over-trusting tools. An agent with the power to act needs the narrowest permissions and a human gate on anything that cannot be undone. Speed is not worth a deleted file or an email you did not mean to send.

Skipping evaluation. If you cannot measure whether your team got better or worse after a change, you are not building a system. You are gambling.

The Honest Truth About Multi-Agent Systems

A team of agents will not fix a process you do not understand.

If you cannot describe how a task should be done step by step, you cannot delegate it to agents, because each agent needs a clear instruction and you are the one writing it. The work of building an agent team is mostly the work of thinking clearly about your own process. The agents are easy. The clarity is hard.

But here is what makes this worth it. The people who learn to orchestrate agents are not going to be replaced by AI. They are the ones using AI to do the work of a whole team by themselves. That is the leverage. One person, a clear process, and a team of agents that never sleeps.

The window where building this puts you years ahead of everyone else is open right now.

Six weeks from today you can either still be typing one question into a chat box and waiting for one answer.

Or you can be running a team that works while you sleep.

The difference is whether you start building stage one today.

If you found this useful, follow me @eng_khairallah1 for more AI content like this. I post breakdowns, courses, and tools every week.

hope this was useful for you, Khairallah ❤️