Multi-worker collaboration

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. Both are covered below, alongside the platform-level reach every worker gets automatically.

​

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

​

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.

​

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. Through it, a worker can:

• Invoke and manage applications and workflows — start a run of an existing 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 run, check its state, and take part in it.
• Ask a human a question mid-task — the same Ask-a-Human 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 — 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

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