acceptodds
Under review as a conference paper at ICLR 2027

BRIDGE: Selective Boundary Repair with Dependency Graph Evidence in Multi-Agent Systems

Abstract

Multi-agent collaboration has emerged as a critical paradigm for tackling complex, long-horizon tasks; however, while coordination protocols continue to advance, systemic failures at the inter-agent collaboration interface remain a pervasive bottleneck. In collaborative workflows, systems frequently suffer from broken handoffs—where critical task context is omitted, misrouted, or ignored despite each agent emitting locally plausible responses. To address this challenge, we present BRIDGE, a verifiable runtime control framework that treats handoff repair as selective intervention over explicit dependency graphs. Central to BRIDGE is an integrated fault-attribution and calibration pipeline, HandoffProbe, which decouples execution dependencies and injects counterfactual handoff perturbations to provide empirical supervision for runtime intervention. Leveraging this diagnostic foundation, BRIDGE dynamically compiles observable interaction traces into a provenance graph to pinpoint unresolved dependencies, without accessing private agent states. It then evaluates candidate repairs through an empirical gate that weighs expected gains against disruption risks, and executes repairs only when formal local postconditions hold. Extensive evaluations across demanding benchmarks demonstrate that BRIDGE boosts task success by up to 12.3 absolute percentage points on SILO-BENCH and 11.1 on TeamBench. Across both backbones, BRIDGE maintains strict cost-effectiveness, adding as little as 2.0% marginal token overhead. Furthermore, on 562 handoff-relevant traces from the MAST benchmark, BRIDGE achieves 69.8% F1 in a single pass, establishing a reliable operational boundary for verifiable coordination repair.

Primary area:
foundation or frontier models, including LLMs
Keywords:
multi-agent systems, large language models, LLM agents, multi-agent collaboration

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_BqaZOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
3
Soundness
1
Read review
Paper summary

BRIDGE addresses a failure mode in multi-agent systems. Its contribution is selective repair of broken inter-agent handoffs, using dependency graphs, offline intervention calibration, and pre-release verification. Its reported performance gains are good, and the ablations are informative. However, several technical claims are stronger than the supplied evidence supports, especially regarding verification guarantees, causal attribution, and transactional correctness. One concern is the authors should have done a thorough paper survey to properly position their contribution.

Critical strengths
  1. The paper addresses an important problem. In a distributed system that every individual agent may appear competent, but the collective fails because an essential dependency is not accounted for between agents. The paper addresses this problem in three parts:

Provenance graph: Identify which required information was produced, delivered, consumed, or misrouted. HandoffProbe: Estimate offline whether a particular repair is likely to help or harm. Verified release: Allow a repaired message to proceed only after an explicit local postcondition passes.

  1. The important idea is not just repairing a message. It is deciding whether it's worthy to repair at all.
Critical weaknesses

1. The paper misses a number of critical related work addressing the same or similar problems. I would advise the authors to enumerate their contributions with respect to these recent papers.

AgentAsk (ACL 2026) , MOC (ICML 2026) , MAST (NeurIPS 2025), SagaLLM (PVLDB 2025)

2. There are at least three potential over-claims with no supporting evidence:

2.1 Narrow the transaction claim to local verify-before-release, or implement genuine cross-component recovery. Cross-component recovery is non-trivial.

2.2 Report the experimental unit and task-clustered statistical analysis, or the performance claims are not proven to be statistically reliable.

2.3 Compare with 30-year work in the transaction processing domain, started by Jim Gray in 1908s; and in particular, the recent work SagaLLM, to sharpen novelty claims.

Questions for authors
  1. Please answer your contributions with respect to the list of related work. Can you do a direct novelty-by-mechanism comparison?

  2. Can you do a false-positive repair study? In this study, consider cases in which a dependency appears missing or malformed, but the native workflow would already succeed. Then measure how often BRIDGE intervenes incorrectly, how much harm it causes, and whether calibration reliably rejects those interventions.

8 comments
AuthorsOpenReview ↗

Response to Reviewer BqaZ (part 1)

Thank you for your helpful comments on related work and system scope. Our responses to each point are given below.

W1: Related Work and Novelty

W1.1 & Q1: Missing related work (AgentAsk, MOC, MAST, SagaLLM) and direct novelty-by-mechanism comparison.

AgentAsk, MOC, and MAST are cited in Section 2 and compared in Tables 2–3. In the revised paper, we will add SagaLLM (PVLDB 2025) and include the following comparison of problem scopes and mechanisms:

SystemTarget ProblemIntervention TimingControl ScopeMain Mechanism
MAST (NeurIPS 2025)Failure taxonomy and attributionPost-hoc (after execution)Full execution traceLabels failure modes on completed traces
AgentAsk (ACL 2026)Ambiguous instructionsPre-dispatch (at handoff)Single messagePrompts an LLM to ask clarification questions
MOC (ICML 2026)Context length and multi-hop routingDuring message routingMulti-hop message historySummarizes earlier messages under a token budget
SagaLLM (PVLDB 2025)Workflow state consistency and recoveryPost-commit (after action execution)Multi-step workflow stateTracks state constraints and runs compensating actions to undo failed steps
BRIDGE (Ours)Inter-agent handoff omissionsPre-dispatch (before message release)Single handoff boundaryTracks fact delivery and consumption in a graph, gates repairs by offline priors, and checks postconditions in a local buffer
  • AgentAsk (Lin et al., ACL 2026): Uses an LLM prompt to ask peers for clarification. Because it does not track whether facts were already delivered or gate interventions by expected utility, it can over-intervene (lowering GPT SILO-BENCH from 68.9% to 65.6%, vs. 77.8% for BRIDGE).

  • MOC (Guan et al., ICML 2026): Summarizes multi-hop message history to save tokens, but does not check whether the receiving agent actually uses the delivered facts (scoring 63.3% on GPT).

  • MAST (Cemri et al., NeurIPS 2025): Defines 14 failure modes for post-hoc trace analysis, without runtime intervention.

  • SagaLLM (Chang & Geng, PVLDB 2025): SagaLLM and BRIDGE study different problems at different stages of execution. SagaLLM focuses on multi-step workflow consistency and post-commit recovery: when an external action fails or violates a workflow constraint, SagaLLM generates and executes compensating actions to restore overall workflow state. In contrast, BRIDGE focuses on message handoffs between agents before the message is released downstream. The two approaches are complementary: BRIDGE filters handoff omissions before message delivery, while SagaLLM recovers external workflow state after multi-step execution failures.


