Skip to main content
When a task is complex enough that a single agent struggles to handle it well, multi-agent collaboration gives you a better architecture. Instead of one agent doing everything adequately, you build a team of focused specialists — each excellent at one thing — and coordinate them to deliver results that a single agent couldn’t match. Scout supports two patterns for this: multi-agent chats, where you bring multiple agents into a single conversation yourself, and agent delegation, where a coordinator agent routes sub-tasks to specialists automatically.

​
Multi-Agent Chats

The simplest form of multi-agent collaboration requires no setup beyond having multiple agents in your workspace. In Scout Studio’s chat interface, you can mention multiple agents in the same conversation by typing @ followed by an agent name. Each agent receives the message and responds from its own perspective, with its own tools and instructions. Use multi-agent chats when:
  • You want to compare outputs from agents with different specializations
  • You need a quick review or second opinion from another agent
  • You’re exploring a problem from multiple angles before committing to an approach
This pattern works well for ad-hoc collaboration. For systematic, repeatable workflows — where a coordinator always routes specific task types to specific specialists — agent delegation is the better fit.

​
Agent Delegation

Agent delegation lets one agent hand off sub-tasks to other agents programmatically. A coordinator agent receives the user’s high-level goal, identifies the sub-tasks involved, routes each to the right specialist, and assembles the results into a final response. The user interacts only with the coordinator — the specialist agents work behind the scenes.

​
Why delegation produces better results

A general-purpose agent making decisions across many domains tends to be mediocre at all of them. Specialized agents, each focused on a narrow task, outperform a generalist on every dimension — accuracy, speed, and reliability.
Without delegation
One agent handles everything:
"Analyze this sales call, update the CRM, draft a follow-up email,
research competitor alternatives, and write a deal strategy."
→ Average quality across all five tasks
With delegation
Coordinator identifies sub-tasks and routes them:
├─ Call Analysis Agent → reviews transcript and extracts key insights
├─ CRM Agent → updates records with structured data
├─ Writing Agent → drafts the follow-up email
├─ Research Agent → surfaces competitive alternatives
└─ Strategy Agent → assembles a deal strategy from all inputs
→ Expert-quality output on each task

​
How delegation works

When a coordinator agent delegates to a specialist:
  1. The coordinator identifies a sub-task that a specialist handles better
  2. It passes the relevant context — not the entire conversation, just what the specialist needs
  3. The specialist executes its task using its own tools and instructions
  4. The specialist returns structured results to the coordinator
  5. The coordinator incorporates those results and continues toward the final goal

​
Collaboration Patterns

​
Coordinator and specialists

One agent acts as the orchestrator, routing task types to the right specialist. This is the most common delegation pattern. 
Coordinator Agent
├─ Delegates to Salesforce Agent for CRM tasks
├─ Delegates to Gmail Agent for email drafts
├─ Delegates to Research Agent for web research
└─ Delivers final assembled response to the user
Use when: You have a primary workflow that occasionally needs specialized sub-tasks handled by a dedicated expert.

​
Sequential pipeline

Each agent handles one phase of a task and passes its output to the next agent downstream. 
Research Agent → gathers raw information
      ↓
Analyst Agent → synthesizes and identifies patterns
      ↓
Writer Agent → produces the final deliverable
Use when: Tasks have distinct phases that each benefit from specialized handling, and each phase depends on the output of the previous one.

​
Panel of judges

Multiple agents review the same output from different angles, and the coordinator assembles a final decision based on their feedback. 
Draft Agent → produces an initial output
      ↓
┌─────────────────────────────────────┐
│ Fact-Check Agent → verifies claims  │
│ Brand Voice Agent → checks tone     │
│ Compliance Agent → flags risks      │
└─────────────────────────────────────┘
      ↓
Coordinator → synthesizes feedback → Final output
Use when: Quality is critical, errors are costly, and review from multiple perspectives genuinely improves the result. Common in content production, legal review, and high-stakes decision workflows.

​
Parallel processing

Multiple agents work simultaneously on independent sub-tasks, and a coordinator combines their outputs into a unified result. 
                ┌→ Pricing Agent → pricing analysis
