How a talk loop between two agents starts and the cheapest hard stop for it

Flashcard·Easy·4.0 · 0·~30s·Asked atCerebras Truera Zoho

Attempt it

It starts when each agent decides the other is better suited for the current state. A's prompt says 'if the task is research, hand to B'; B's prompt says 'if the task involves analysis, hand to A.' The task touches both, neither agent commits, and they ping-pong. Underlying causes: ambiguous role boundaries in the prompts, missing termination criteria, and an absent allowed-targets ACL that would have prevented the round-trip handoff at the framework level.

The cheapest hard stop is a max_handoffs cap enforced by the runtime, typically 5 to 10 for a real workflow. When the cap fires, the runtime stops the loop and either returns the last message or routes to a terminal 'give up' agent. This is the floor; the proper fix is also tightening the role boundaries in the prompts and pruning the handoff graph so the cycle is structurally impossible.

Your answer

**The ping-pong starts when each agent's prompt makes the other one look like the better choice for the current state.** Imagine two agents in a swarm. Agent A's system prompt says 'if the task involves research, hand off to B'. Agent B's system prompt says 'if the task involves analysis, hand off to A'. A task that touches both is now a tennis match: A bats it to B, B bats it back, neither commits to actually doing the work. Three things conspire to let this happen: - **Ambiguous role boundaries.** Both prompts have overlapping triggers for handoff and no clear ownership rule for tasks that touch both areas. - **Missing termination criteria.** Neither prompt has a 'commit if you have already received this' rule. - **No allowed-targets ACL.** The framework does not prevent A from handing back to B after B handed to A; the cycle is structurally possible. **The cheapest hard stop is a max_handoffs cap** enforced by the runtime. Typically 5 to 10 for a real workflow. When the cap fires, the runtime stops the loop and either returns the last message or routes to a terminal 'give up' agent. The cap is the floor, not the ceiling. The proper fix is also tightening the prompts (clear ownership, 'commit if received') and pruning the handoff graph so the cycle cannot form.

**Talk loops are a structural failure mode of peer-handoff swarms, and the cheapest hard stop is a runtime-enforced max_handoffs cap.** **How they start.** Each agent's prompt encodes 'if the task looks like X, hand off to peer Y'. When two agents have overlapping handoff triggers and a task that touches both, neither commits. A hands to B, B hands to A, repeat. The pattern is famous enough that it has a name in the swarm literature: ping-pong. **The three causes worth naming.** - **Ambiguous role boundaries.** The prompts do not specify ownership for tasks that touch multiple roles. A clear rule like 'if the task touches both research and analysis, the agent who receives it first owns it and may consult peers via tool calls rather than handoffs' eliminates a wide swath of cycles. - **Missing termination criteria in the prompts.** A simple 'if you have already worked this task once, commit; do not hand off' rule kills the round-trip case immediately. - **No allowed-targets ACL at the framework level.** A handoff graph that allows A to B and B to A is a literal cycle. Pruning it (A to B only, with a different exit path) makes the loop structurally impossible. **The hard-stop and why it is the cheapest.** A `max_handoffs` cap is one line of runtime config. It bounds the worst case independently of prompt quality. Typical values are 5 to 10 handoffs per run for a real workflow; trigger an explicit 'give up and ask a human' terminal or return the last useful message. Every serious framework exposes this (OpenAI Agents SDK, LangGraph supervisor, AutoGen 0.4 termination conditions, CrewAI max_rpm-style limits). **The floor versus ceiling distinction.** The cap stops the bleeding so production does not blow up while you debug. The actual fix is tightening prompts, adding the 'commit if received' rule, and pruning the handoff graph.

TL;DR

Ambiguous role boundaries plus missing handoff ACL start the ping-pong; a max_handoffs cap is the cheapest hard stop, with tighter prompts and a pruned handoff graph as the real fix.

Memory aid

Easy to grasp

Picture two coworkers in adjacent cubicles. A says 'this is really B's job, I will pass it over'. B looks at it and says 'no, this is A's specialty, I will pass it back'. Neither wants to commit, and the file flies back and forth all afternoon. The cheapest fix is a manager who walks by after the fifth round and says 'stop, just finish it'. The proper fix is rewriting both job descriptions so it is clear who owns this kind of task and removing the option to bounce it back. Multi-agent ping-pong is the same office comedy with LLMs.

Key concepts

Multi-Agent Systems

Concept explanation~2 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

Talk loops are the canonical failure mode of swarm-style multi-agent topologies. Two agents (or more) hand the same task back and forth without making progress, burning tokens and frustrating users until something stops them. The pattern is so well-known that every serious framework ships a runtime cap to stop it, which is why this question is rated as a fundamentals check rather than a senior trap.

The answer has two parts. The first is correctly diagnosing the cause: ambiguous role-boundary prompts plus a handoff graph that allows cycles plus no termination rule in the prompts. The second is correctly naming the cheapest hard stop: a max_handoffs cap enforced by the runtime, with the explicit caveat that this is the floor, not the fix.

One-line summary: ping-pong starts in the prompts and dies at the cap. Three layers of defence: tight prompts, pruned graph, runtime cap. The cap is the floor.

How a talk loop actually starts

The minimal reproduction

Agent A's system prompt: 'You are a research specialist. If the user asks for analysis, hand off to the analysis agent.' Agent B's system prompt: 'You are an analysis specialist. If the user asks for research, hand off to the research agent.'

User query: 'Research the multi-agent framework landscape and analyse which is best for our use case.'

A receives, sees 'analyse', hands to B. B receives, sees 'research', hands to A. A receives, sees 'analyse', hands to B. Loop.

Why the loop happens

Three contributing causes are present and worth naming separately:

Ambiguous role boundaries. The handoff triggers in both prompts overlap. The task genuinely touches both areas, and neither prompt specifies ownership for that case.
Missing termination criteria. Neither prompt has a 'if you have already received this task once, commit and finish; do not hand off again' rule.
Open handoff graph. The framework allows A to hand to B and B to hand to A, so the cycle is structurally possible. An allowed-targets ACL that omitted one of those directions would have made the loop impossible at the graph level.

Multi-agent variants

Three-agent cycles (A to B to C to A) are harder to spot by reading individual prompts because no single pair contains the cycle. Detection has to look at the handoff trajectory, not just the prompts.

The runtime cap as the cheapest hard stop

Why prompts and ACL are the real fix

Production detection and the interview signal

Situations where this technique stops working.

2–4 min · Everything important, quickly.

Real products, models, and research that use this idea.

OpenAI Agents SDK exposes `max_turns` on Runner and `handoffs=[...]` on Agent precisely to address this failure mode.
LangGraph supervisor templates avoid the cycle structurally because workers return to the supervisor, not directly to peers.

What an interviewer would ask next. Try answering before peeking at the approach.

QHow would you actually prune the handoff graph to make cycles impossible?

Model the allowed handoffs as a directed graph and require it to be acyclic (a DAG). If A can hand to B, B's handoff list excludes A; B can instead escalate to a terminal 'reviewer' or 'human' agent. Verify acyclicity in your test suite by graph traversal.

2 more follow-ups an interviewer would ask next. Sign in to reveal them.

Red flags & common mistakes

The phrases that signal junior thinking. Click to expand.

Most common mistake

Treating the cap as the fix rather than the floor. A cap stops the bleeding; only tightened prompts and a pruned handoff graph prevent the wound.

60 second bullets to scan on the way to the call.

What a swarm topology is and why it is prone to loops
The three causes of talk loops (overlapping prompts, missing termination criteria, no ACL)

Primary sources. Browse if you want the original framing.