Three Sub-Agent Design Decisions That Control Speed, Reliability, and Cost

Most multi-agent systems follow the same basic pattern: a user asks something, the main agent breaks the request into tasks, calls a few sub-agents, and combines everything into a final response. This setup scales well because different teams can own different sub-agents and work can run in parallel. But it only works if you get three specific design choices right.

Decision 1: Sync vs. Async Execution

Sync means the main agent calls a sub-agent and waits for the result before continuing. It is simple, but it blocks the flow. Use sync when the main agent cannot continue without that specific result.

Async means sub-agents run in the background while the main agent keeps moving. The product feels faster to the user, but coordination and state management become more complex. The choice between these two modes directly affects perceived speed and system complexity.

Decision 2: Tool Design

There are two approaches to exposing sub-agents as tools.

The first option is one tool per sub-agent. You create a dedicated tool for each sub-agent, which gives you tight control over inputs. You can filter or clean the output before it goes back to the main agent. The trade-off is more configuration and more wiring.

The second option is a single dispatch tool. One task tool routes work to any sub-agent. This is cleaner, but now the main agent must know what sub-agents exist. You can handle this by listing them in the system prompt, exposing them as an argument (like agent_name), or providing a list_agents tool so the agent discovers them progressively when there are too many to enumerate.

Decision 3: Context Engineering

This covers specs, inputs, and outputs.

Your main agent needs clear sub-agent specs: a tool name, a good description, and correct arguments so it knows exactly when to call each sub-agent.

Then you design inputs on purpose. Instead of sending only a raw query, add an expertise argument like beginner, intermediate, or expert. Your tool uses that value to modify the prompt before it reaches the sub-agent, so the same question automatically gets explained at the right level.

Finally, outputs determine what the sub-agent returns. It can return only the final answer, or it can return the full message history so the main agent can see the sub-agent's reasoning trajectory and combine results more reliably.

Key Takeaways

• Choose sync execution when results are blocking; choose async when you need perceived speed but can handle coordination complexity
• Tool-per-agent gives you control over inputs and outputs; a single dispatch tool is cleaner but requires sub-agent discovery
• Design inputs with purpose (add arguments like expertise level) and decide whether outputs should include just the answer or the full reasoning chain

Resources

• Anthropic Multi-Agent Documentation -- Reference for building multi-agent systems with Claude