acceptodds
Under review as a conference paper at ICLR 2027

BranchMind: Verified Evidence Sharing Across Parallel Coding Agents

Abstract

Parallel coding agents explore independent branches, yet repeatedly inspect the same files, symbols, and tests. Their transcripts are isolated because an observation made on one branch can become invalid after another branch edits its code. We introduce BranchMind, an execution memory that makes repository evidence reusable without turning state validity into a language-model judgment. A publisher packages pre-edit tool observations with content-addressed receipts over the exact code ranges and dependency manifests that support them. A consumer receives only observations whose receipts still match its branch. We evaluate this mechanism on 20 executable maintenance tasks from 10 public repositories through 579 new agent trajectories and two model families. Independent agents revisit the same file family in 39.2% of the shorter pre-edit trajectory. Across 145 real commit transitions, range receipts recover 37 byte-stable reads that whole-file invalidation discards. A contemporaneous 120-trajectory attribution study shows that paths reduce calls by 2.88 per run (task-and-repeat 95% CI: 0.70–5.03 fewer), while the observed success count is three higher after restoring concrete observations at 0.68 additional calls. We then freeze all 18 eligible natural partial branches across seven tasks and cross four sharing policies with GPT-6 Luna, DeepSeek V4 Pro, and a runtime-enforced DeepSeek replay. Range validation retains all 32 stable observations and exposes none of 31 changed observations; whole-file hashing retains only 7. Across 54 paired receiver–branch cells, descriptive means are 15.74 versus 17.93 calls; the task-weighted delta is 1.95 fewer (33 lower, 7 ties; task-and-branch 95% CI: 0.18–3.80 fewer), with 3 versus 4 observed successes. Against no sharing the task-weighted delta is 3.51 fewer calls with the same 3/54 successes. BranchMind turns execution already paid for by one agent into compact, branch-valid progress for another, without training or model-based routing.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
coding agents, multi-agent systems, evidence sharing, branch validity, software agents, execution memory, verification

Reviews

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

BranchMind shares pre-edit file observations between coding agents and validates them using hashes of the observed code ranges and dependency manifests. Across 20 Go maintenance tasks, it shows that range validation retains more unchanged observations than whole-file hashing and can reduce receiver tool calls. Attribution experiments distinguish localization hints from the additional value of concrete observations.

Critical strengths
  1. The validity contract is simple and auditable. On natural partial branches, range receipts retain all 32 stable observations versus 7 for whole-file validation, while exposing none of the 31 changed observations. This demonstrates the intended selective reuse mechanism (Section 4.4).
  2. The study provides careful controls, including instruction-matched repeats, a paths-only condition, runtime enforcement, and held-out developer tests. These help separate useful reuse from prompt changes and invalid evidence (Sections 3–4; Appendix C).
Critical weaknesses
  1. Evaluation coverage and benchmark representativeness are limited. The study uses 20 custom Go tasks, with only seven tasks represented in the diverged-branch evaluation, and reports no results on SWE-bench Pro or Terminal-Bench 2.0. Section 3.1 describes a commit-and-test construction protocol, but the rationale for repository and commit selection and the preparation of issue descriptions are insufficiently explained. This limits confidence in generalization.
  2. Practical efficiency gains remain insufficiently established. Tool-call reduction is clearer than monetary or latency savings: the cost and time intervals in Section 4.3 include zero. On diverged branches, success is 3/54 versus 4/54 for whole-file validation, and the Appendix B sensitivity analysis reduces the task-weighted call advantage from 1.95 to 0.05 after excluding two matched units with module-cache reads. These results leave uncertainty about stable system-level savings at comparable task success.
  3. Presentation issues: Section 3.4 defines RQ1–RQ4, but Section 4.5 introduces RQ5 without a corresponding definition. Figure 1 also contains overlapping branch and fork labels, reducing readability.