AuthorsOpenReview ↗

Response to Reviewer BqaZ (part 2)

W2: Transaction Scope, Statistics, and Positioning

W2.1: Narrow the transaction claim to local verify-before-release, or implement genuine cross-component recovery.

We agree. We will replace the word "transactional" throughout the paper with "verified release" and "local verify-before-release":

  • What BRIDGE does: Candidate repairs run in a local staging buffer. If the postcondition check passes (Check = 1), the controller releases the updated message; otherwise, it restores the local graph state and sends the original message.

In the MAST dataset, 98.2% of traces involve code and reasoning dialogues rather than stateful external APIs (1.8%, AppWorld), and 88.1% of handoff errors co-occur with later execution errors. Checking handoffs before release stops missing context early without needing distributed locks.


W2.2: Report the experimental unit and task-clustered statistical analysis.

  1. Experimental units: TeamBench and DeepSeek SILO-BENCH run 1 rollout per task across 90 tasks (n=90n = 90 independent tasks). MAST evaluates 562 independent traces. On GPT SILO-BENCH (3 seeds across 90 tasks), Table 2 reports the sample standard deviation (±SD\pm\text{SD}) across the 3 seeds (we will change ±SE\pm\text{SE} to ±SD\pm\text{SD} in Appendix D.2).

  2. Task-clustered test: Treating each of the 90 tasks on GPT SILO-BENCH as one unit (di∈[−3,+3]d_i \in [-3, +3]), a two-sided paired Wilcoxon signed-rank test gives p=0.0029p = 0.0029 (19 tasks with net gains, 6 with net losses, 65 ties, and 0 tasks with d≤−2d \le -2).


W2.3: Compare with 1980s transaction processing theory and SagaLLM to sharpen novelty claims.

Classic database transactions (Gray, 1980s) use locks and two-phase commit to guarantee all-or-nothing execution across nodes. SagaLLM adapts the saga pattern to multi-step LLM workflows by checking workflow constraints and running post-commit compensating actions when a step fails. BRIDGE addresses a narrower, earlier step: checking a single inter-agent message in a local buffer before sending it to the next agent. To compare global workflow validation with local handoff graph diagnosis on static traces, we adapted SagaLLM's two-phase validation pipeline to the 562 MAST traces under DeepSeek-V4.1-flash (using the same setup as Table 3 and Table 9):

MethodTokens / Trace ↓Mode 2.4 F1Mode 2.5 F1Macro-F1Overall F1 (%) ↑ (Table 3)Control Handoff FPR (n=278) ↓
Direct Prompting6,686.034.562.29862.544.2%
BRIDGE (Ours)9,116.142.613.37768.664.4%
SagaLLM (adapted)15,236 (+67.1%).145.614.37968.874.8%

Breakdown of SagaLLM alerts on the 278 control traces (which have no handoff failures):

Control SubsetTraces (n)Handoff False Positive RateWorkflow Violation RateCompensation Triggered
All control traces27874.8% (208/278)83.1%63.3% (176/278)
Controls with non-handoff errors (e.g., tool/runtime errors)22184.2%91.9%71.0%
Clean controls (zero MAST errors)5738.6%49.1%33.3% (19/57)

This comparison shows how the two designs match their intended goals:

  • Diagnostic accuracy and token cost: SagaLLM and BRIDGE reach similar handoff F1 scores (Macro-F1 0.379 vs. 0.377, overall F1 68.8% vs. 68.6%, paired McNemar p=0.736p = 0.736). Because SagaLLM extracts workflow state tables and runs global validation in two calls, it uses 15,236 tokens per trace compared to 9,116 for BRIDGE (+67.1%).

  • Difference in target scope: On the 221 control traces that contain non-handoff errors (such as tool failures or runtime crashes), SagaLLM flags workflow violations on 91.9% of traces and triggers compensation on 71.0%. This happens because SagaLLM is designed to catch broad workflow execution failures, whereas the MAST metric here only scores handoff failures. BRIDGE focuses specifically on inter-agent handoff edges and further filters alerts through an offline utility gate before acting.

AuthorsOpenReview ↗

Response to Reviewer BqaZ (part 3)

Q2: False-Positive Repair Study

Q2: False-positive repair study.

