AI agent orchestration: how to build a team of agents

What you're going to build

A main agent will take a goal, split it up and ask three specialists for specific pieces. Then it will pull their contributions together into a final output. For this guide, the practical case is building a website:

• seo-reformas — researches search intent and prepares the mini SEO brief.
• constructor-web — turns the brief into the site's structure and technical plan.
• auditor-web — reviews SEO, user experience and validation points.

You need: access to the hablo Customer area, to Orchestration and to OpenClaw Control; a main agent; clear roles for the specialists and a simple case to test with.

1. Define the result before the agents

Start with a concrete output. In this example: generate a complete website from a minimal brief. The main agent shouldn't do everything; it should coordinate, delegate and check.

• What the main agent will receive.
• Which pieces of work can be split off.
• What format the final result will have.

2. Go to the Orchestration section

Open the Customer area and go into Orchestration. This screen is the team's blueprint: here you define the specialists that will work with the main agent.

You're not creating separate chats. You're creating a working and communication structure.

3. Create each specialist with a stable identifier

Add the specialists one by one. The identifier is the internal reference that connections and delegated tasks will use: keep it short, descriptive and free of needless changes.

Avoid: vague names like "agent2", generic descriptions, or mixing several incompatible responsibilities into the same specialist.

4. Telegram: only if you need it

Telegram isn't needed for the agents to work with each other. Use it if you want to talk to a specialist by hand or run direct tests.

• Automatic orchestration: not needed.
• Talking to each agent by hand: can be useful.

5. Decide who can talk to whom

In the communication matrix, switch on the flow between the main agent and each specialist. This set-up uses two-way communication: the main agent sends jobs out and gets answers back.

Governance: a specialist contributes data and suggestions; the main agent keeps the responsibility for coordinating and deciding. Spell that out in their instructions.

6. Open each agent's session in OpenClaw

From hablo, press Talk to my agent. In OpenClaw, open each specialist and go through its context files. Do it agent by agent: the technical structure is already there, but you still have to give it working judgement.

7. Fine-tune each specialist's SOUL

Go through SOUL.md, AGENTS.md, TOOLS.md, IDENTITY.md, USER.md and HEARTBEAT.md. In practice, SOUL.md is what defines the role, the limits, the way it answers and the collaboration expected.

Check: read the instructions of two different agents and it should be clear, without looking at their names, which one does SEO, which one builds and which one audits.

8. Choose each agent's AI model

At the bottom of the chat, open the model selector and pick the right LLM. That decision affects both quality and cost — if you want the price detail model by model, it's in our guide to credit.

1. Go into the agent's chat.
2. Open the selector next to the composer.
3. Pick the model.
4. Check that its name is showing.
5. Repeat the check on every agent.

9. Prepare a small, checkable test

Don't start with a huge project. Use a request that lets you check how the responsibilities are shared out. The example asks for a website for a fictional employment lawyer, Clara Vidal.

10. Watch how the main agent shares out the job

When you launch the orchestration, the main agent reads the goal and divides the work up:

• SEO — mini brief on search and content.
• Build — technical plan and page structure.
• Audit — checklist and risks.

11. Demand a final integration, not three loose answers

The value shows up when the main agent gathers the contributions and returns them as a single, clear, checkable output. The example uses a table to compare each contribution and decide the next step.

12. Review and iterate: one thing at a time

A first answer that works doesn't prove the architecture is solid. Repeat the case with variations and find where it breaks:

• If it delegates badly, clarify responsibilities and when each one is used.
• If an answer is vague, pin down the output format.
• If the main agent follows suggestions it shouldn't, reinforce its role as coordinator.
• If the cost or the quality doesn't fit, review the model you picked.
• If the result doesn't come together, ask explicitly for a final synthesis.

13. Final check: your system is ready when you can tick all of this

• The goal and the final format are defined.
• Each specialist has a distinct job.
• Identifiers and descriptions are clear.
• The matrix allows the flow you need.
• The SOUL spells out role, limits and output.
• The model has been checked in every chat.
• The test shows real delegations.
• The main agent integrates and reviews the answers.

Expected result: you stop having one AI trying to solve everything and move to a coordinated system where each agent contributes one specific piece.