Skip to main content

Delegation

An agent doesn't have to do everything itself. Delegation lets one agent hand part of a job to another agent that's better suited to it. Unlike work hidden inside a single chat, a delegated worker is a real session you can see: it appears in the sidebar, you can open it, watch it work live, steer it mid-flight, and its result reports back to the chat that delegated it.

How it works​

Every agent with the delegation tool can delegate to itself — a second session of the same agent, working in parallel. Delegating to other agents is what you control: each agent has a Delegation Targets roster in its Configuration page, and departments can wire rosters up automatically from your org structure. From there it's conversational. Ask your assistant to "have the research agent dig into this" and it spawns a worker on that agent:

  • As a chat — the worker is a real conversation in the sidebar. Peek in, add your own guidance, or interrupt it; the worker serves you first and folds your input into what it reports back.
  • As a background task — fire-and-forget work that shows up in the task history.

Workers can delegate onward, run in parallel, and continue across rounds: a follow-up goes back to the same worker with its context intact. If the worker is still busy, the follow-up reaches it mid-turn, and the report it's working on covers it too. Delegation goes one way: the worker's report comes back to the chat that delegated the work on its own, as soon as the worker finishes its turn.

A delegation can also name checks that review the worker's turns. The worker fixes what they find, and if a check still fails, its verdict comes back with the worker's report.

The project dock​

For bigger jobs that split into several parallel lanes, the delegating chat becomes an orchestrator. A dock panel on the chat shows every lane as a live card — who's working, who's waiting on a human, who's done — alongside the project's board file and any app pinned to the project. Delegated workers get an accent in the sidebar so you can tell lanes from ordinary chats at a glance.

Handing over files​

When a job needs it, agents can also pass real files to each other. An agent can send files to the same agents it can delegate to. In an All directions department, for example, a content creator can hand finished assets directly up to its manager. The sender picks the specific files, and they are copied into the target agent's workspace/inbox/<sender>/ folder, never overwriting anything. The target's own sessions find them there. Sending files is deliberately passive — it makes nothing happen by itself; delegating with a prompt is how you make an agent act.

A worker can also attach the files it produced to its result. Copies land in the delegating chat's workspace, and the reply has an Open button for each.

Reading across the team​

Delegation edges also power cross-agent awareness:

  • In your own chats, an agent can read whatever you could see on other agents you have access to: their schedules, task history, sessions, triggers, and notifications. Reading is where it ends — to change another agent, it delegates to it.
  • An agent's scheduled runs (which have no user present) can read the shared activity of the agents on its delegation roster. That's what makes a morning-briefing agent work: its 7am task reads what the team's agents did overnight and summarizes it.

Costs and attribution​

A delegated worker's usage is attributed to the model that actually ran it, and shows up in the same usage views as everything else. Delegations can pin a worker to a specific model, and the lane stays on that model across continues. A follow-up can also move a worker that isn't busy to another model.

Next steps​