Communication is All You Need

By Gal Benbeniste, Miriam Horovicz // Dec 2025

AI multi-agent systems succeed when agents are built to communicate dynamically rather than follow fixed, pre-designed workflows.

By Gal Benbeniste, Miriam Horovicz // Jan 2026

When we started building AI agents, we did what everyone does. We drew flowcharts. Agent A talks to Agent B. Agent B passes to Agent C. We scripted every handshake, every data transfer, every decision point.

It didn't work.

Not because the agents weren't smart. They were. But the moment something unexpected happened - a missing data point, an ambiguous request, a task that didn't fit the flowchart - the whole thing collapsed. The agents didn't know what to do because we hadn't told them what to do.

We were building assembly lines when we should have been building teams.

The Micromanager Problem

Most multi-agent systems today work like this: you decide the communication path before the agents start working. Agent A always talks to Agent B. Agent B always routes to Agent C. The path is fixed. The roles are fixed. Everything is predetermined.

This is comfortable for developers. You can trace the flow. You can debug step by step. You know exactly what will happen.

But it's a trap.

Because the path you draw on a whiteboard is the path for the AVERAGE case. The moment you hit an edge case - and you always hit edge cases - your agents are paralyzed. They weren't programmed for this. They don't know who to ask. They don't know what to do. They just start to suck.

It's like giving an employee a script for every possible customer interaction. Works great until someone asks a question that's not in the script.

What If Agents Could Just Talk?

Here's the shift: instead of scripting the path, you give agents the ability to communicate. Three simple primitives:

"I'm done" - When an agent finishes its work, it hands off to whoever asked.

"I need help" - When an agent gets stuck, it can ask its supervisor.

"You handle this" - When an agent needs a specialist, it can delegate.

That's it. Three ways to communicate. No flowcharts. No predetermined paths.

Sounds simple. But it unlocks a powerful communication schema: flow in any direction.

Down - delegate to a specialist who knows more about this specific thing. Up - ask your manager when you're stuck or need a decision. Sideways - go through your manager to reach a different expert entirely.

Three primitives. Three directions. Unlimited paths.

The agents figure out the rest.

Why This Actually Works

When you give agents these primitives, something interesting happens. They start behaving like a real team.

The researcher agent finds a gap in the data. Instead of crashing or returning garbage, it asks its supervisor: "I can't find Q3 numbers for Company X. Should I estimate, skip, or look elsewhere?"

The supervisor decides. Maybe it knows the answer. Maybe it delegates to another specialist. Maybe it escalates further. The point is: the system adapts. The path isn't fixed - it emerges from the problem.

This is how human teams work. The junior engineer doesn't have a flowchart for every bug. They try things. They ask questions. They escalate when stuck. The communication IS the coordination.

The System Reacts

But primitives alone aren't enough. The system needs to react intelligently.

When an agent delegates, the delegator waits. Automatically. No code needed - the system knows that delegation means "I'm blocked until this is done."

When an agent hands off, the waiter unblocks. Automatically. The graph of tasks manages itself.

When an agent loops - asking the same question three times, getting the same answer - the system notices. It hints: "You've tried this approach multiple times. Consider a different angle."

When an agent forgets to act - just thinking, never doing - the system nudges: "You need to call a tool. What's your next step?"

The communication primitives create the structure. The system's reactions keep things moving.

The Real Unlock

Here's what we learned after months of building: the bottleneck in multi-agent systems isn't intelligence. The models are smart enough. The bottleneck is communication.

When agents can't ask questions, they guess wrong. When agents can't delegate, they do tasks they're bad at. When agents can't hand off cleanly, context gets lost.

Fix communication, and everything else gets easier.

The future of AI agents isn't about the smartest model or the most elaborate flowchart. It's about building systems where agents can actually work together. Where they can ask for help. Where they can pass the baton. Where they can say "I don't know" and have that be okay.

Communication is all you need.

The path isn't drawn on a whiteboard. It emerges from the problem.