> ## Documentation Index
> Fetch the complete documentation index at: https://vetta.sh/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Team

> A coordinator agent and a version-pinned roster of specialists, coordinating two ways: point-to-point delegation and a durable shared board.

export const Levers = ({items, cols}) => <div style={{
  display: "grid",
  gridTemplateColumns: `repeat(${cols || 2}, minmax(0,1fr))`,
  gap: "12px",
  margin: "1.5rem 0"
}}>
    {items.map((it, i) => <div key={i} style={{
  border: "1px solid rgba(0,0,0,0.10)",
  padding: "16px 18px",
  background: "#ffffff"
}}>
        <div style={{
  fontSize: "13px",
  fontWeight: 500,
  color: "#777777"
}}>{it.k}</div>
        <div style={{
  fontSize: "15px",
  fontWeight: 500,
  margin: "6px 0 4px",
  letterSpacing: "-0.02em",
  color: "#000000"
}}>{it.v}</div>
        <div style={{
  fontSize: "14px",
  color: "#555555",
  lineHeight: 1.5
}}>{it.d}</div>
      </div>)}
  </div>;

export const Flow = ({steps, note}) => <div style={{
  margin: "1.5rem 0"
}}>
    <div style={{
  display: "flex",
  flexWrap: "wrap",
  alignItems: "stretch",
  gap: "8px"
}}>
      {steps.map((s, i) => <div key={i} style={{
  display: "flex",
  alignItems: "center",
  gap: "8px"
}}>
          <div style={{
  border: "1px solid rgba(0,0,0,0.10)",
  padding: "10px 14px",
  background: s.accent ? "rgba(0,0,0,0.04)" : "#ffffff",
  minWidth: "84px",
  textAlign: "center"
}}>
            <div style={{
  fontSize: "13px",
  fontWeight: 500,
  color: "#000000"
}}>{s.t}</div>
            {s.d ? <div style={{
  fontSize: "12px",
  color: "#777777",
  marginTop: "2px"
}}>{s.d}</div> : null}
          </div>
          {i < steps.length - 1 ? <span style={{
  color: "#777777",
  fontSize: "16px"
}}>→</span> : null}
        </div>)}
    </div>
    {note ? <div style={{
  fontSize: "12px",
  color: "#777777",
  marginTop: "10px"
}}>{note}</div> : null}
  </div>;

<Note>**Available now.** Coordinators, rosters, delegation and the shared board are live. One roster entry type is not: an `advisor` entry parses but is [refused at save](/docs/team/coordinator#advisor--parses-but-is-not-served).</Note>

A **team** is a **coordinator** agent with a **roster** of member agents. The coordinator owns the top-level task and the top-level context; each member runs in its own session with only the context it was handed, and a team may mix harnesses freely below the coordinator.

<Note>**Any published harness can be the coordinator's.** Both mechanisms below are tools Vetta contributes to the coordinator's turn; the `claude_code` and `hermes` harnesses run their own CLI's toolset inside a micro-VM and reach ours over a session-scoped tool endpoint instead. One caveat there: `wait_for_agents` does not pause the turn, so the coordinator parks once the turn goes idle — a few extra model calls, not a wrong answer. [Harness capabilities](/docs/concepts/harness-capabilities#two-limits-on-the-second-road) has the matrix.</Note>

<Card title="Team reference" icon="network" href="/docs/team/overview">
  Full detail on the two coordination mechanisms, the coordinator, roster versioning, the board, and how context and budget flow.
</Card>

## Two ways they coordinate

This is the part to know first. A team has **two** mechanisms, not one, and they are shaped differently.

<Levers
  cols={2}
  items={[
{ k: "Delegation", v: "send_to_agent", d: "Point-to-point, task-shaped, one-shot. The coordinator hands one member a brief; the member runs in its own session and the answer folds back as a tool result. Private to those two, and gone when the run is." },
{ k: "The board", v: "board_read / board_write", d: "Broadcast, durable, many-to-many. Cards with four fixed statuses that outlive every session that touched them, and that every member reads and writes." }
]}
/>

Delegate when the work is bounded and you need the answer back. Use the board when the work is *state* — what the team is trying to do, who holds what, what is stuck on what. The proven pattern uses both: the coordinator puts the plan on the board, then delegates each card.

## The coordinator model

<Flow
  steps={[
{ t: "Coordinator", d: "owns the task", accent: true },
{ t: "Delegate", d: "one bounded brief" },
{ t: "Member", d: "its own session" },
{ t: "Report back", d: "result only" }
]}
  note="Delegation is capped to one level — a member is never handed the delegation tool at all."
/>

## The shape of a team

The roster lives on the coordinator's own config, so a team is an agent you have given a roster:

```typescript TypeScript theme={"system"}
await vetta.agents.update(coordinator.id, {
  expected_version: coordinator.current_version,
  multiagent: {
    type: "coordinator",
    agents: [
      { type: "agent", id: "agt_9f2c…", version: 4 },
      { type: "agent", id: "agt_4a71…", version: 2 },
    ],
    board: true,
  },
});
```

Each member is **pinned by version** — the pin is resolved and written at save — so a team's behavior is reproducible even as its members evolve independently.

## Why delegate, not just a bigger prompt

Delegation is about **context isolation and cost**, not wall-clock speed.

<Levers
  cols={2}
  items={[
{ k: "Isolate context", v: "Members start fresh", d: "A member gets only its brief — the coordinator's long transcript never rides along on every downstream call." },
{ k: "Bound cost", v: "Fewer tokens downstream", d: "Isolated context means cheaper calls, and the coordinator's budget bounds the whole team." },
{ k: "Compose specialists", v: "Reuse by id + version", d: "A specialist's persona, tools, and skills are reused wholesale rather than re-prompted." },
{ k: "Mix harnesses", v: "Per-member cost", d: "A member's harness is its own, and it decides what that member holds while it runs — a machine, or nothing at all." }
]}
/>

<Card title="Next: skills" icon="book" href="/docs/capabilities/skills">
  Reusable expertise any agent can load.
</Card>