TL;DR
ReGround is a three-step procedure for situations where several agents or sources bring in data and some of that data is false. First, the model identifies the unreliable source by spotting contradictions between reports. Then it breaks the shared context into individual facts and keeps only the confirmed ones. Only after that does it answer the question, using the now cleaned-up state.
The key finding: a right answer doesn't mean the shared picture is right. Agents often answer correctly simply because the current question doesn't touch the corrupted facts. The false fact stays in the shared context. It goes off later, when the next task or another agent picks up that information. As long as you only look at the answers, everything seems fine. The error surfaces at the worst possible moment. Ordinary "discussion" between agents barely fixes these errors. They rarely find the unreliable source and rarely clean up the shared context.
The fix is simple: add an explicit verify-and-clean step before the context becomes shared and trusted. The method was tested on several model families, and it improved every metric. It does best at fixing the quality of the shared state, while answer accuracy rises noticeably less.
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
STEP 1: Source check (do NOT show the shared context)
→ find pairs of contradicting reports
→ the other reports support/refute each side
→ the less-supported source → into candidate list K
→ repeat M times
→ rate each candidate's reliability using reports outside K
→ output: "unreliable source: X"
STEP 2: State reconstruction
→ break the shared context into atomic facts (one fact = one idea)
→ check each one against trusted sources
→ supported → keep; contradicted/unconfirmed → remove
→ add facts from trusted reports
→ output: clean shared state
STEP 3: Answer the question using only the clean state
You can run it all as one prompt in a chat or as three sequential requests.
Example in Action
Task: An entrepreneur is buying a bakery franchise in Austin. Three assistants (three separate chats) put together reports: a lawyer on the contract, a finance person on the numbers, a marketer on the location. A false fact has crept into the shared brief someone already wrote: "the lease runs through 2031." The lawyer sees an end date of 2026 in the contract. Today's question is simple: "Will this location pay for itself in 18 months?" The answer may come out right without the lease term at all. But tomorrow the question will be "Should we take a 5-year loan?" and the false fact will surface.
Prompt:
<Role>
You are a shared-context auditor. Your job is not to answer the question right away,
but first to clean unreliable facts out of the shared brief.
</Role>
<Inputs>
<SharedContext>
Hearth & Crumb bakery franchise, Austin, South Congress Ave. The lease runs through 2031.
Franchise fee $45,000. Foot traffic 1,800 people per day. Average ticket $9.40.
</SharedContext>
<Report agent="Lawyer">
The lease is signed through 12/31/2026; renewal by mutual agreement of the parties.
Franchise agreement for 5 years. Royalty 6% of revenue.
</Report>
<Report agent="Finance">
Location revenue per the franchisor's data: $48,000 per month. Costs: rent $7,800,
payroll $15,000, ingredients 38% of revenue. Lease term in the documents: through 2026.
</Report>
<Report agent="Marketer">
Foot traffic on South Congress: about 1,800 people per day. Competitors within 200 m: three
coffee shops. Average ticket in the area: $8.50–$9.80.
</Report>
<Question>
Will the location pay for itself in 18 months? What are the risks for a 5-year loan?
</Question>
</Inputs>
<Procedure>
Stage 1. SOURCE CHECK (do not use SharedContext at this stage)
Repeat 2 times:
- Find a pair of reports that contradict each other.
- For the remaining reports, say whether they support or refute each side.
- Add the less-supported source to list K.
Then for each source in K, rate its reliability from 0 to 10, relying only
on reports outside K. Name the unreliable source. If there are no contradictions, say so.
Stage 2. STATE RECONSTRUCTION
- Break SharedContext into atomic facts (one claim = one line).
- For each fact: SUPPORTED / REFUTED / UNCONFIRMED, citing the report.
- Keep only SUPPORTED facts. List removed ones separately with the reason.
- Add important facts from trusted reports.
- Output the "Clean State" as a list.
Stage 3. ANSWER
Answer the Question relying ONLY on the "Clean State". If there aren't enough
confirmed facts to answer, say exactly which ones are missing.
</Procedure>
Result: The model returns three blocks. The first breaks down the contradiction: the lease term in the brief versus the contract and the finance documents. The shared brief (or whoever wrote it) turns out to be the unreliable source. The second has a table of facts with statuses and a list of removed items, including "lease through 2031." Then comes the clean state. The third is the payback answer with a caveat that the lease ends in 2026. That is the main risk for a 5-year loan.
Why It Works
The weakness. If you just put agents in a discussion, they solve the current question instead of keeping the shared picture clean. A false fact that's irrelevant to the question bothers no one. So no one refutes it. On top of that, there's a strong distribution effect: when information is scattered across agents, the shared state suffers more than the answer does. The answer to a specific question holds up longer.
The model's strength. It's good at checking a specific short claim against a specific text. "Is this fact supported by the lawyer's report?" is easier than "find where an error crept into the brief." The model is also decent at spotting a contradiction between two texts.
How the method exploits this. It turns a vague "check everything" into a chain of small checks. First we hunt for the unreliable source through contradictions, with the shared brief deliberately hidden, since it may be corrupted itself. Then we slice the brief into atomic facts, and each fact is checked on its own. The answer is built on the clean state. The error doesn't survive to the next task, because the state is cleaned before answering.
Control knobs: - Number of conflict-search iterations (2 in the template) → raise it if you have many sources; lower it for 2–3 reports. - The "remove" condition → you can drop only "refuted" facts and keep the "unconfirmed" ones. You lose less information, but the risk of something false remains. - Hiding the shared context in Stage 1 → don't remove this: if the brief contains a falsehood, it will throw off the source check. - Agent names → give real roles (lawyer, finance) so the model cites sources specifically. - The last step → replace the answer with writing the "clean state" to a file or the agent's memory: then all later work starts from the cleaned version.
Prompt Template
<Role>
You are a shared-context auditor. First you clean unreliable facts out of the shared
brief, and only then do you answer the question.
</Role>
<Inputs>
<SharedContext>
{shared_brief}
</SharedContext>
<Report agent="{role_1}">{report_1}</Report>
<Report agent="{role_2}">{report_2}</Report>
<Report agent="{role_3}">{report_3}</Report>
<Question>{question}</Question>
</Inputs>
<Procedure>
Stage 1. SOURCE CHECK (do not use SharedContext at this stage)
Repeat {M} times:
- Find a pair of reports that contradict each other.
- Say how the remaining reports support or refute each side.
- Add the less-supported source to list K.
Then for each source in K, rate its reliability (0–10), relying only
on reports outside K. Name the unreliable source or write "no contradictions."
Stage 2. STATE RECONSTRUCTION
- Break SharedContext into atomic facts (one claim = one line).
- For each fact: SUPPORTED / REFUTED / UNCONFIRMED + a citation to the report.
- Keep only SUPPORTED facts. List removed ones separately with the reason.
- Add facts from trusted reports.
- Output the "Clean State" as a list.
Stage 3. ANSWER
Answer the Question relying ONLY on the "Clean State".
If there aren't enough confirmed facts, list which ones are missing.
</Procedure>
What to fill in: {shared_brief} is the text everyone already treats as shared (a summary, brief, notes). {report_N} are the findings of individual agents, chats or people. {M} is the number of conflict-search iterations (1–3). {question} is what you're deciding right now.
This template was assembled from the method's description in the paper: the authors' own prompts are in an appendix and aren't in the available text.
🚀 Quick start — paste into a chat:
Here's the ReGround template (clean the shared context before answering). Adapt it to my task: [your task].
Ask me questions to fill in the fields.
[paste the template above]
The LLM will ask what sources and reports you have, what counts as the "shared brief," and what question you're deciding now. That's because the method rests on three things: separate sources that can be checked against each other, a shared text that needs cleaning, and a specific question. It will take the stage structure from the template and fit it to your data.
Limitations
⚠️ You need independent sources: the method finds falsehoods through contradictions between reports. If there's only one source, or everyone repeats the same mistake, there's nothing to check against.
⚠️ The main test has one unreliable source: in the core setup, exactly one agent brings in false data. The authors cover cases with several unreliable sources separately, but the available text has no details. The more false reports, the weaker the footing.
⚠️ Losing useful info: facts no one confirmed get removed. If you have few sources, some of the truth won't make it into the clean state either.
⚠️ Costlier than a plain discussion: instead of one answer you get several verification passes. For simple tasks with one or two facts, it's overkill.
⚠️ Lab conditions: the falsehoods in the tests were invented by a model and are "plausible" the way GPT-4o makes them. Testing covered medicine and disaster response. Real-world lies can be sneakier or cruder. For critical decisions, a human should still check the final result.
⚠️ A stronger model doesn't cure it: stronger models answer better but don't clean the state any better. Don't count on "the next version."
Resources
- Paper: Right Answers, Wrong States: Hidden Information Failures in Multi-Agent Collaboration
- Code and data: https://github.com/whr000001/OffQuery
- Authors: Herun Wan, Minnan Luo, Zihan Ma (Xi'an Jiaotong University); Jiaying Wu, Min-Yen Kan (National University of Singapore); Fanxiao Li (Yunnan University); Nancy F. Chen (A*STAR, Singapore)
- Related: FActScore (Min et al., 2023), the basis for splitting text into atomic facts; the MediQ and CrisisFacts datasets