Below are four examples from our benchmarks where Native execution succeeds, showing how BRIDGE avoids breaking working trajectories:

  1. SILO-BENCH global distinct count task (utility gate abstention): Two agents hold private number sets and must count the total unique numbers (28). In Round 1, before the agents share their sets, the provenance graph flags a missing fact and proposes an ASK action. The utility gate abstains. In Rounds 2 to 6, the agents share their sets on their own and both submit 28.

  2. TeamBench protocol bridge task (utility gate abstention during coding): Twice during Planner-to-Executor handoffs, the draft message leaves out references to earlier contract details, which raises a candidate rewrite. The utility gate abstains both times, and the coding agent fixes all bugs and passes all 12 unit tests.

  3. SILO-BENCH distributed XOR task (local rollback on failed check): During a forced INTEGRATE probe test, Agent 0 sends a short reply in Round 1. BRIDGE generates a candidate rewrite in the local staging buffer. Because the rewrite fails the postcondition check, BRIDGE discards the rewrite in the buffer and sends the original message. The agents finish the task normally and submit the correct answer (251).

  4. MAST clean programming trace (graph consumption tracking): In a clean trace where all tests pass, the tester agent updates a test as requested by the reviewer agent. In the final turn, the reviewer confirms the test is correct and adds a general comment. Direct Prompting and SagaLLM misclassify this final comment as an ignored instruction, whereas BRIDGE's provenance graph sees that all 5 earlier handoffs were already consumed and outputs pass.

In short, the utility gate and local postcondition check work together as a two-stage filter that prevents unnecessary or faulty repairs from breaking successful runs. We will add this study to the Appendix, and we thank you again for your valuable suggestions.

Reviewer_dGBKOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes BRIDGE, a runtime framework for repairing information handoffs in multi-agent systems. It addresses missing evidence, evidence that a recipient fails to use, and errors in context routing. HandoffProbe introduces faults into offline trajectories and compares continuations with and without repair to estimate the benefits and risks of intervention.

At runtime, BRIDGE builds a dependency graph of agent interactions and checks for unresolved information requirements. A calibrated utility gate selects a repair, and a local check determines whether to keep the changed handoff or restore the original state.

The evaluation covers SILO-BENCH and TeamBench with two models, plus a 562-trace MAST subset for failure diagnosis. The authors report improved task success and diagnosis with low token overhead. My main concerns are the conflicting descriptions of repair, inconsistent cost accounting, and success counts that do not agree across tables.

Critical strengths
  • Selective intervention addresses the risk of harmful repairs. HandoffProbe compares repairs from the same faulty execution prefix and labels them as helpful, harmful, or neutral. BRIDGE checks whether a repair is feasible, estimates its benefit, and verifies its result before committing it (Sections 3.2 to 3.5). These checks give the controller a concrete way to avoid unnecessary or harmful changes.

  • The evaluation measures both task recovery and failure diagnosis. Table 2 reports improved success across two task suites and two models. The 562-trace MAST evaluation includes errors unrelated to handoffs, testing whether the diagnosis can distinguish handoff failures from other problems (Appendix C.1 and Table 8). Together, these experiments assess whether repairs help and whether the controller identifies the right failures.

Critical weaknesses
  • The paper gives conflicting descriptions of repair and its cost. Section 3.5 says INTEGRATE requires no LLM inference. Appendix F.2 instead reports 41 full-message reconstructions, and Table 14 assigns this operation 4,260 tokens per DeepSeek task. Table 14 also gives total overheads of 20.4% for GPT and 50.5% for DeepSeek, compared with the headline 2.0% GPT figure. The paper does not explain how these implementations and costs support its efficiency claim. Appendix F.1 also says costly repair generations were bypassed, leaving the interventions behind GPT's improvement unclear.

  • The success counts do not agree, and the statistical analysis is unclear. TeamBench has 90 tasks per method. Table 2's DeepSeek success rates of 48.9% and 60.0% imply 44 and 54 successes, a gain of ten. Table 12 instead lists 12 BRIDGE-only wins and three Native-only wins, a gain of nine. Appendix C.3 also calls the drop from 75.6% to 56.7% a 23.3-point decrease, rather than 18.9 points. Table 12 pools three GPT runs on the same 90 SILO-BENCH tasks without explaining how the analysis handles repeated tasks. These inconsistencies make the reported gains and uncertainty difficult to assess.

Questions for authors
  • Was INTEGRATE implemented as programmatic composition or LLM rewriting in Table 2?

  • Which costs are included in the 2.0% GPT overhead, and why does Table 14 report 20.4%?

  • Why does Table 2 imply ten additional TeamBench successes while Table 12 implies nine?

  • How do the standard errors and ablation tests account for repeated runs on the same tasks?

  • Which interventions explain GPT's 8.9-point gain when Appendix F.1 says costly repair generations were bypassed?

6 comments
AuthorsOpenReview ↗

Response to Reviewer dGBK (part 1)

We appreciate your careful reading of our paper and tables. We address each of your questions below.

W1: Mechanism, Cost Accounting, and GPT Interventions

W1.1 & Q1: Section 3.5 states INTEGRATE requires no LLM inference, whereas Appendix F.2 reports 41 full-message reconstructions (4,260 tokens/task in Table 14). Was INTEGRATE implemented as programmatic composition or LLM rewriting in Table 2?

In our implementation, INTEGRATE has two execution modes depending on whether the handoff content is structured data or free-form text:

  1. Programmatic update: When the missing fact is a structured value (such as a number or shard value in public history), the controller updates the message and checks the postcondition directly by code without calling an LLM. All GPT interventions in Table 2 used this mode.

  2. LLM message rewrite in the staging buffer (4,260 tokens/task in Table 14): When the missing fact must be inserted into free-form text or code instructions, simple string concatenation can break the message format. In this case, the controller runs one LLM call to rewrite the message inside a local staging buffer. Across the 90 DeepSeek tasks in Table 2, the controller ran 41 such rewrites. Each rewritten message is checked against its postcondition before release; if the check fails, the controller discards the rewrite and sends the original message.

