Managers
A manager (shown as a Multi-Agent in the builder) orchestrates a team of agents. Given a request, it breaks the work into subtasks, delegates each one to the best-suited agent from its pool, and synthesizes the results into a single answer — possibly over several rounds of delegation.
What it's for
A single agent works best with a focused job and a modest toolset. When a workflow spans several distinct capabilities — say, researching a customer, drafting a proposal, and updating your CRM — a manager lets you keep each capability in its own specialist agent with tight instructions, and puts one coordinator in front of all of them. Callers (a chat user, a phone number, an embed, or the API) talk to the manager; the manager decides who does what.
Navigating here
From the dashboard sidebar, open Agentic Workflows → Multi-Agents. The list has the usual ownership tabs (Owned By Me / Shared With Me / Company Wide) plus search and filters. Create Multi-Agent starts a new one — like agents and tools, the name allows letters, numbers, and underscores (no spaces), and the description should say what workflow this manager orchestrates.
Key concepts
The delegation model
Under the hood, each agent in the manager's pool is exposed to the manager's model as an invoke_<AgentName> function whose main argument is the task to assign. A run proceeds as a loop:
- The manager reads the request (and its own instructions) and delegates a task to one or more sub-agents.
- Each sub-agent runs its own conversation with its own tools, plus two injected signal tools: Complete (report back a summary of what was accomplished) and Help (report that it's stuck — what it needs and what it already tried).
- The manager reads each result. A Complete feeds into its synthesis; a Help prompts it to supply the missing information or hand the task to a different agent.
- When all subtasks are resolved, the manager composes the final response.
This is why sub-agent descriptions matter so much: they're what the manager reads when deciding where to delegate. An agent whose description clearly says when it's useful gets the right tasks.
The manager definition
A manager's editor mirrors an agent's: a Model Type (the model that plans delegations and synthesizes results), Instructions (delegation rules, ordering, and how to combine outputs), Prompt Variables referenced as @@{variable_name}, tags, and an optional Voice Model / Voice Name for spoken interactions — including custom voices.
The agent pool
The Agents section holds the sub-agents this manager can delegate to. Import existing agents or create a new one in place. Each should cover a distinct capability — overlapping agents force the manager to guess.
When to use a manager vs. one agent with many tools
Prefer a single agent when one system prompt can sensibly govern all its tools. Reach for a manager when:
- The toolset is getting large or mixed. A model choosing among dozens of loosely related tools makes worse calls than a manager choosing among a few well-described specialists.
- Subtasks need different instructions. A research step and a bookkeeping step want different rules, different models, maybe different knowledge bases — that's per-agent configuration a single prompt can't express cleanly.
- You want to reuse existing agents. Agents you've already built and tested slot straight into a pool.
Billing: a manager conversation bills as the number of sub-agents configured on the manager — a manager with three agents bills three AI tasks per conversation, and the sub-agent invocations inside the run are not billed separately. Keep the pool to agents the workflow actually needs.
How to create a manager
- On the Multi-Agents page, click Create Multi-Agent; enter a name (no spaces) and a description of the workflow it orchestrates.
- In the editor, pick the Model Type and write Instructions: which agent handles what, in what order, and how to combine results.
- Under Agents, import existing agents or create new ones. Review each agent's description — it's the manager's routing signal.
- Define any Prompt Variables, then Save.
How to test a manager
- Click Test in the top right of the editor. The streaming test window opens against your draft.
- Send a request and watch the orchestration live: each delegation appears as a collapsible agent invocation card showing the sub-agent's name, the exact task the manager assigned, its status, and the tool calls it makes as it works.
- Iterate: if the wrong agent got a task, sharpen the agents' descriptions or the manager's instructions; if the right agent failed, fix that agent (its own Test button is one click away). There's also a Real Time Voice option for a live voice conversation with the manager.
Past runs — including full nested sub-agent transcripts — live in Manager History.
How to publish and share
Manage → Publish makes the current draft the version served through the API (see Versions), Manage → Embed generates a chat-widget snippet, and Share grants teammate or company-wide access — the same lifecycle as agents.
Sharing and access levels
Every multi-agent starts private to its owner. Share it with specific teammates — each at their own access level — or company-wide at a single level for everyone. What each level allows:
| Level | What it lets a teammate do |
|---|---|
| READ | View the manager, its versions, and its sharing details, and test-run it |
| WRITE | Edit the draft |
| PUBLISH | Publish and roll back versions |
| ADMIN | Share and delete the manager |
The owner always has ADMIN implicitly; transferring ownership is owner-only.