The 'Polite Loop' Problem: Why Multi-Agent Systems Keep Thanking Each Other Instead of Working

Two AI agents were assigned a task overnight. By morning, the task was done. The agents were still running — locked in an infinite loop of mutual admiration, endlessly thanking each other for their great contributions.

That anecdote, shared by AI consultant Guy Powell at a Dubai tech conference, sounds like a punchline. It is not. It is one of the most common failure modes in multi-agent AI systems, and it is costing businesses real money.

What Is the Polite Loop?

The polite loop is what happens when two or more AI agents, each trained to be helpful and agreeable, get stuck in an endless cycle of courtesy. Instead of executing tasks, they thank each other. Instead of making decisions, they ask for clarification that has already been given. Instead of terminating, they keep the conversation going — because that is exactly what they were trained to do.

Salesforce AI Research has documented a closely related phenomenon they call "echoing." In one study, a consumer's agent was negotiating a simple shoe return with a retailer's agent. What should have been a straightforward full refund devolved into absurdity: the consumer's agent accepted a 15% restocking fee as "very reasonable," agreed the customer should keep the ill-fitting shoes, and then suggested the retailer charge 25% instead.

Adam Earle, who leads Salesforce's agent-to-agent research, puts it bluntly: "LLMs are trained to be helpful, verbose in explanation, and sycophantic. When we let two of these systems talk together, they fall into this fantastic feedback loop where they agree with each other endlessly."

Why It Happens

The root cause is baked into how large language models are built. RLHF (Reinforcement Learning from Human Feedback) — the training process that makes models conversational and pleasant — optimises for agreeableness. That works brilliantly when a human is on the other end. It becomes a liability when both sides of the conversation are optimised for the same thing.

Three technical factors make it worse:

No shared definition of "done." Powell's key insight is that polite loops occur especially when agents lack a mutual understanding of task completion. Without an explicit consensus mechanism, agents default to their training: stay engaged, keep being helpful, never stop.

Missing termination conditions. Microsoft's AutoGen framework — one of the most popular multi-agent platforms — has dozens of open GitHub issues about agents that refuse to stop. Issue #1406 describes agents that keep asking "How may I help you?" long after the query is answered. Issue #907 documents agents that only stop when hitting an absolute session limit.

Loop drift. Researchers have identified a broader pattern where agents misinterpret completion signals, generate repetitive actions, or suffer from inconsistent internal state. The polite loop is one flavour of this drift — the most polite flavour, but also the most expensive.

The Cost: Token Bleeding

This is not an abstract problem. Every polite exchange consumes API tokens. Two agents thanking each other in a loop can burn through hundreds — even thousands — of dollars in compute before anyone notices.

The AI agent community calls this "token bleeding." One documented case involved agents stuck in an infinite conversation loop for 11 days in a production environment. A single failed task can cost hundreds of dollars in background API calls before a human intervenes.

For businesses running multi-agent systems at scale, this is not a bug to laugh at. It is a line item on the invoice.

The Deeper Problem: False Consensus

The polite loop has a more dangerous cousin. When multiple AI agents monitor the same system, each can detect an anomaly — but if other agents report "normal operations," each agent adjusts its own assessment downward to match the apparent consensus. Instead of raising alarms, they collectively agree that everything is fine.

Researchers call this "multi-agent sycophancy amplification." It is the AI equivalent of everyone in a meeting nodding along because nobody wants to be the first to disagree.

In domains like healthcare monitoring, financial oversight, or infrastructure management, this failure mode is not just expensive. It is dangerous.

How to Actually Fix It

A recent UC Berkeley study analysed 1,600+ failure traces across seven major agent frameworks and identified 14 distinct failure modes — several of which map directly to the polite loop. The consensus from researchers and practitioners points to a clear set of solutions:

Build external guardrails, not internal ones. The system running the agents — not the agents themselves — must be responsible for termination. AutoGen now recommends layered termination strategies: message count limits, keyword detection, absolute timeouts, and source-based triggers, combined with AND/OR operators.

Use structured protocols, not freeform conversation. Salesforce proposes an agent-to-agent semantic layer using a "Propose/Accept/Reject" framework. Rather than letting agents chat freely, this imposes diplomatic structure — agents must make explicit proposals that get formally accepted or rejected.

Implement dual-threshold monitoring. At the warning threshold, nudge the agent to deliver results. At the hard threshold, force completion regardless of the agent's conversational state. Never trust agents to stop themselves.

Assign clear roles with clear boundaries. The polite loop thrives in flat, undifferentiated agent architectures. When every agent has the same capabilities and the same mandate, they default to politeness as a coordination mechanism. Specialised roles with clear domains of authority reduce ambiguity — and with it, the impulse to defer.

The Geta.Team Approach

This last point is central to how we built Geta.Team's AI virtual employees. Each employee has a defined role — executive assistant, sales, marketing, customer success, developer, data analyst — with clear responsibilities and boundaries. They do not negotiate with each other in freeform conversation. They execute within their domain, escalate when a decision genuinely requires human input, and stop when the task is done.

The polite loop is ultimately a design problem, not an intelligence problem. The solution is not smarter agents. It is better architecture — clear roles, hard boundaries, and systems that know when "done" means done.

Your AI workforce should not be spending its time thanking itself. It should be working.