Section 3.5 was inaccurate in stating that INTEGRATE always uses zero LLM tokens. We will revise Section 3.5 and Table 14 to describe both modes clearly.


W1.2 & Q2: Which costs are included in the 2.0% GPT overhead, and why does Table 14 report total overheads of 20.4% (GPT) and 50.5% (DeepSeek)? How do these support the efficiency claim?

Table 14 reports three cost rows:

  • Agent Communication (+2.3% / +588 tokens on GPT; +6.3% on DeepSeek): The sum of prompt token changes (+523 tokens / +2.1%) and output token changes (+65 tokens / +0.3%), which equals 523+65=588523 + 65 = 588 tokens (588/25,198=+2.3%588 / 25,198 = +2.3\%).

  • Official Agent Evaluation (+2.0% / +495 tokens on GPT; +24.5% on DeepSeek): Compares the agent evaluation total (25,69325,693 on GPT; 27,96327,963 on DeepSeek, which includes 4,260 tokens/task from active INTEGRATE rewrites) against Native (25,19825,198 on GPT; 22,46022,460 on DeepSeek). On GPT, 25,693−25,198=49525,693 - 25,198 = 495 tokens (+2.0%+2.0\%), where the 93-token difference from +588 comes from excluding timeout runs in the paired baseline set.

  • End-to-End (+20.4% on GPT; +50.5% on DeepSeek): Adds the controller boundary diagnosis tokens (4,566 tokens/task on GPT; 5,655 on DeepSeek) to give the total system token cost.

Compared to baselines like VeriMAP (+410% to +579% token increase), BRIDGE improves task pass rates (+8.9 to +12.3 percentage points) at a much lower token cost. We will update the Abstract and main text to report both the agent margin (+2.0% / +24.5%) and the total end-to-end cost (+20.4% / +50.5%).


W1.3 & Q5: Which interventions explain GPT's 8.9-point gain when Appendix F.1 says costly repair generations were bypassed?

The 8.9-point gain on GPT-5.6-Terra (68.9% to 77.8%) comes from two deterministic mechanisms that use zero LLM tokens:

  1. Precondition check before task submission: Under Equation (2), a final submission action requires that delivered peer facts have been consumed in the provenance graph. When an agent tries to submit a final answer while a peer message is still unconsumed (Fuse\mathcal{F}_{\text{use}}), the controller blocks the early exit and requires the agent to read the pending message first. In SILO-BENCH, this stops agents from submitting incomplete answers in Round 1 and lets them read the peer shard in Round 2 before computing the final result.

  2. Programmatic INTEGRATE and VERIFY on public facts (12 commits): When all peer values are already visible in the public message history, the controller checks whether the outgoing result matches the public inputs and updates inconsistent values using only public messages. At the same time, the utility gate abstains from LLM message rewrites on all 429 GPT boundaries. In Table 2, baselines that perform unguided LLM edits (AgentAsk 65.6%, Self-Refine 64.4%, MOC 63.3%) all score below Native (68.9%). By skipping LLM rewrites on GPT, the utility gate avoids these harmful edits while keeping the gains from deterministic graph checks. We will add this explanation to Section 4 and Appendix F.1.


AuthorsOpenReview ↗

Response to Reviewer dGBK (part 2)

W2: Statistics, Ablations, and Repeated Runs

W2.1 & Q3: Why does Table 2 imply ten additional TeamBench successes while Table 12 implies nine?

Table 2 reports results on all 90 tasks (48.9% to 60.0%, net gain of 10 tasks). Table 12 used an earlier subset of 75 tasks where 15 tasks had failed due to network or container errors (12 wins vs. 3 losses, net gain of 9 tasks). On all 90 tasks, BRIDGE has 13 wins and 3 losses (net gain of 10 tasks, exact binomial p=0.021p = 0.021), matching Table 2. We will update Table 12 in the revised paper.


W2.2: Why does Appendix C.3 call the drop from 75.6% to 56.7% a 23.3-point decrease rather than 18.9 points?

In the submitted paper, the ablations were run on the 30-task seed-0 subset, where the Full system scored 80.0% (24/30) and the ablated models scored 56.7% (17/30), which is a 23.3-point decrease (80.0%−56.7%=23.3%80.0\% - 56.7\% = 23.3\%). However, Table 4 listed the 90-task mean for the Full system (75.6%, 68/90), where 75.6%−56.7%=18.9%75.6\% - 56.7\% = 18.9\%. Mixing the 30-task drop (23.3 points) with the 90-task Full score (75.6%) in Appendix C.3 was an error. We will fix this in the revision.


