Skip to main content

Sub-agents & delegation

For bigger tasks, an agent can hand work to another agent — a coordinator splits the job, the specialists do their parts, and the coordinator combines the results. Kaizen calls this delegation, and you control it.

Your roster, per agent​

For agents you create or configure, delegation is off by default. For each agent you use, you choose which other agents it may delegate to. A persona, an administrator default, or a model cannot add a new delegation edge.

Protected built-in agents can ship with a small, source-reviewed roster. For example, Default can hand a public or current research gap to Web Researcher. That edge is part of the reviewed agent definition, is visible in the composer, and can be turned off for one prompt. It is not a hidden deployment-wide grant, and an unavailable specialist simply removes the path.

Those reviewed edges are the defaults, not the limit. Under Sub-agents in the composer's Add to chat menu, Default lists every chat agent you can use — including agents you built yourself — and you add the one you want for this chat. So when your own agent is the right specialist, you hand the work to it instead of switching agents and losing the thread.

Adding one grants nothing new: the agents you can add are the ones you could already open and run directly, Kaizen re-checks your access to the target at the moment of the hand-off, and the child still runs at the lower of the two agents' capability ceilings. Nothing is delegable until you add it, and adding it applies to that chat rather than writing a standing grant.

Some agents keep a fixed roster on purpose. Agent Builder, for instance, may hand work only to Package Creator; that reviewed pair is the whole list you can choose from.

Fanning work out to the same agent​

An agent can be its own sub-agent. Add it to its own list and it can hand itself slices of a job — the same analysis over four documents, one child run each — instead of grinding through them in a single reply. Each slice is a real child run you can watch and read separately.

This does not recurse. A delegated agent cannot delegate again, so a fan-out is one level wide and one level deep no matter which agent you pick, including itself.

Kaizen considers what you are asking it to do now, not just the nouns in your message. A follow-up such as “turn this research into a presentation” starts with the research already in the chat instead of forcing the same handoff again. The coordinator can still retrieve more when the deliverable needs missing detail, fresher evidence, or better grounding. Ask for current updates, new sources, or another search when that retrieval is itself part of your request.

Your choices are per member and per agent: they do not leak into another agent, and they do not change anyone else's.

How an agent knows what exists​

Every eligible chat agent gets a shared roster capability. Instead of stuffing the full agent list into every prompt, the agent can ask for it when the question calls for it — "what other agents are available?" — and receives only the member-safe roster you have made available to it.

That roster also tells the agent which of those it may hand work to on this turn, so it can say plainly that an agent exists but is not added to this chat yet — rather than promising a hand-off that then fails, or denying one you have already enabled.

The roster is infrastructure shared by every agent, not a special feature of one persona.

What delegation inherits​

A delegated turn is still your turn. It runs under:

  • your identity and permissions,
  • the same budgets — delegation does not buy extra token or time allowance,
  • the same guardrails, approvals, and write guard,
  • the same audit trail.

A sub-agent cannot exceed what you are allowed to do, and it cannot exceed the capability ceiling of the agent that called it. Delegation redistributes work; it never escalates authority.

Typed handoffs and evidence​

Each sub-agent receives a versioned task envelope: one objective, the exact task identity, bounded prerequisite results, and the result contract Kaizen expects back. The envelope has a digest, so recovery cannot silently substitute a different objective or dependency payload.

A completed child result is also typed and digest-bound. Kaizen records the exact answer digest and attaches only citations and artifacts observed during that child run. The coordinator sees those evidence bindings and whether the result is grounded; it never receives hidden reasoning or raw tool output.

This is provenance, not an automatic truth score. A result with no observed source remains visibly ungrounded, and a citation proves where a claim came from rather than guaranteeing that the claim is correct.

Watching it happen​

When a turn delegates, Kaizen shows the orchestration as it runs: which sub-agents were invoked, what each was asked, and how their results folded back into the answer. You can open the trace for a completed orchestration, and resume or cancel one that is still running.

The completed card keeps the child agent's full answer. Kaizen may use a shorter, readable projection when it hands that result back to the coordinator, but that internal context limit does not clip what you can read.

When delegation helps​

  • Genuinely separable sub-tasks — research three vendors, then compare.
  • Specialist knowledge scopes — one agent scoped to security runbooks, another to the deployment docs.
  • A different persona for one step — draft with one, review with another.

When it does not​

  • A single, well-scoped question. Delegation adds latency and coordination overhead. One good agent beats a committee.
  • As a workaround for a missing tool grant. If the agent needs a tool, grant it the tool.
  • To get around a budget. It will not; the budget is per turn.

Turning it off​

Deselect an optional sub-agent and its delegation path closes for that agent immediately. Deselect any roster entry in the composer — a reviewed default or one you added — to close it for that prompt. There is no separate teardown and no per-turn routing grant that outlives the turn.

For how delegation is implemented and bounded inside the runtime, see Sub-agents & orchestration internals.