> ## 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.

> [!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](https://vetta.sh/docs/team/coordinator.md#advisor--parses-but-is-not-served).

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 Naive Managed Agents 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](https://vetta.sh/docs/concepts/harness-capabilities.md#two-limits-on-the-second-road) has the matrix.

> [card] [Team reference](https://vetta.sh/docs/team/overview.md)
>
> Full detail on the two coordination mechanisms, the coordinator, roster versioning, the board, and how context and budget flow.

## Two ways they coordinate

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

The same tool has a third shape that is not a team mechanism at all: `send_to_agent` with `wait: false` is a [handoff](https://vetta.sh/docs/capabilities/tools.md#handoffs) — it starts another agent's *own* session on work you have filed and does not wait for it, on that agent's budget, with no coordinator. Any agent whose [`handoffs`](https://vetta.sh/docs/capabilities/tools#handoffs) allow the target may use it, roster or not. Reach for it when the next seat should simply begin, not answer.

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

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.

> [card] [Next: skills](https://vetta.sh/docs/capabilities/skills.md)
>
> Reusable expertise any agent can load.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.