W2.3 & Q4: Table 12 pools three GPT runs on the same 90 tasks. How do the standard errors (SEs) and ablation tests account for repeated runs on the same tasks?

  1. Standard deviation and task-level test on GPT: The ±\pm values in Table 2 on SILO-BENCH (GPT: 68.9±4.0%68.9 \pm 4.0\% vs. 77.8±1.1%77.8 \pm 1.1\%; DeepSeek: 63.3±3.3%63.3 \pm 3.3\% vs. 75.6±3.8%75.6 \pm 3.8\%) are the sample standard deviation (±SD\pm\text{SD}) across the 3 seeds. We will change the label (±SE)(\pm\text{SE}) in Appendix D.2 to (±SD)(\pm\text{SD}). To avoid pooling repeated runs across the 90 tasks, we ran a task-level paired Wilcoxon signed-rank test on the per-task net pass difference d∈[−3,+3]d \in [-3, +3] across the n=90n = 90 unique tasks: 19 tasks have net gains, 65 tie, and 6 have net losses (with zero tasks having d≤−2d \le -2), giving a two-sided p=0.0029p = 0.0029.

  2. Multi-seed 90-task ablation rerun: To evaluate the ablations across all 90 tasks and multiple seeds, we ran a new 3-seed paired ablation on DeepSeek-V4.1-flash (3 generation seeds ×\times 30 tasks = 90):

    • BRIDGE (Full System): 53.3% ±\pm 3.3%, 75,896 tokens/task.

    • w/o Local Verification (No Rollback): 50.0% ±\pm 10.0%, paired McNemar p=0.690p = 0.690, 71,223 tokens/task.

    • w/o Historical Experience Adjustment: 48.9% ±\pm 5.1%, paired McNemar p=0.557p = 0.557, 67,111 tokens/task.

    • w/o Utility Gate (Always Intervene): 47.8% ±\pm 6.9%, paired McNemar p=0.473p = 0.473, 85,046 tokens/task.

    In this 90-task rerun, the Full system achieves the highest mean score, the lowest cross-seed variance (±3.3%\pm 3.3\%), and 10.8% lower token usage than removing the utility gate. However, the paired pass-rate differences are not statistically significant (p=0.473p = 0.473 to 0.6900.690), and the experience log recorded zero card hits. We will include this complete 3-seed table and soften our claims on component significance in Section 4.4 and Appendix C.3.

Thank you for the authors' responses and additional experiments. However, my main concerns remain unresolved.

1. Repair mechanism and cost accounting.

The authors clarify that INTEGRATE supports both programmatic updates and LLM-based rewriting. However, the relationship between the 41 message reconstructions, approximately 4,900 prompt tokens per reconstruction, and 4,260 tokens per task remains unclear. The substantial differences between agent-level and end-to-end overhead (2.0% vs. 20.4% for GPT; 24.5% vs. 50.5% for DeepSeek) also require further clarification.

2. Ablation results and component effectiveness.

The newly reported success rate of the full BRIDGE system (53.3%) differs substantially from the original result in Table 4 (75.6%), and the authors have not adequately explained this discrepancy.

3. Attribution of GPT performance gains.

The authors attribute GPT's 8.9-percentage-point improvement to pre-submission dependency checks and programmatic INTEGRATE/VERIFY operations. While plausible, the individual contributions of these mechanisms have not been experimentally validated.

Overall, the responses address some of my concerns, but the remaining issues still undermine the evidence supporting the paper's claims. I therefore maintain my original score.

Reviewer_zArwOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

This paper addresses broken handoffs in multi-agent LLM systems, where an upstream agent omits or misroutes task-critical context, or a downstream agent receives it and ignores it, and the whole task fails. BRIDGE compiles the public interaction trace into a provenance graph at runtime, locates unresolved dependencies (frontiers), generates candidate repairs from a small set of primitives such as ASK and INTEGRATE, and decides whether to intervene using empirical utility priors calibrated offline. HandoffProbe learns these priors by injecting communication faults into historical trajectories and comparing paired continuations with and without repair, with outcomes judged by deterministic oracles rather than an LLM. A repair is committed only after a local postcondition check on the graph delta passes, and otherwise the controller rolls back to the native message. Experiments on SILO-BENCH and TeamBench compare against Native, AgentAsk, Self-Refine, MOC, and VeriMAP with DeepSeek-V4.1-flash and GPT-5.6-Terra, plus a diagnostic evaluation on 562 MAST traces. The main results are 63.3% to 75.6% on SILO-BENCH (DeepSeek) and 68.9% to 77.8% (GPT), 48.9% to 60.0% on TeamBench, marginal token overhead as low as 2.0% claimed in the abstract, and 69.8% F1 on the MAST traces in a single pass (GPT-5.6-Terra).

Critical strengths

I think the direction is right. Context loss at handoffs between agents is a real pain point, and deciding whether to repair at all, verifying the repair locally, and rolling back on failure is more reasonable than unconditional rewriting, while the deterministic oracle avoids LLM self-evaluation. The design is worth pursuing, which is why this is a weak reject rather than a reject. My reservations are about the evidence below.

Critical weaknesses
  1. It is unclear whether the gains come from repair. The paper itself states in Appendix F.1 that on GPT the gate abstained from repair on all 429 monitored handoff boundaries, and Table 14 shows 0 tokens of active repair for GPT, yet the SILO-BENCH success rate still rises by 8.9 points (68.9% to 77.8%, 36 wins vs. 12 losses, Tables 2 and 12). With no repair executed, the source of these 8.9 points is unexplained. TeamBench with DeepSeek does not add up either: 48.9% to 60.0% over 90 tasks is a net gain of 10 tasks (44 to 54), but Table 12 reports only 12 wins vs. 3 losses, a net of 9, one task short. Table 14 also contains an unexplained "+523" (prompt context variation) for GPT.

  2. The statistics are not clean. Appendix D.1 specifies three provider-seed runs over the same 90 instances for GPT on SILO-BENCH (DeepSeek runs one rollout per instance), and Table 12 pools these 90 tasks × 3 runs into n=270 for the paired test, but the three runs of the same task are not independent and cannot be treated as independent samples. The ablations are evaluated under a single reference seed (seed-0, Appendix C.3), and the two key ablations have p=0.063 and 0.070, neither significant (Table 4), yet the text calls empirical gating and transactional verification indispensable.

  3. The overhead is overstated. The abstract reports marginal token overhead as low as 2.0%, which holds only for GPT; Table 14 gives +24.5% for DeepSeek, and the end-to-end cumulative footprint is +20.4% for GPT and +50.5% for DeepSeek. The paper also never states who supplies the execution contract (O,R,V) and the fact specification set Q(O) that the controller relies on. If these are written manually per task, BRIDGE receives more supervision than the baselines.

