> ## Documentation Index
> Fetch the complete documentation index at: https://docs.cogniagent.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Multi-worker collaboration
> How a worker delegates to another worker, spins up a helper team for parallel work, and reaches across the platform.
A worker rarely has to do everything itself inside one task. It can hand off a piece of work to another worker, split a big job across a short-lived team of helpers, or reach out to run an application, workflow, or conversation elsewhere in the workspace.
## Two ways to bring in help, at a glance
Cowork gives a worker two different collaboration mechanisms, and they solve different problems.
| | Delegate to another worker | Spawn a helper team |
| --------------- | ------------------------------------------------------------------------ | ------------------------------------------------------------------------ |
| Who it calls | A different, named worker in the workspace | Unnamed, short-lived helpers, each given a role |
| Where it runs | Its own task, in its own sandbox | Inside the same task, sharing its sandbox and files |
| What comes back | The other worker's full result, logged as a delegation in the transcript | A summary from each helper; the parent keeps working with the results |
| Depth limit | About three hops, so delegation chains can't loop forever | One level — a helper can't spawn helpers of its own |
| Good for | Handing a sub-job to a specialist colleague that already knows the job | Splitting one task into independent pieces that can run at the same time |
Both are covered below, alongside the platform-level reach every worker gets automatically.
```mermaid theme={null}
flowchart LR
A[Worker A
running a task] -->|delegate to worker| B[Worker B
new task, own sandbox]
A -->|spawn a helper team| C[Helper subagents
same task, shared sandbox]
A -->|CogniAgent connection| D[Applications / workflows
and Conversations]
D -->|invoke worker: execute-worker node| A
```
## Delegate a piece of work to another worker
When a task calls for a different skill set — handing research off to a research worker, or a draft off to a writing worker — a worker can delegate to another worker in the same workspace instead of trying to do the job itself.
The worker names which workspace colleague should take the sub-job, along with the goal and any context it needs — the child doesn't have to guess what the parent already knows.
The target worker gets its own task with its own sandbox, its own skills, capabilities, and memory — the same as if a person had started it. This keeps the two workers' work cleanly separated.
It runs like any other task, either waiting for the caller (the delegating worker pauses until it has an answer) or reporting back once it finishes.
The parent worker's task shows the hand-off as a delegation event, so you can see that work happened elsewhere without having to go find the other task yourself.
Control returns to the worker that started the delegation — it stays the one deciding what happens next, which keeps a chain of hand-offs auditable instead of turning into a tangle of workers calling each other unpredictably.
Delegated tasks are private to the same workspace, not to a second person — a delegation is the delegating worker's own sub-work, not something a teammate started, so it doesn't cross the usual task-privacy boundary. It bills the same workspace as the rest of the work.
### The delegation depth cap
To stop a delegation chain from looping forever — worker A calling worker B calling worker A again — delegation depth is capped at about three hops. Once a chain hits the cap, it can't delegate further; it has to finish the job with what it has. This is a safety limit, not a setting you configure per worker.
## Spin up a helper team for parallel work
Some jobs don't need a different worker — they need more hands on the *same* job at the same time. For that, a worker can spawn a short-lived team of helper subagents inside its own task, each one given a role and a slice of the work:
* **Researcher** and **reviewer** helpers read but don't write — good for gathering information or checking work.
* **General** helpers cover everyday read-only steps.
* **Coder** helpers can also write and edit files, when the slice of work needs it.
Unlike delegating to another worker, a helper team shares the parent task's sandbox and files instead of getting a sandbox of its own — they're all working the same job, in parallel, not handing it to a separate colleague. The team's progress streams into the task's activity timeline as it runs, so you can watch each helper's status and expand into its steps; when a helper finishes, only its final summary feeds back into the parent's work — the helper's own back-and-forth doesn't clutter the main conversation.
A helper can't spawn a team of its own — that's the depth limit for this mechanism: one level of fan-out, so a task can't spiral into helpers spawning helpers.
This is the shape to reach for when a task decomposes cleanly — a research worker fanning out to read several sources at once, or a review pass checking a piece of work from a few angles in parallel — rather than when the job genuinely belongs to a different, specialized worker.
## Reach across the platform
Every worker also gets a connection to the rest of CogniAgent automatically, with nothing to configure — the same always-on connection covered in [Capabilities & connections](/cowork/workers/capabilities). Through it, a worker can:
* **Invoke and manage applications and workflows** — start a run of an existing [application](/applications/create-application) and use its result, or read and adjust its graph, the same way a person would from the Applications area.
* **Invoke and manage conversations** — start a [Conversation Flow](/conversation-flows/overview) run, check its state, and take part in it.
* **Ask a human a question mid-task** — the same [Ask-a-Human](/cowork/collaborate/human-in-the-loop) mechanism, initiated directly by the worker.
Handing work to an application or a workflow is the deterministic counterpart to delegating to another worker: instead of a colleague deciding how to approach the job, it runs a fixed graph of steps and hands back whatever that graph produces.
### The other direction: a workflow calling a worker
The reach also works in reverse. You can invoke a worker as a step in an [Application workflow](/applications/create-application) — the **execute-worker node** — picking a worker (and optionally an existing task to keep using), passing it a prompt, and getting back its result, including any files it produced. This is what makes patterns like "a workflow triggers a worker to draft something, then continues with the draft" possible without a person in the loop.
## Cross-organization agent interop
Agent-to-agent interop across *different* companies' platforms — the **A2A (Agent2Agent)** protocol — is on the roadmap, not available today. Everything above (delegation, helper teams, and platform reach) already covers collaboration within your own workspace.
A2A is an open, vendor-neutral standard for agents built by different companies to discover each other and hand off work, with its own task lifecycle, streaming updates, and authentication. It earns its keep once workers need to collaborate with agents outside CogniAgent entirely — a different vendor's agent, a different organization's platform — where you don't control both sides of the conversation.
Inside a single workspace, on a single platform, that overhead isn't needed: internal delegation and helper teams already give workers a supervised, auditable way to bring in help. If cross-organization collaboration becomes a real need, it's designed to layer on as an addition rather than a rewrite — the same task and result shapes used internally map cleanly onto A2A's.
## Next steps
See how Ask-a-Human and approvals pause a task for you.
Understand the always-on connection that powers this reach.
See where delegation and helper teams fit into a worker's turn.
Revisit what makes up a worker before you start delegating to one.