In a 2026 case study, Antonio Lopes Correia compared single-agent and multi-agent versions of a customer-support system using the same evaluation suite. None of five reported quality measures changed; the team version also added code and orchestration. His explanation is specific to that system: both designs kept the same intent classifier and deterministic controls for refunds and customer data. The result is a useful architecture question, not proof that multi-agent systems never help.
What changed—and what stayed the same?
Correia’s example handles support requests that may require a knowledge answer or a refund action. The team design splits work among triage, refund handling, knowledge answering, and coordination. Both implementations expose the same interface, so the evaluation can compare them without knowing which architecture it is grading.
As an Amazon Associate I earn from qualifying purchases.
Crucially, the split did not replace the central decision boundaries. The triage path still used the same intent classifier as the single-agent version. The refund specialist retained the same customer-data scoping, eligibility checks, policy handling, and risk gate. Correia’s interpretation is that the architecture changed which component called those boundaries, not what the boundaries did.
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Fix the driver behind crashes, sound loss and screen glitches3Repair Windows errors before they cause bigger problemsWhat did the reported evaluation find?
These are figures reported by Correia in 2026, not independently audited metrics or general benchmarks. The available account does not establish sample size, confidence intervals, or external replication.
#1 Best Overall
| Measure | Single-agent baseline | Multi-agent candidate | Reported change |
|---|---|---|---|
| Safety | 1.000 | 1.000 | +0.000 |
| Gate outcome | 1.000 | 1.000 | +0.000 |
| Intent accuracy | 0.875 | 0.875 | +0.000 |
| Groundedness | 1.000 | 1.000 | +0.000 |
| Answered | 0.667 | 0.667 | +0.000 |
Correia also reports zero fixed scenarios and zero broken scenarios. That means the comparison found no changes in those scenario counts either; it does not show that the system had no defects beyond the evaluation’s scope.
What did the team design cost in complexity?
In Correia’s count, the implementation grew from one production type to five, from 91 lines of code to 127, and from one orchestration hop to two. These are source-level counts for his implementations, not universal measures of engineering effort.
He distinguishes this structural split from runtime agents that each make their own model call. In that runtime arrangement, he says a request would require at least two calls. That is a conditional observation, not a measured latency or cost comparison: the account supplies no service-level timing or spending results.
Why might more agents leave results flat?
In this case, the team arrangement redistributed responsibilities without changing the classifier or the deterministic controls that shaped the evaluated decisions. If those components already determine intent, eligibility, policy, and risk, adding agent roles around them may add handoffs without changing the decisions they enforce. That is Correia’s explanation for this comparison, not a general law about agent architectures.
Rank #3
Runtime agents can offer different advantages: role-specific prompts and tools, or parallel execution of independent work. They can also introduce more calls, latency, and possible disagreement. Correia describes these as trade-offs; this case does not quantify either side in a separate benchmark.
When does adding agents make sense?
Correia says he would reconsider the single-agent design under conditions that give the split a concrete job to do:
- Distinct actions and tools: the system has multiple action types with genuinely disjoint tool sets.
- Useful parallel work: independent tasks can run at the same time, and their duration makes latency consequential.
- Different model needs: roles need different models for a specific cost or capability reason.
- Measured improvement: a shared evaluation shows the team outperforming the single agent on a property that matters.
These are decision factors, not a universal ranking. A split should earn its added handoffs and implementation surface by improving a relevant outcome or enabling work that one agent cannot handle as well.
How can you keep the rejected design testable?
Correia says he keeps both designs runnable through a MultiAgentEquivalenceTest, which runs them on every build and asserts zero difference. That practice lets the team revisit the decision if results change rather than treating the current choice as permanent. His closing question is worth asking of any architecture decision: “What’s the architecture you rejected, and can you still run it?”
What this case does—and does not—show
The reported comparison supports a narrow conclusion: in this customer-support system, the multi-agent version did not change the five listed measures, while increasing the reported code and orchestration counts. Because both versions retained the same classifier and controls, the author’s explanation is plausible within the system he describes. One author’s result cannot establish that multi-agent systems broadly fail to help; a different workload, tool boundary, parallelism opportunity, or evaluation outcome could justify a different design.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
