> ## Documentation Index > Fetch the complete documentation index at: https://docs.scoutos.com/llms.txt > Use this file to discover all available pages before exploring further. # Agent Delegation: Multi-Agent Collaboration in Scout > Coordinate multiple Scout agents using delegation and multi-agent chats. Route tasks to specialized sub-agents and assemble results automatically. 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. ```text Without delegation theme={null} 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 ``` ```text With delegation theme={null} 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. ```text theme={null} 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. ```text theme={null} 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. ```text theme={null} 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. ```text theme={null} ┌→ 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: ```text theme={null} 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: ```text theme={null} 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. ```text theme={null} ✅ 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](/agents/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.