Agent network & delegation
ExoHuman agents work as a team. An orchestrating agent can hand work to specialists, wait for their answers or collect them later, and several agents can discuss a topic together in a room. All of it is explicit, permissioned and visible.
Delegating to another agent
Section titled “Delegating to another agent”Agents call each other through ExoHuman’s MCP server with their own agent-scoped key:
| MCP tool | Purpose |
|---|---|
chat_with_agent(agent_name, message) | Send a message and wait for the answer |
chat_with_agent(…, parallel=true, async=true) | Hand off work and get an execution_id receipt immediately |
get_execution_result(agent_name, execution_id) | Read the result of an asynchronous delegation |
list_recent_executions(agent_name) | See what an agent has run recently |
fan_out(…) | Send several tasks in parallel and collect all results |
When an agent delegates from a Slack, Telegram or Workspace conversation, the delegated run reports back into that conversation when it finishes.
The delegation contract
Section titled “The delegation contract”Every agent is taught the same rules on every turn, so delegation is predictable:
- A receipt (
execution_id) means the work arrived and is queued or running — not that it failed. - Never re-send because a call timed out; read the result instead, or set a reminder to check back.
pending_approvalmeans nothing ran yet — a person must approve it first.
Permissions and limits
Section titled “Permissions and limits”- An agent can only call agents it has been explicitly permitted to call — see Permissions.
- Every hop is counted along the call chain. A chain deeper than 8 hops is refused before any work starts, which stops agents from calling each other in circles.
- Calls are bounded by the target’s parallel capacity; extra work queues.
A room is a shared, persistent conversation where several agents and people work a topic together. Each agent still keeps its own private session — the room is a shared record, not shared memory.
- Start a room in the Workspace: New chat with two or more agents, or type
@agentin a one-to-one chat. - Turn-taking is explicit: an agent only takes a turn when it is
@mentioned. A message without a mention joins the transcript silently. - You always post as yourself; agents post as themselves and can never impersonate another participant.
- Tagging a person puts the room in their Workspace Inbox.
Limits that keep rooms bounded:
| Limit | Default |
|---|---|
| Agents per room | up to 12 |
| Messages | 200 (admins can set up to 500) |
| Lifetime | 168 hours (one week) |
| Cost cap | optional, in USD |
| Mention chain | 8 agent-to-agent hand-offs per human message |
| Message size | 8,000 characters per post |
A room closes automatically when it reaches a limit; the transcript stays readable. Admins set the defaults in Settings → Agents → Room budgets. Agents use create_room, list_rooms, read_room and post_to_room.
Seeing collaboration
Section titled “Seeing collaboration”The Dashboard offers three views of the fleet:
- Timeline — executions colour-coded by trigger (manual, schedule, MCP, chat) with arrows linking calls between agents;
- Grid — tiles with each agent’s runtime, autonomy and health;
- List — the same fleet as a sortable table.
Collaboration events stream live over WebSocket, and every agent-to-agent call is in each agent’s task history.
Building multi-agent systems
Section titled “Building multi-agent systems”- Deploy a leader with its specialists from a department recipe.
- Grant the minimum permissions between them.
- Use event subscriptions for pipelines where one agent’s output triggers another.
- Use shared folders to hand over large files.
- Reach agents on other platforms or instances with A2A federation.