> ## Documentation Index
> Fetch the complete documentation index at: https://docs.corbits.dev/llms.txt
> Use this file to discover all available pages before exploring further.
# The Corbits Code fleet
> How Corbits Code dispatches specialist agents, enforces their authority tiers where tools are assembled, and lets you steer workers mid-run.
Ask for something substantial and Corbits Code does not attempt it alone. It classifies the work, dispatches specialists, and synthesizes what they send back. Ask for a feature and an implementer goes and builds it while a reviewer reads what came back. Ask for a survey of an unfamiliar tree and an explorer goes and reads it, unable to change a line while it does.
This page describes **Corbits Code**, the app. It does not describe credentials or grants held by the control plane, and it does not speak for the shared agent runtime.
Two words are worth separating before the rest makes sense.
A **director** is a role definition that ships with Corbits Code: one job, an explicit list of work it must refuse, a system prompt, a tool envelope, an authority tier, and the shape of report it owes back. An **agent** is a running instance. Your session is one. Every specialist it dispatches is another. Directors are what agents are made from, and they do not change while you work. ([`director definitions`](https://github.com/corbitsdev/corbits-code/blob/main/src/agent/directors/types.ts); [`director registry`](https://github.com/corbitsdev/corbits-code/blob/main/src/agent/directors/registry.ts))
On the [Corbits Code overview](/platform/corbits-code/overview), a **reactor director** governs event-loop policy, while fleet directors define dispatchable roles and their authority. Corbits Code composes both in a session. Where this page says "director" on its own, it means a fleet role. ([`event-loop policy`](https://github.com/corbitsdev/corbits-code/blob/main/src/agent/reactor-events.ts); [`director definitions`](https://github.com/corbitsdev/corbits-code/blob/main/src/agent/directors/types.ts))
## Authority is a tier, not a prompt
Every director carries one of three tiers, and the tier decides what it may do to the rest of the tree.
Tier 1, the primary agent. Full fleet control over the whole tree.
Tier 2. May manage only its own descendants, never a sibling and never anything above it.
Tier 3, the workers. Each carries an explicit tool allowlist sized to its job, finishes with a report envelope, and mounts no fleet verbs at all.
The check runs where tools are assembled, not in prompt wording. That is what makes the tiers worth anything: a reviewer that cannot write is not a reviewer that has been asked nicely not to, and no amount of conversation hands a leaf a fleet verb it was never mounted. Same pattern as the [safety middleware](/platform/corbits-code/steering-and-safety), one layer owning the constraint.
## Picking a specialist
Dispatch by intent and take the default, or name a director directly. `implement` defaults to **build**, `explore` and `plan` default to directors of the same name, and `review` defaults to **critique**. Naming an id that is not registered fails with the list of valid ones rather than quietly falling back to something general.
The shipped fleet is a **closed set**, and its names are reserved. A **profile** is the general shape a dispatchable role takes, the same job/prompt/tool-envelope/tier/report-shape as a director, just not in that closed set. Roles of your own are still yours to add, as profiles, from a plugin or your project tree. What you cannot do is take a director's name: a profile whose id collides with a shipped director is skipped at load, so a director can never be quietly replaced by something wearing its id.
## Working a live fleet
Workers are sessions you can steer, not fire-and-forget calls.
| Verb | What it does |
| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `spawn_agent` / `wait_agents` | Start workers and collect them. These replace the older fused `task()` call, which still works but is deprecated. |
| `send_input` | Steer a worker mid-turn. By default the message is delivered into the live session, or answers a question the worker is waiting on, and returns without waiting for a reply. With `interrupt: true` it stops the current turn and queues the message as the next one. |
| `interrupt_agent` | Stop waiting on a worker's turn and mark the session interrupted, keeping its context. A tool call already in flight keeps running. |
| `resume_agent` | Start the next turn on a retained worker that has finished or been interrupted, returning immediately so `wait_agents` collects it. |
| `close_agent` | Tear a session down, under a cleanup deadline so a wedged worker cannot hang the call. |
| `read_agent_trace` | Read a worker's trace to see what it actually did. |
| `search_agents` | Find spawnable directors and profiles by capability, role, or team name, so you can dispatch a specialist without knowing its id. Primary session only. |
## How a run ends
A worker runs until it produces a **report envelope**: a structured Summary, Findings, Blockers, and Paths. Short of that, it stops for one of four recorded reasons. It was cancelled by the operator, it hit an opt-in wall-clock deadline, it stalled after a long silence with no tool activity, or it narrated an answer instead of writing an envelope. ([`director definitions`](https://github.com/corbitsdev/corbits-code/blob/main/src/agent/directors/types.ts); [`director tool sets`](https://github.com/corbitsdev/corbits-code/blob/main/src/agent/directors/tool-sets.ts); [`worker lifecycle`](https://github.com/corbitsdev/corbits-code/blob/main/src/agent/director.ts))
None of those is a turn count. Turn budgets were removed outright, including the `maxTurns` setting, the per-director cap, and the argument on the dispatch tools. A worker is bounded by the clock, by its own completion, or by you, and never by a number of inference passes it was allowed to spend.
***
## Support
Join hundreds of developers building with Corbits and speak with the team directly.