6.2.6 · D5AI Agents & Tool Use
Question bank — Multi-agent collaboration
Before we start, three words get reused everywhere, so let's pin them down in plain language:
True or false — justify
A team beats one big agent whenever there are more agents
False. More agents only help when specialization savings plus parallel speedup exceed the extra communication cost; below that break-even, adding agents just adds message overhead and slows things down.
Multi-agent collaboration is basically an ensemble of models
False. An ensemble fuses predictions statistically (e.g. averaging) with no dialogue, while agents exchange explicit messages and adapt to each other — coordination, not aggregation.
A manager-worker system cannot show emergent behaviour because the manager controls everything
False. The manager sets tasks but does not compute each worker's answer, so the final result still emerges from the workers' reasoning that the manager alone could not have produced.
Parallel-with-aggregation and a debate pattern are the same thing since both use several agents
False. Aggregation agents solve independently and are combined at the end (no cross-talk during solving); debate agents argue with each other's outputs each round. Interaction-during vs. no-interaction is the whole difference.
If capabilities are perfectly partitioned () the coordination cost is zero
False. Disjoint capabilities remove skill overlap, but agents must still pass results and requests to each other, so the message cost term never disappears.
A sequential pipeline is always safer than a single agent because each stage is checked
False. A pipeline has no built-in checking — its danger is error propagation: a mistake in an early stage silently corrupts every stage downstream.
Peer-to-peer negotiation scales better than manager-worker in every case
False. Peer-to-peer removes the central bottleneck but needs conflict-resolution protocols; with few agents and simple tasks a manager is simpler and faster.
Two debate agents that always agree still improve the answer
False. Debate's value comes from surfacing disagreement (confirmation-bias reduction). Two agents that never dissent produce the same blind spots as one agent.
Giving every worker the same tools makes collaboration more robust
Mostly false. Identical toolsets remove specialization gain — the main reason multi-agent wins — turning the system into a costly copy of one agent unless you specifically want redundancy for voting.
Spot the error
"We split the task among 4 agents, so latency is now one quarter." — find the flaw
Parallel time is , not total time divided by 4. The slowest agent plus messaging sets the pace; a single slow stage or a serial dependency erases the speedup.
"Our aggregation vote gave a unanimous answer, so it must be correct." — find the flaw
Unanimity only means the agents shared the same reasoning path or bias, not that the path was right; correlated errors make a confident-looking majority wrong.
"The tester and coder are the same agent to save cost." — find the flaw
Fusing them destroys independent scrutiny: the tests inherit the coder's assumptions, so bugs the coder didn't foresee stay invisible. The separation is the whole point of that role.
"We added a synthesizer, but it just concatenates the five reader summaries." — find the flaw
Concatenation isn't synthesis. A real synthesizer must reconcile overlaps, contradictions, and gaps across summaries — otherwise the emergent 'coherent whole' never appears.
"Since agents are autonomous, we never need a shared goal." — find the flaw
Autonomy is about independent decision-making, not independent purpose. Without shared or complementary goals the agents optimize apart and their outputs don't compose into a solution.
"Our manager re-assigns tasks by whoever is idle, ignoring skill." — find the flaw
The assignment rule should maximize — match task to capability. Assigning by idleness alone can hand a task to an agent that lacks the needed capability.
Why questions
Why do debate/adversarial patterns reduce confirmation bias?
Because an agent whose only job is to attack the proposal must actively search for weak points, forcing the flaw into the open instead of letting the proposer's own biases go unchallenged.
Why does a single agent's cost explode as the capability set grows?
Every extra capability enlarges its context, instructions, and reasoning branching, so prompts bloat and focus degrades — the agent spreads thin over many skills instead of mastering one.
Why is a well-defined message interface critical to multi-agent success?
Because the whole cost-benefit hinges on staying small; loose, verbose, or ambiguous messaging inflates that term until coordination overhead cancels the specialization gain.
Why can parallel readers cut research latency but parallel pipeline stages cannot?
Readers have no dependency on each other, so they truly run at once; pipeline stages depend on the previous stage's output, so they must wait in order regardless of how many agents exist.
Why do we separate a Reviewer from the Coder even after tests pass?
Passing tests only cover cases the tester imagined; the Reviewer brings fresh, orthogonal scrutiny (security, maintainability) that neither coder nor tester was looking for.
Why does emergent behaviour require information sharing and not just parallel work?
Parallel work alone gives you independent partial results; emergence needs the joint policy to be conditioned on messages from others, so agents shape actions around shared information.
Edge cases
What happens if exactly one agent is present — is it "multi-agent"?
No. With one reasoning loop there is nothing to coordinate or exchange messages with, so it collapses to a single agent with tools.
What happens in a sequential pipeline if the first agent silently returns a plausible-but-wrong output?
Error propagation: every downstream agent treats the corrupted input as valid, so the final output is confidently wrong with no stage detecting the original fault.
What happens to majority voting when all agents share the identical training bias?
The 'majority' becomes a correlated block — the vote reproduces the shared error rather than cancelling it, so robustness gained from voting shrinks toward zero.
What happens when two peer agents negotiate a shared resource and neither yields?
Without a conflict-resolution protocol they deadlock; this is why peer-to-peer designs must include tie-breaking or priority rules borrowed from game-theoretic equilibria.
What is the degenerate case where multi-agent cost equals single-agent cost?
When agents are un-specialized clones with no parallelism — each does the same full task, so never falls below and message cost is pure overhead.
What happens if message cost grows faster than the number of agents (e.g. all-to-all chat)?
Communication dominates: with every agent messaging every other, overhead scales roughly with the square of the agent count, eventually erasing any specialization or parallel benefit — a distributed-systems scaling wall.
Recall One-line summary to keep
Multi-agent wins only when specialization + parallelism savings beat communication cost, and each collaboration pattern trades one risk (bottleneck, bias, error propagation, deadlock) for another. See also 6.3.01-Prompt-engineering-for-agents for shaping the messages that make coordination cheap.