Questions for authors
  1. [Clarification] Which repairs were actually committed on GPT?
  2. [Clarification] What exactly is the "+523" (prompt context variation) in Table 14, and did Native receive the same context?
  3. [Clarification] How are (O,R,V) and Q(O) obtained, and can the baselines access the same information?
  4. [Clarification] The TeamBench attestation requires "tests passed". Does the controller call the official evaluation tests before committing?
  5. [Suggestion] Figure 1 draws ASK as a successful repair while Table 7 shows ASK was not admitted on either backbone; please make these consistent. Please also add seeds to the ablations and report variance.
8 comments
AuthorsOpenReview ↗

Response to Reviewer zArw (part 1)

Thank you for your review. Below is our point-by-point response.

W1: Source of Gains and Verification

W1.1 & Q1: Where does the +8.9 percentage point gain on GPT come from when the utility gate abstained from active repair on all 429 boundaries, and which interventions were actually committed on GPT?

The +8.9 percentage point gain on SILO-BENCH with GPT-5.6-Terra (68.9% to 77.8%) does not come from LLM message rewriting. As noted in Appendix F.1, the utility gate abstained from LLM message rewriting across all 429 boundaries. Instead, the gain comes from two deterministic operations in our method that require zero LLM calls:

  1. Precondition check before task submission:

    • Method mechanism: In Section 3.2 (Equation 2), an action is eligible only when its required facts are satisfied in the provenance graph. When the provenance graph shows that required facts from another agent have been delivered but not yet consumed (an unconsumed delivery frontier, Fuse\mathcal{F}_{\text{use}}), a final task submission action does not meet its precondition. The controller blocks the early submission and requires the agent to read the pending handoff message first. The controller does not compute or change the task answer. The agent reads the message and computes the final answer on its own.

    • SILO-BENCH example: In distributed aggregation tasks, agents must exchange local data shards before submitting a final answer. Under Native execution, an agent often submits a final answer in Round 1 before reading its peer's message, which causes task failure. Under BRIDGE, the provenance graph detects the unconsumed peer message and delays submission until Round 2. The agent then reads the peer message and submits the correct result.

  2. Programmatic INTEGRATE and VERIFY on public facts (12 commits):

    • Method mechanism: As stated in Table 1 and Section 3.5, INTEGRATE and VERIFY can be executed by rule-based code when the required facts are already present in the visible message history. When all peer facts are visible in public messages, the controller checks whether the outgoing message matches those public facts and updates mismatched values using only the public history.

    • SILO-BENCH example: In distributed reduction tasks, when all peer values are already present in the public message log, the controller checks the final value against the public messages before release. Across all 270 GPT runs, this programmatic update was committed 12 times and used 0 LLM tokens.

Both operations depend on the core components of BRIDGE. First, the provenance graph tracks which required facts have been delivered and consumed. Second, the utility gate prevents unnecessary LLM rewrites on GPT-5.6-Terra. In Table 2, baselines without a utility gate (AgentAsk 65.6%, Self-Refine 64.4%, MOC 63.3%) all score below Native (68.9%) because unnecessary LLM edits disrupt valid trajectories. By abstaining from LLM rewrites on GPT, the utility gate avoids this degradation while keeping the +8.9 percentage point gain from deterministic graph checks. We will report programmatic graph actions and LLM rewrites separately in Section 3.5, Table 14, and Appendix F.1.


W1.2: Why does TeamBench with DeepSeek imply a net gain of 10 tasks in Table 2 while Table 12 reports a net gain of 9 tasks?

Table 2 reports results on all 90 tasks (48.9% to 60.0%, or 44 to 54 passed tasks, for a net gain of 10 tasks). Table 12 used an earlier table from 75 tasks where 15 tasks had stopped due to network and container errors (36 vs. 45 passed tasks, 12 wins vs. 3 losses, for a net gain of 9 tasks). On the full 90-task set, BRIDGE has 13 wins and 3 losses (net gain of 10 tasks, exact binomial p=0.021p = 0.021), which matches Table 2. We will update Table 12 in the revised paper to match Table 2.


W1.3 & Q2: What exactly is the "+523" (prompt context variation) for GPT in Table 14, and did Native receive the same context?

At the start of each task, Native and BRIDGE receive the exact same input prompt. The extra +523 prompt tokens per task come from normal dialogue history in later rounds when BRIDGE prevents an early exit:

  • Under Native execution, when an agent exits early in Round 1, the task ends after one call and uses only the Round 1 prompt tokens.

  • Under BRIDGE, when the controller blocks an early exit, the agent continues to Round 2 to read the peer message.

  • In standard multi-turn chat APIs, Round 2 includes the Round 1 messages in the prompt context. Because BRIDGE prevents early exits, agents run for 0.49 more rounds on average (+3.9% more model calls). The message history in these extra rounds adds an average of +523 prompt tokens per task in Table 14.

