---
title: "Discussion on \"Multi-Agent Systems: What Happens When One Agent Isn't Enough\" | Hashnode"
description: "Discussion on \"Multi-Agent Systems: What Happens When One Agent Isn't Enough\". Multi-Agent AI: Orchestration Patterns Explained"
url: "https://hashnode.com/posts/multi-agent-systems-what-happens-when-one-agent-isn-t-enough/6ab0d27c65e23f8a291ec245"
---

[Feed](https://hashnode.com/feed) /

Discussion

# [Multi-Agent Systems: What Happens When One Agent Isn't Enough](https://nagspidey.hashnode.dev/multi-agent-systems-what-happens-when-one-agent-isn-t-enough?utm_source=hashnode&utm_medium=feed)

Multi-Agent AI: Orchestration Patterns Explained

Sep 21 · 10 min read · nagspidey.hashnode.dev  
Read the article

-   [#ai-agents](https://hashnode.com/tag/ai-agents)
-   [#multi-agent-systems](https://hashnode.com/tag/multi-agent-systems)
-   [#ai-orchestration](https://hashnode.com/tag/ai-orchestration)
-   [#llm](https://hashnode.com/tag/llm)
-   [#software-architecture](https://hashnode.com/tag/software-architecture)

## Written by

[Nagappan S](https://hashnode.com/@imkarthik03)

@imkarthik03 · Chennai, India

  
[View profile](https://hashnode.com/@imkarthik03)

Building scalable products at the intersection of Full Stack Engineering & AI

I build scalable web apps, experiment with AI, and turn complex engineering problems into working products.

## Responses 5

Markdown supported · ⌘↵ to post

[Rulestack](https://hashnode.com/@rulestack)

[Sep 21](https://hashnode.com/posts/multi-agent-systems-what-happens-when-one-agent-isn-t-enough/6ab0d27c65e23f8a291ec245/comment/6ab11c15915242fb297635c9)

In Claude Code we measured what a spawned subagent pays before it reads a single file: about 54,000 tokens of system prompt, tool schemas and instruction files, written once into the prompt cache. We don't know the equivalent in your stack, but a cost like that never shows up in a call count, so the 2x you saw may be the cheaper half of the story. We came for the cost side and left thinking about the handoff contract instead.

[Nagappan S](https://hashnode.com/@imkarthik03)

[Sep 24](https://hashnode.com/posts/multi-agent-systems-what-happens-when-one-agent-isn-t-enough/6ab0d27c65e23f8a291ec245/comment/6ab11c15915242fb297635c9#reply-6ab4c8c950e4c0b663bebde2)

Thanks for sharing this. You're right that the cost of starting a subagent doesn't show up in a call count, so the 2x could well be the cheaper half of the story. It's a good reminder to look at the handoff contract and total token cost together, not just the number of calls.

[Mihai\_LeanZero](https://hashnode.com/@mihaileanzero)

[Sep 21](https://hashnode.com/posts/multi-agent-systems-what-happens-when-one-agent-isn-t-enough/6ab0d27c65e23f8a291ec245/comment/6ab0d6f9eda3bd36ff4bdeb4)

The structured-object fix is the right one, but I've hit a version of this that survives it: the downstream agent gets the upstream agent's clean structured output and still re-verifies from scratch, not because the interface was vague but because it has the same search/fetch tools the upstream agent does and nothing tells it not to use them. A model that can re-derive an answer will often do it anyway out of a kind of default thoroughness, even when the input it was handed is fine. What's worked for me beyond just defining the object is telling the downstream agent explicitly to treat the input as ground truth unless it finds a specific contradiction, and narrowing its tool access so re-deriving the whole thing from zero isn't the easiest path. Otherwise you've built a clean interface that a capable agent quietly ignores half the time.

[Nagappan S](https://hashnode.com/@imkarthik03)

[Sep 24](https://hashnode.com/posts/multi-agent-systems-what-happens-when-one-agent-isn-t-enough/6ab0d27c65e23f8a291ec245/comment/6ab0d6f9eda3bd36ff4bdeb4#reply-6ab4c8ec50e4c0b663bec0d9)

Thanks, Mihai. That's a failure mode a clean structured output alone doesn't prevent: a downstream agent with the same tools can quietly redo the work anyway. Treating the input as ground truth unless it finds a specific contradiction, plus narrowing its tools, is a practical fix. Have you seen a difference in cost or latency since making that change?

[Mihai\_LeanZero](https://hashnode.com/@mihaileanzero)

[Sep 29](https://hashnode.com/posts/multi-agent-systems-what-happens-when-one-agent-isn-t-enough/6ab0d27c65e23f8a291ec245/comment/6ab0d6f9eda3bd36ff4bdeb4#reply-6abbff580d20ed763cf24979)

Only qualitatively, not with numbers I'd trust enough to quote. Fewer duplicate search/fetch calls in a trace is a real token saving as a mechanism, that part isn't really in question. Latency is murkier, because it depends on whether the redundant work was blocking the response or overlapping with something else, and that varies by setup. So take the direction as reasoning rather than a measured result -- I don't have a clean before/after to point to.