Deploy your first team

By the end of this tutorial you’ll have a team of agents in Clawboo, you’ll have run the one-time “Know Your Team” introduction flow, and you’ll have sent a message in group chat and watched the team leader delegate a task onto the durable board. A team is a named group of Boos (agents) that collaborate in one shared chat room. Clawboo gives you two ways to deploy one: pick a ready-made template from the marketplace catalog (82 teams, 304 agents), or, on the native-first path, let onboarding seed a starter team for you. This tutorial covers both, then walks the same group-chat-and-board collaboration loop that follows either.

​

Prerequisites

​

Steps

​

1. Get a team

You either already have one (from native onboarding) or you deploy one now. You already have a team. During native onboarding you picked a starter team from the marketplace and deployed it (every agent clawboo-native). The wizard’s “Your team is ready” screen was that team’s Meet your team beat, so its group chat opens directly on the introduce yourself step. Skip to step 3 and start from the second screen there; your team already exists. Deploy a template team. The + button in the leftmost sidebar takes you to the Marketplace’s Teams tab (the catalog of 82 teams, 304 agents). Press Deploy on a team card, then customize its name, icon, color, and the runtime each member runs on. You can mix runtimes: a native leader with a Claude Code or OpenClaw specialist, for example. (Prefer a blank team? Use the Start from scratch card on that same tab.) Expected result: the create-team modal advances to a deploy screen: the team icon you picked, animating, above a Deploying heading that carries your team’s name.

​

2. Watch the team deploy

Clawboo now creates the team and its agents in order:

1. POST /api/teams creates the team row (name, icon, color, the template id).
2. For each agent in the template, createAgent writes its four agent files: SOUL.md, IDENTITY.md, TOOLS.md, and a collaboration-protocol AGENTS.md, then POST /api/teams/:id/agents assigns it to the team. The protocol file teaches each agent the team roster and the structured <delegate to="@Name">task</delegate> syntax it uses to route work.
3. If the template defines @mention routing, agent-to-agent coordination is auto-enabled.

The deploy screen tracks this live: a Creating agent name… line names the agent being written right now, and a progress bar under it counts N/M agents. When the last one lands, the screen flips to a check mark and “Team deployed!”, then the modal hands you off. Expected result: after the brief “Team deployed!” beat the modal closes itself and you land directly in your new team’s group chat, with a success toast confirming the agent count. There is no separate “done” dialog to dismiss.

​

3. Run the “Know Your Team” gate

The first time you open a team’s group chat, a one-time onboarding gate fills the window instead of the chat. This is the Know Your Team flow, and it runs once per team. The gate has two phases:

1. Meet your team: a welcome card showing each agent’s avatar and, when Boo Zero (the universal team leader) is identified, a “Led by …” badge. The copy explains that your team is led by Boo Zero, who takes your request and routes it to the right specialist. Click Get Started.
2. Your turn: a textarea asks you to introduce yourself (“your name, what you’re working on, how you’d like the team to help”). Type a short intro and click Continue to Team Space.

A team deployed during onboarding opens straight on phase 2: the wizard’s “Your team is ready” screen already showed you the same Meet your team card, so the gate does not repeat it. Your introduction is persisted to SQLite as the source of truth and injected into the team’s context preamble on every future message, so every agent always sees it, and Boo Zero replies in-character to acknowledge it. Expected result: the gate closes and the settled team space opens, the team’s Ghost Graph on top, the group chat below. You learn what each teammate does by watching the first real task in action, not from a scripted intro round.

​

4. Send a message in group chat

You’re now in normal group chat. Type a request into the composer at the bottom and send it. Your message routes to the team’s leader by default (Boo Zero, or the first team member). To address a specific agent, start your message with @AgentName; the longest-prefix match against the roster wins, and the @mention is stripped before delivery. Expected result: the leader starts responding, its reply streaming live into the transcript with its own avatar and name.

​

5. Watch a delegation land on the board

When the leader decides a request needs hands-on work, it emits a structured <delegate to="@Name">task</delegate> directive in its response. Clawboo’s orchestration engine, which observes every team member’s session, turns that directive into a durable board task; it does not scrape prose for intent. For each delegation, the engine:

1. Creates a board task and atomically claims it for the target agent (a lost claim is a conflict, never retried).
2. Delivers the task to that agent’s session through a non-destructive queue (a busy agent’s task waits for its turn boundary; it never interrupts an in-flight run).
3. Reports the result back when the agent finishes: the task moves to done and a report-up summary lands on the board.

You see this in the chat as a Board task card, a labeled row with a status pill that flips live from Queued to Working to Done, plus the assignee’s avatar and name. The board is the source of truth; the card is a read-only projection of it, so it survives a page refresh. Completed tasks are also batched into a [Task Update] narration delivered back to the leader for synthesis. Expected result: at least one Board task card appears inline in the chat, its status pill advancing to Done, and the leader synthesizes the teammate’s work back to you.

​

What you should see

The settled team space puts the team’s Ghost Graph on top and the group chat below, with Board task cards interleaved into the conversation as delegations land: The Ghost Graph itself renders the team as an org chart, the leader at the top, teammates below, and the @mention routing from each agent’s AGENTS.md drawn as edges:

​

What just happened

Deploying a team created real agent records in SQLite, the registry of record for which agents and teams exist, and wrote each agent’s collaboration protocol into its AGENTS.md, which is what teaches the leader the <delegate> syntax and seeds the Ghost Graph’s edges. The Know-Your-Team gate ran once so you could meet the team and introduce yourself, persisting your introduction so every future message carries it. Then, in chat, the leader’s structured delegation became a durable board task: the server-side orchestration engine derives tasks from typed signals rather than parsing prose, claims each task race-free, and reflects the result back, which is why the work survives a refresh (and a tab close) and the leader is never left waiting on a silent teammate.

​

Next steps

• The board, the durable, race-free coordination substrate behind every delegation
• Delegation and orchestration, how structured signals become board tasks
• Peer chat, how mixed-runtime agents talk to each other as named peers
• Using group chat, the group-chat surface in depth, including the gate
• Tour the dashboard: Atlas, Ghost Graph, and the view modes