AuthorsOpenReview ↗

Response to Reviewer zArw (part 2)

W2: Statistical Significance and Component Necessity

W2.1: The three provider-seed runs on GPT-SILO are not independent; is the performance gain statistically reliable without pooling into 270 samples?

Repeated runs on the same task are correlated. To avoid pooling the 270 runs, we treat each of the 90 tasks as a single unit and compute the net difference in passes per task across the three seeds (di∈[−3,+3]d_i \in [-3, +3]).

  1. Task-level counts: Out of 90 tasks, 65 tasks are tied (d=0d = 0). BRIDGE beats Native on 19 tasks (d=+1d = +1 on 12 tasks, d=+2d = +2 on 3 tasks, and d=+3d = +3 on 4 tasks). Native beats BRIDGE on 6 tasks (d=−1d = -1 on 6 tasks, and 0 tasks with d≤−2d \le -2).

  2. Single-seed results: When each seed is tested separately (n=90n = 90 tasks per seed), BRIDGE has a positive net gain in all three seeds (+4, +10, and +10 tasks), and two seeds are individually significant (exact test p=0.013p = 0.013 and p=0.041p = 0.041).

We will update Table 12 to report this task-level test.


W2.2: The ablations yielded two-sided pp-values of 0.063 and 0.070; why does the text claim empirical gating and verification are "indispensable"?

First, we clarify the numbers in Table 4 and Appendix C.3. In the submitted paper, the ablations were run on a 30-task subset (seed 0), where the Full system scored 80.0% and the ablated models scored 56.7%. However, Table 4 listed the 90-task score for the Full system (75.6%) instead of its 30-task score (80.0%), which caused the mismatch between 18.9% and 23.3%.

Second, to address your request for multi-seed ablations across all 90 tasks, we ran a new 3-seed paired ablation (3 generation seeds ×\times 30 tasks = 90 tasks per condition, 360 runs total) on DeepSeek-V4.1-flash after fixing tool-call XML parsing:

ConfigurationMean ±\pm SD (%)Mean Tokens / Task
BRIDGE (Full System)53.3 ±\pm 3.375,896
w/o Local Verification (No Rollback)50.0 ±\pm 10.071,223
w/o Historical Experience Adjustment48.9 ±\pm 5.167,111
w/o Utility Gate (Always Intervene)47.8 ±\pm 6.985,046
From this 360-run experiment, we observe this:

Mean performance, variance, and token cost: The Full system has the highest mean pass rate (53.3%) and the lowest standard deviation across seeds (±3.3%\pm 3.3\%, compared to ±6.9%\pm 6.9\% without the utility gate and ±10.0%\pm 10.0\% without local verification). Removing the utility gate also increases token usage by 12.1% (85,046 vs. 75,896 tokens per task).

We will revise Section 4.4, Table 4, and Appendix C.3 to remove the word "indispensable", align the 30-task and 90-task denominators, and report these 3-seed results and limitations directly.


W3: Cost Transparency and Privileged Information

W3.1: Why does the abstract highlight a 2.0% marginal overhead while Table 14 reports +24.5% for DeepSeek and +20.4% / +50.5% end-to-end footprints?

Reporting only the 2.0% GPT number in the abstract was incomplete. Detecting missing facts and rewriting messages uses extra tokens. In the revised paper, we report both cost metrics from Table 14 in the abstract and main text:

  • Official Agent Evaluation Margin (agent messages plus active message repairs): +2.0% on GPT (+2.3% in agent messages and 0% in active repairs) and +24.5% on DeepSeek (+6.3% in agent messages and +19.0% from 41 message rewrites).

  • End-to-End Cumulative Footprint (including controller diagnosis): +20.4% on GPT and +50.5% on DeepSeek. This includes all controller boundary diagnosis calls (+18.1% or 4,566 tokens per task on GPT; +25.2% or 5,655 tokens per task on DeepSeek).

  • Baseline comparison: Baselines such as VeriMAP increase token usage by +410% to +579% while scoring lower than Native on DeepSeek (61.1% vs. 63.3%).

We will update the description: "+2.0% (GPT) to +24.5% (DeepSeek) in agent evaluation margin, and +20.4% to +50.5% in end-to-end token footprint."


W3.2 & Q3: How are the execution contract (O,R,V)(O, R, V) and fact specification set Q(O)Q(O) obtained, and does BRIDGE receive privileged supervision over the baselines?

The contract (O,R,V)(O, R, V) and fact set Q(O)Q(O) are not hand-written per task and do not use ground-truth labels:

  • SILO-BENCH (rule-based extraction, 0 LLM tokens): Built automatically from public task descriptions by code rules (for example, recording that an agent has a local shard and needs a peer shard).

  • TeamBench and MAST (runtime LLM extraction): Extracted at each boundary by an LLM prompt using only the public task prompt, visible messages, and tool outputs. These tokens are included in the controller diagnosis cost in Table 14.

  • Equal access: Our code blocks all evaluation fields (expected_output, ground_truth, reference_answer, evaluator). BRIDGE and all baselines read the exact same public context.

AuthorsOpenReview ↗

Response to Reviewer zArw (part 3)

Q4: The TeamBench attestation requires "tests passed". Does the controller call the official evaluation tests before committing?

No. In TeamBench, each agent (planner, executor, verifier) runs in its own isolated Docker container. The official grading test suite is not inside the agent containers. The official tests run only after the agents finish the task or hit the step limit. During execution, the controller never calls the official grading tests; the "tests passed" check only reads the exit code when an agent runs its own local unit tests inside its container.