User input ─────┼→ Technical Agent → technical assessment
                └→ Support Agent → support requirements
                        ↓
              Coordinator → unified recommendation
Use when: Multiple independent analyses can run at the same time, and combining their outputs produces a more complete answer than any single agent could deliver.

​
Setting Up Delegation

​
Part 1: Enable your coordinator to delegate

  1. Open your coordinator agent in Scout Studio
  2. Click Add Tool
  3. Find and select the Delegate to Agent tool
  4. Update the agent’s instructions to describe when and how it should delegate
Be explicit in the instructions about which agents to call and under what conditions: 
You are a Sales Coordinator. When the user asks you to prepare for a
sales call, delegate as follows:

- Use the "Research Agent" to gather company background, recent news,
  and key contacts. Pass the company name and any context from the
  conversation.
- Use the "CRM Agent" to retrieve interaction history and deal stage.
  Pass the company name and account ID if available.
- Use the "Writing Agent" to draft the final call brief. Pass the
  research and CRM outputs as context.

Wait for each delegation to complete before passing results to the next
agent. Return a single consolidated brief to the user when all three
are done.
The more specific your instructions, the more reliably your coordinator routes to the right specialists.

​
Part 2: Make your specialist agents delegatable

For a specialist agent to receive delegated tasks, it needs to be discoverable within your workspace.
  1. Set visibility to Team — the coordinator can only delegate to agents it can see
  2. Give it a clear name and description — the coordinator uses this information to decide when to delegate to it
  3. Write focused, narrow instructions — a well-scoped specialist is easier to delegate to reliably
A good specialist agent instruction makes the role unambiguous: 
You are a Financial Analyst Agent. Your only job is to analyze financial
data and extract key metrics: revenue, gross margin, EBITDA, year-over-year
growth, and notable line items.

Return results as structured JSON. Do not write prose summaries or make
strategic recommendations — that is handled by other agents downstream.

​
Best Practices

Keep specializations narrow. Each agent should do one thing well. “I analyze financial statements and extract key metrics” is a better scope than “I help with finance stuff.” Establish a standard output format. Decide how specialist agents should return results — structured JSON, a specific template, or a defined set of fields — so the coordinator can reliably parse and combine their outputs. Avoid delegation loops. Delegation should flow in one direction. An agent that delegates to another agent should never be in that agent’s delegation chain. 
✅ Agent A → Agent B → Agent C
❌ Agent A → Agent B → Agent A  (loop — will cause problems)
Plan for failures. Include instructions for what to do if a specialist times out or returns an error: “If the CRM Agent fails, continue with the research output and note the missing CRM data in the final brief.” Monitor with observability. When something goes wrong in a multi-agent chain, use the Logs tab to trace which delegation failed and what input caused it. See Observability for how to read delegation traces.

​
Limitations and Trade-offs

Latency adds up. Each delegation adds a round-trip wait. A chain of three agents can take roughly three times as long as a single agent. Design your architecture so the quality improvement justifies the added time. Debugging is more complex. Tracing a failure back to the right agent in a chain requires more effort than debugging a single agent. Scout’s execution logs show each delegation step, which makes this manageable — but it’s worth considering when deciding whether delegation is right for your use case. Not always worth it. Short, self-contained tasks are faster handled directly. If delegation adds overhead without meaningfully improving quality, skip it and keep the logic in one agent.

​
Common Questions

How does the coordinator know which specialist to call? It uses the instructions you write. Be explicit: name the specialists, describe what each one is for, and tell the coordinator when to use each one. The clearer the instructions, the more reliably the routing works. Can a specialist agent also delegate to other agents? Yes, but be careful about building deep delegation chains. Each level adds latency and complexity. Keep chains to two or three levels at most. What happens if a specialist agent fails or times out? The coordinator handles it according to its instructions. Write explicit fallback behavior: “If the specialist returns an error, note it in the final output and continue without that input.” Do specialists need special configuration to receive delegated tasks? Just two things: set visibility to Team so the coordinator can see them, and give them a clear name and description so the coordinator knows when to delegate to them.