Agents That Talk Too Much: When LLMs Overplan and Underperform

In the rush to build powerful multi-agent systems, many teams are hitting a strange wall:
More agents = more complexity = worse outcomes.

We’ve seen it ourselves. You plug in a planner, a search agent, a summarizer, a re-router, and a validator... only to watch the system slow down, loop unnecessarily, or return inconsistent answers.

So what’s happening?

Why Over-Orchestration Hurts

Most LLMs today aren’t bottlenecked by model quality — they’re bottlenecked by coordination overhead.
Every extra agent adds:

• A prompt-hop that increases latency

• A memory handoff that risks context loss

• An execution fork that might not be needed

Instead of smart automation, you get death by delegation.

Real-World Battle: Claude 3.5 + LangGraph vs GPT-4 + CAMEL

In internal tests:

• Claude 3.5 Sonnet with ReAct + limited tool access beat more “autonomous” agent chains in speed and reliability

• GPT-4 with CAMEL-style recursive planning often hallucinated tools or over-planned low-impact subgoals

Why? Because not all decisions need a team of agents. Sometimes, one LLM with sharp tool access does the job better.

Best Practices for Agent Systems (from painful lessons)

1. Start with single-agent + tool-use.
   If you can solve the problem with one planner + retriever + executor, don’t overengineer it.

2. Use agents where reasoning paths vary wildly.
   Multi-agent setups shine in complex, multi-modal, or uncertain flows (e.g., ticket triage + search + summarization).

3. Measure coordination cost.
   If adding an agent saves time for humans but adds 4 seconds to the response, is the trade-off worth it?

4. Prefer stateless tools over nested agents.
   Tools like vector search, calculators, and function calls are easier to manage and debug than spinning up agent subloops.

What’s Next?

The next evolution won’t be more agents — it’ll be better agent scaffolding.
Think LangGraph with memory control, agent guards, and token-budget awareness.

TL;DR

Don’t build agent factories when a well-prompted LLM can finish the job.
The future of agentic systems lies in clarity of control, not chaos of delegation.