Questions for authors
  1. Can the methods reduce the total token cost and wall-clock time of the evaluated tasks? Beyond tool calls, please show the corresponding token cost and time.
  2. Can you provide results on SWE-bench Pro or Terminal-Bench 2.0 to establish whether the gains generalize on these popular benchmarks?
  3. How were the 20 task evaluated in your paper constructed? Please show the criteria and do some analysis to these tasks. I think the construction process is missing. So we can not know the quality of the task. Which will influence the soundness of the claim and the results presented in the paper.
Reviewer_zJY6OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
1
Soundness
1
Read review
Paper summary

The paper proposes BranchMind, a mechanism for sharing tool observations between coding agents working in parallel on the same task from a common parent. A publisher records the file reads. A consumer recomputes the digests on its own branch and sees only reads whose receipts still match. The authors build a 20-task Go benchmark (BranchMind-20), run 579 trajectories, and report that agents re-inspect the same files ~39% of the time, range-level hashing keeps more stable reads than whole-file hashing, sharing reduces tool calls by roughly 10–24% depending on the study, with no change in held-out success.

Critical strengths
  • Interesting observation and idea. It is good to know how would the observation between parallel agents help if shared.
Critical weaknesses
  • The experiments are weak. The evaluation uses a self-constructed benchmark of only 20 Go tasks (2 per repository), far below the scale that is standard for repository-level coding-agent evaluation. The conclusions are not reliable and generalizable at this scale. Moreover, every comparison condition is an ablation of BranchMind itself. No external baseline is included, even though the attribution study shows the gain comes mainly from file paths, which a cheap retrieval-based localizer could supply without running a publisher at all.
  • The method does not address the setting the paper claims. BranchMind is framed as evidence sharing across parallel agents, but the mechanism is a one-shot handoff, where evidence is collected until the publisher’s first edit and sent to other branches for their prompt construction. Supporting genuinely concurrent agents would require incremental publishing, mid-trajectory injection into a running consumer, and deduplication against the consumer’s own observations. None of which is considered.
Questions for authors
  • How does the method perform on an established benchmark (e.g., SWE-bench Pro or Multi-SWE-bench), and against an external baseline that supplies file paths without running a publisher (e.g., a retrieval-based localizer) or that hands over the publisher’s transcript/summary directly?
  • Does the implemented system support incremental publishing and mid-trajectory injection into a running consumer? If so, please report a concurrent-agent experiment with system-level wall-clock time.
Reviewer_q11dOpenReview ↗
Rating
1
Confidence
3
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

The paper proposes BranchMind, an execution memory for coding agents working on sibling branches of the same repo. The system generated content-addressed receipts for code ranges, then consumers receive only observations for code ranges that correspond to their branch. The evaluation used BranchMind-20 and 579 trajectories with GPT and DeepSeek receivers.

Critical strengths
  1. I feel like the paper addresses a useful problem, and there is data to support the validity of the approach.
  2. Experiments align well with the claims.
Critical weaknesses
  1. This is a very narrow topic, and the technical contribution is small. This is basically just content hashing over line ranges. There's no new ML contributions.
  2. The evaluation is limited. For example, while the motivation is agents running concurrently, the experiments are sequential. There's no measure of how it would behave in real concurrency. Only file reads are considered, and not searches or tool calls. Tasks are all very small, etc etc.
Questions for authors
  1. Receipts are keyed to line intervals [a, b]. Does an insertion or deletion above an observed range invalidate it even when its content is unchanged? How many of the 31 “changed” ranges in the divergence study are pure relocations?
  2. How is the “compact set of task-relevant lines” selected from a read? Is it a deterministic rule or a model? Does the digest cover the full read interval or only the lines shown to the consumer?
  3. What did the three module-cache reads in the Cobra units contain? Could they have exposed upstream code that includes the fix? Please report range−whole-file and range−none estimates with intervals per receiver, with and without those units.
  4. Are there trajectories in which stale evidence from unfiltered sharing misled the receiver? If none were observed, what evidence supports the practical need for validation over unfiltered sharing?

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.