TL;DR
The study shows that agents that pass each other only numbers or verdicts almost never reach the correct group decision. When an agent adds an explanation with concrete facts to its position, the group solves the task correctly in most runs. Each agent got one “secret” fact, and the right group answer could only be reached by combining all of them.
Without explanations, agents see each other's numbers but not where those numbers came from. They drift toward the room average and get stuck on the wrong answer. A neutral filler sentence with no facts doesn't help at all: what matters is information, not word count. There's a second catch, too. When facts need to be reconciled (a duplicate stated in different units, a contract and its cancellation), most models fail even when they share explanations. And agents can agree with each other on the wrong answer: agreement is not correctness.
The practical takeaway is simple. In each agent's instructions, spell out the message format: position + the fact it rests on + what you changed after reading others' messages. For catching duplicates and cancellations, add a separate step or a separate agent.
Want this for your own case? Apply this study to your task: AI adapts its method to what you are working on and writes the prompt.
Method Blueprint
The paper measures an agent network rather than proposing a single prompt. The practical part boils down to the exchange format:
STEP 1: Agent receives its fact → computes its own estimate
STEP 2: Posts a MESSAGE = position (number) + explanation with the fact
STEP 3: Reads colleagues' messages → revises its position
(repeat for several rounds)
STEP 4: Final result = a predefined rule (median / mean)
STEP 5 (for messy data): separate fact reconciliation — duplicates, cancellations, units
Three message formats were compared:
reasoning: number + explanation with the fact → works
numbers: number only → doesn't work
filler: number + the same fact-free sentence → doesn't work
You can set all this up across several chats or in an agent environment where agents read a shared log.
Example
Task: The operations team at an Amazon delivery station in Chicago is planning shifts for Black Friday week. They need to decide how many people to put on three roles: inbound receiving, customer pickup, and returns packing. The information is scattered: - the logistics lead knows about a shipment schedule change; - the marketer knows about a promo code; - the shift supervisor knows about vacations.
Each fact changes the estimate. We spin up three or four “expert” agents, each holding its own fact.
Prompt (system instruction for each agent; swap in that agent's fact):
<Role>
You are a member of a group planning shifts at an Amazon delivery station for Black Friday week.
You hold ONE private fact. Your colleagues hold the other facts.
The group's result is the median of your final estimates. You don't need to agree with the others:
your job is to make sure the final estimate comes out right.
</Role>
<Baseline>
Volume: receiving 600 packages/shift, pickup 900, returns 150.
Throughput: receiving 100/person, pickup 150/person, returns 30/person.
Baseline estimate: receiving 6, pickup 6, returns 5.
</Baseline>
<MyFact>
The shipment from the fulfillment center will arrive a day early: +25% to receiving on Monday and Tuesday.
</MyFact>
<MessageFormat>
Each round, send your colleagues a message in exactly this form:
Position: receiving = X, pickup = Y, returns = Z (people per shift)
My fact: [the fact verbatim, with numbers]
How it changes the estimate: [calculation in 1-2 lines]
What I took from colleagues: [which facts from their messages you used and how your position changed; if nothing changed, say why]
</MessageFormat>
<Rules>
- Never send numbers alone. Always include the fact and the calculation.
- When reading colleagues' messages, use their facts, not just their numbers.
- If two messages describe the same event in different words or units, count it once.
- If a fact is canceled by another message, ignore it.
</Rules>
Result: each round, the agents post messages in the same format: position, fact, calculation, and what they took from colleagues. You can see the estimates converge and why: which fact moved which position. The final median should land closer to the answer you'd get from all facts at once. If facts are duplicated or canceled, the duplicates-and-cancellations rule raises the odds of a correct answer but doesn't guarantee it (more in the limitations section).
Why It Works
The weakness. If an agent sees only a colleague's number, it has no idea which fact it rests on. From “8 people” you can't tell whether that's an adjustment for the shipment or for vacations. The agent is left guessing and averaging. The group converges on something in the middle, but not on the right answer.
The strength. Models are good at combining facts from text and recalculating an answer when the fact is right in front of them. A short message with a concrete number (“+25% to receiving”) is easy for another agent to pick up and plug into its own calculation.
How the method exploits this. The message format forces agents to bring the fact into the shared conversation. Other agents get raw material for their math instead of a finished conclusion. A neutral fact-free sentence doesn't help, which means “just talk more” doesn't work: you need actually useful information.
Control levers:
- Strict message format (My fact, How it changes the estimate) → keeps the agent from getting away with a bare number.
- The “What I took from colleagues” field → forces agents to read others' facts, not others' numbers.
- Aggregation rule (median or mean) → sets a shared goal without a “reach an agreement” command.
- Duplicate and cancellation rules → cover the weakest spot. For messy data, hand reconciliation to a separate agent.
- Number of rounds → in the paper, accuracy kept rising from round two to round ten, but 3-4 rounds are enough for simple tasks.
Prompt Template
<Role>
You are a member of a group of {number_of_participants} agents. The group's task: {task}.
You hold ONE private fact. Your colleagues hold the other facts.
The group's result is {aggregation_rule}. You don't need to agree with the others:
your goal is for the result to come out right.
</Role>
<Baseline>
{shared_input_data_and_formulas}
</Baseline>
<MyFact>
{private_fact_with_a_concrete_number}
</MyFact>
<MessageFormat>
Each round, send a message in exactly this form:
Position: {what_we_estimate_and_units}
My fact: [the fact verbatim, with numbers]
How it changes the estimate: [calculation in 1-2 lines]
What I took from colleagues: [which facts you used and how your position changed; if it didn't change, why]
</MessageFormat>
<Rules>
- Never send numbers alone. Always include the fact and the calculation.
- Use your colleagues' facts, not just their numbers.
- If two messages describe the same event in different words or units, count it once.
- If a fact is canceled by another message, ignore it.
</Rules>
What to fill in:
- {task}: what you're estimating (shifts, budget, project timeline).
- {aggregation_rule}: median, mean, the manager's call.
- {shared_input_data_and_formulas}: what everyone already knows.
- {private_fact_with_a_concrete_number}: different for each agent, always with a number or a marker. That makes it easy to check whether the fact reached the others.
🚀 Quick start — paste into a chat:
Here is an instruction template for agents that exchange facts and reach a shared estimate. Adapt it to my task: [your task].
Ask me questions to fill in the fields.
[paste the template above]
The LLM will ask who the participants are, which fact each one holds, what formula produces the result, and how estimates are combined. It needs this so that every agent has its own fact and the message format forces it to pass that fact on. It will take the pattern from the template and assemble ready-to-use instructions for each agent.
Limitations
⚠️ Fact-reconciliation tasks: when the job is to spot a duplicate in different units or a canceled contract, nearly all GPT-family models failed (a handful of successes out of forty), even with explanations. Only two strong Claude models pulled it off. Don't count on “explanations” to handle this kind of reconciliation on their own.
⚠️ Agreement ≠ correctness: without explanations, agents often converged with each other, but on the wrong answer. If you judge the group by “everyone agrees,” you'll mistake a failure for a success. Check the result against an independent calculation.
⚠️ You need a checkable answer: the author used numeric tasks with a computable “correct” answer. Open-ended decisions (“which strategy should we pick”) need their own quality criteria.
⚠️ Correct facts don't guarantee understanding: a “fact mentioned” label doesn't prove the agent understood it. The authors acknowledge this.
⚠️ The weak model drops out: the smallest Claude model did worse than the rest even with explanations. For roles that demand accuracy, use a stronger model.
⚠️ One author, one task type: shift planning on fixed scenario sets, in low reasoning-effort mode. Carry it over to other tasks with care.
How They Tested It
The author built a network of 4-6 agents, each in its own container. The task was shift planning: every agent got one fact about the coming week, and the correct answer could only be derived from all the facts together. The agents were not told that answer and were not asked to agree.
Three message formats were compared: number + explanation, number only, and number + the same filler sentence every time. The last one is a control: it tests whether extra text by itself helps. Six models were run (three from Claude and three from GPT), with 8 scenarios, 5 repeats and 10 rounds each. That's 1,872 runs in total.
Explanations win big on the simple task: a correct and agreed-upon decision in 92% of runs versus 3% for “numbers only” and 0% for “filler.” That's the headline result: without facts in the exchange, you can't get information out of one agent's head.
The second task added a duplicate (the same contract in different units) and a canceled contract. Here the models split: Sonnet and Opus almost always handled it, the GPT models almost always didn't. What's more interesting: in the “numbers only” format, 16% of runs ended in agreement on a wrong answer. The agents converged with each other, just not with reality.
Also from the results: in 19% of reconciliation runs the group reached the correct answer first and then lost it. So looking only at the final state isn't enough; you need to track the trajectory.
A separate experiment looked at agents leaving and joining. If the departing agent had been posting explanations, the group kept solving the task correctly (41 out of 48 with a silent exit). If the agent that left had posted only numbers, the group lost that information: for many models, success dropped to zero or near zero. Knowledge lives in the message log, not in the agent's head.
Adaptations and Extrapolations
🔧 Technique: exit ritual → no information lost on handoff
From the experiment with departing agents: if an agent is finishing its work or handing the task to another, add this to its instructions:
Before you finish, post a final message to the shared log:
every fact you know, with numbers, and how each one affects the result.
Don't send just the conclusion.
In the paper, a departing agent's explanations stay in the history and save the group's decision. This carries the principle over to handoffs between agents in a chain (the paper doesn't directly test this instruction).
🔧 Technique: a dedicated reconciler → patching the weak spot
The weak spot in the second task (duplicates, cancellations) suggests an idea the authors didn't test: add an agent with no fact of its own whose only job is to reconcile the messages.
You are the reconciler. Don't contribute facts of your own. Read every participant's messages and write out:
1) the list of unique facts (with units);
2) which messages describe the same event;
3) which facts have been canceled;
4) the final estimate, recalculated using only the current facts.
This is an extrapolation: test it on your own data.
Resources
- Measuring Consensus in AI Agent Networks — Jin Gao, independent researcher (USA), 2026.
- Related work from the references: HiddenBench and Systematic failures in collective reasoning under distributed information in multi-agent LLMs (Li, Naito, Shirado, ICML 2026); SILO-BENCH (Zhang et al., ACL 2026); DEBATE (Chuang et al.); When truth is distributed (Yan et al.).
- Agent-to-agent messaging protocol: A2A (Agent2Agent).