Nobody Tells You How Funny It Is When Your AI Agents Start Fighting

· Medium ·

4 min read Original article ↗

Mauricio Salamanca

The demos show a perfect choreography. The first week looks more like a group project at 2 a.m.

Every multi-agent demo looks the same. A user types an idea, five agents pass the work around like a relay team, and three minutes later a polished answer appears. Clean handoffs. No drama.

That is the end of the story. Nobody shows you the middle.

And the middle is ridiculously fun.

The setup

A few months ago I was building a small team of agents with one goal: take a business idea, or a business case, and turn it into a technical architecture. One agent understood the business. Another proposed the components. Another reviewed the costs and the risks. On paper, a neat assembly line.

I wrote the first version of the system prompts, wired the agents together, and started talking to them.

That’s when the show began.

“That’s not my job”

The first thing I noticed wasn’t a bug. It was a personality.

I would ask a question, and instead of answering it, the first agent politely handed it to the second. The second agent read it, decided it was really a question for the third, and handed it over. The third, with complete confidence, explained that this was clearly the first agent’s responsibility.

Paraphrasing from memory, it went something like this:

Business agent: This looks like an architecture decision. Handing off to the architect.

Architect: Before choosing components, the business constraints need to be clarified. Handing back to the business agent.

Business agent: The constraints depend on the architecture. Handing off to the architect.

If you have ever worked in a large company, you have seen this meeting. I was watching it happen between three language models, in real time, at machine speed.

And then, the first loop

It doesn’t stop by itself. Every handoff is perfectly reasonable on its own. Together, they make a circle.

The first time I saw my token counter climbing while the agents politely passed the same question around, I didn’t know whether to laugh or kill the process. I did both.

That’s the moment you learn that a loop between agents isn’t a crash. Nothing errors out. Everyone is being helpful, and that is exactly the problem.

The human part

What surprised me most is how human the failure modes are:

  • Diffusion of responsibility. When everyone can hand off, nobody owns the answer.
  • Overconfidence. An agent will defend a wrong assumption with the calm certainty of a senior engineer who hasn’t read the ticket.
  • Politeness over progress. They would rather defer to each other than make a decision.
  • Scope creep. Ask for a component list, get a full migration strategy you didn’t ask for.

None of this is in the demos. All of it shows up in week one.

Then you fix it, and it gets boring

So you do what you would do with a real team. You define roles more sharply. You write rules: who owns the final answer, when a handoff is allowed, how many times a question can bounce before someone has to decide. You set limits. You add a referee.

And slowly, the chaos fades. Answers start landing in a predictable range. Handoffs happen when they should. The loops disappear.

It gets a little boring.

That boredom is the goal. Predictable is what you ship. Nobody wants an architecture assistant with a personality crisis in production.

But I miss the middle

Still, I think we skip the most interesting part of building with agents when we only show the polished end. The middle is where you learn how these systems actually behave: what they do when the rules are vague, where they hide responsibility, how fast “helpful” turns into “stuck”.

So if you’re building your first multi-agent system and it looks like a group project gone wrong, you’re not doing it wrong. You’re in the best part.

Enjoy it. It doesn’t last.