Q5: Figure 1 / Figure 2 and Table 7 show different admission outcomes for ASK. How are these reconciled?

Figure 1 and Figure 2 were drawn as general examples of how an ASK action works when admitted (such as on TeamBench), whereas Table 7 shows the calibration table on the synthetic set where ASK had negative utility (−0.31-0.31 and −0.19-0.19) and was not admitted. To remove this mismatch, we will update Figure 1 and Figure 2 in the revised paper so that the action labels match Table 7.

Thank you again for your detailed feedback.

Comments on the paper

2 comments
AuthorsOpenReview ↗

Summary of Revisions in the Updated Manuscript (round 1)

Dear Reviewers (zArw, dGBK, BqaZ) and Area Chair,

We have uploaded a revised PDF with all changes highlighted in blue. A brief summary of the updates:

  • Terminology & Scope (Abstract, Sec. 1, 3.5, 4, 5, App. A.3): Narrowed "transactional" to local verify-before-release and removed overstated phrasing ("indispensable").
  • Cross-Backbone Behavior & Cost Accounting (Abstract, Sec. 1, App. F / Table 16): Clarified cross-backbone mechanism differences, reported both agent-channel (+2.0%–+9.9%) and end-to-end (+20.4%–+24.5%; TeamBench +5.3%) token overheads, and corrected a double-counting error in Table 16's DeepSeek ledger (true end-to-end overhead: +24.5%, not +50.5%).
  • Figures 1–2: Aligned illustrated action labels (INTEGRATE/ASK) and captions with Table 7.
  • Related Work & Mechanism Comparison (Sec. 2, 3.5, App. H / Table 18): Added Gray (1981), OCC, Sagas, and SagaLLM (accurately reflecting its pre-commit validation), plus a 5-system comparison (Table 18) and our mechanism-level additions beyond OCC/Sagas.
  • Contracts & Execution (Sec. 3.1, 3.5, App. A.1): Documented contract construction, anti-leakage blacklist, Eq. 2 precondition check, and programmatic updates vs. bounded staged LLM rewrites.
  • Protocols & Significance Tests (Sec. 4.1–4.2, App. D.1–D.2, D.4 / Table 14): Stated single-rollout protocols (DeepSeek, TeamBench), TeamBench Docker isolation, and added task-clustered Wilcoxon tests for GPT SILO-BENCH (p=0.0029p=0.0029) and full 90-task TeamBench (p=0.021p=0.021).
  • Offline Detection & Ablation Rerun (Sec. 4.3–4.4 / Table 4, App. C.1–C.3 / Tables 10–11): Added adapted SagaLLM comparison, 57 clean-control specificity, and MAST composition; separated the 30-task ablation from the 90-task reference and added the 3-seed 90-task rerun (360 runs) with candid discussion of non-significance and zero experience-card hits.
  • False-Positive Repair Study (App. G / Table 17): Added native-success intervention, gate-rejection, rollback, and failure rates across all three live benchmarks, plus analysis of the 6 losing GPT tasks.

Thank you again for your constructive feedback!

AuthorsOpenReview ↗

General Summary of Discussion and Revisions

Dear Area Chair and Reviewers (zArw, dGBK, BqaZ),

We thank all reviewers for their thorough and constructive feedback. All requested analyses, new experiments, and clarifications have been incorporated into the revised PDF (highlighted in blue):

  • Mechanism & Scope (zArw, dGBK, BqaZ): Narrowed "transactional" to local verify-before-release, removed overstated claims, and clarified BRIDGE's mechanism-level addition beyond OCC (1981), Sagas (1987), and SagaLLM (2025) (Sec. 2, 3.5, App. H / Table 18).
  • Attribution of GPT Gains (zArw, dGBK): Completed a 3-arm ablation on GPT SILO-BENCH (270 runs) showing pre-submission dependency checks alone account for +8.5 of +8.9 pp (23/2423/24 net wins, p=0.0039p=0.0039; App. F.1).
  • Statistical Rigor & Multi-Seed Ablation (zArw, dGBK, BqaZ): Added task-clustered Wilcoxon tests for GPT SILO-BENCH (p=0.0029p=0.0029) and full 90-task TeamBench (p=0.021p=0.021), clarified single-rollout protocols, and added a 3-seed 90-task paired ablation (360 runs) showing Full BRIDGE achieves the highest pass rate, lowest variance (±3.3%\pm 3.3\%), and lower token usage (Sec. 4.1–4.4, Table 4, App. C.3 & D.4).
  • False-Positive Repair & Clean-Control Audits (BqaZ): Quantified native-success rates across all 3 live benchmarks (gate rejection 61.4%–100%61.4\%\text{--}100\%, repair-induced failure 0.0%–1.8%0.0\%\text{--}1.8\%; App. G / Table 17), and reported Stage-1 FPR on the 57 clean MAST controls alongside the adapted SagaLLM comparison (App. C.2 / Tables 10–11).
  • Transparent Cost Accounting & Alignment (zArw, dGBK): Reported dual-scope token overheads (+2.0%–+9.9%+2.0\%\text{--}+9.9\% agent-only; +20.4%–+24.5%+20.4\%\text{--}+24.5\% end-to-end), corrected the DeepSeek ledger in Table 16 (true end-to-end +24.5%+24.5\%), documented contract provenance (App. A.1), and aligned Figures 1–2 with Table 7.

We believe all concerns have been thoroughly addressed with concrete empirical evidence, and we sincerely appreciate your time and consideration.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.