Sub-agents & Parallel Work
One conversation can now fan a piece of work out to several workers at once — in a bot chat, in a code session, or in a code session a bot is running — and watch the whole batch move live. Like every Configure My AI capability, it behaves identically on every AI provider you connect: the same tools, the same card, the same guarantees, whatever model is underneath.
A coordinator and its executors
When a bot or a code session deploys sub-agents, the conversation you are in stays the coordinator: it keeps your configured model — that is where decomposing the work and judging the results happens — and it keeps talking to you while the workers run. Each worker is a real, isolated session of its own that defaults to your provider's fast, efficient tier, because executing a well-scoped task (write the file, run the tests, fetch the data) is exactly what that tier is best at. A task that itself needs deep reasoning can be deployed at coordinator grade instead. On a provider with no cheaper tier, workers simply run your configured model — nothing breaks, nothing silently changes quality.
What a worker can do
- In a bot chat: a worker is a sub-agent of your bot (or a named teammate agent) with the same capabilities you granted — it can research, write files, message channels, start its own connected code session, or execute one of your saved tasks on demand. Permissions only ever narrow: a worker can never do anything the conversation that deployed it could not.
- In a code session: a worker is a full child code session on the same repositories — its own branch, its own checkout, its own checks — working one task while its siblings work theirs.
- Machines: when a worker needs a cloud machine (a browser, a place to run something), it leases a temporary one of its own and the machine is destroyed the moment the worker finishes — the same spin-up/close-out discipline web fetches use, so parallel work never leaves idle machines accruing billing.
The live card
Every deploy renders a card right in the conversation: the batch name, how many agents, elapsed time, one cell per worker — pulsing while it runs, green when done, amber if it has gone quiet, red if it failed — and the stage the work is at right now. Open the card to see each worker's current step, its result summary once it lands, and a link to its full session. The card updates in place, in real time, with no refresh.
The Plan pane follows the work
In a code session, deploying sub-agents auto-populates the Plan tab — one step per worker, moving from pending to in-progress to completed as the cells do — and brings the pane forward so you see it happen. In a bot session, the rail's plan panel shows the same batches live.
Results come back into the conversation
Workers report to the conversation that deployed them, as they finish — not in a side channel you have to poll. A bot coordinator is woken with each worker's result and synthesizes as they arrive; a code coordinator receives each report as its next turn, with the same queue discipline as messages you type. You can redirect a worker mid-flight the same way you steer any session — the coordinator has tools to check on and to message each worker by name.
The guardrails
- Contracts, not just tasks: every worker runs under a contract — the task, an optional verifiable done when, and the evidence its report must carry — so workers finish instead of wandering.
- Cost on the card: the batch card and status report show tokens spent per worker and per batch, so fan-out is a number you can see, not a surprise on the bill.
- Bounded fan-out: at most 8 workers per deploy in a bot conversation, 6 in a code session, with hard depth limits so workers cannot recurse into fleets of their own.
- Narrowed permissions: a worker's tool grants are the intersection of the target agent's and the deploying conversation's — delegation can never widen access.
- Metered like everything else: every worker's spend is metered under your workspace with the same billing checks as any other run, and self-check applies to unattended worker runs when you have it on.
- Failure is visible: a worker that fails shows red on the card with its error, and the batch reports partial results rather than pretending.