- Rating
- 2
- Confidence
- 3
- Informativeness
- 2
- Presentation
- 2
- Soundness
- 2
Read review
Paper summary
This paper proposes SwarmBlame, a watermark-based attribution framework for multi-agent coding systems. Each agent generates text using a distinct secret key managed by a trusted harness. The framework combines watermark evidence across artifacts using anytime-valid statistical tests to identify the generating agent while bounding false accusations. It also introduces composed keys for attributing rewrites and seen-pair exclusion to defend against watermark stealing.
Critical strengths
-
The paper addresses an interesting problem: attribution in multi-agent systems where agents can modify each other's outputs.
-
The anytime-valid statistical formulation for controlling false accusations across multiple keys and artifacts is technically interesting.
-
The experimental evaluation is extensive, covering multiple models, coding tasks, and adversarial behaviors.
Critical weaknesses
-
Unclear threat model and trust assumptions.
My primary concern about this paper is its threat model. The paper assumes a trusted harness that controls generation, mediates every write, and knows which agent rewrites another agent's artifact. At the same time, malicious agents can modify files, falsify logs, and invoke unkeyed tools. The trust boundaries are not sufficiently clear, particularly regarding which operations can bypass the harness and what information the harness reliably retains.
More fundamentally, it is unclear what attribution information the defender actually lacks, given the capabilities of the trusted harness.
-
Insufficient motivation for watermarking over cryptographic provenance.
Given that the trusted harness already authenticates agents and mediates writes, why not maintain cryptographically authenticated, append-only provenance records? These could provide exact attribution and modification histories without statistical errors or watermarking-induced generation degradation.
The authors argue that watermarks remain attached to copied artifacts when provenance metadata is lost. However, the paper does not demonstrate a realistic deployment scenario where authenticated provenance is inadequate but watermark-based attribution provides a meaningful advantage. Moreover, arbitrary rewriting outside the harness can remove watermark evidence, limiting this claimed benefit.
-
Attribution does not necessarily establish responsibility for malicious modifications.
The paper motivates its approach using planted bugs and malicious modifications. However, identifying the generator of a watermarked artifact is different from identifying who introduced a particular vulnerability. A small malicious edit could leave the original author's watermark largely intact. The paper's planted-edit experiments do not fully resolve this distinction.
-
Limited justification for sequential auditing.
The anytime-valid test is interesting, but the auditor is assumed to receive a collection of artifacts after an incident. It is unclear why adaptive stopping is essential in this setting rather than a fixed-size audit, which may offer greater statistical power.
-
Presentation and clarity.
I found the paper difficult to follow. It introduces several attack scenarios and statistical mechanisms before clearly explaining the system architecture and trust assumptions. The distinction between identifying the generator, attributing malicious modifications, and preventing false accusations could also be clearer. A concrete end-to-end example would substantially improve readability.
Questions for authors
-
Can the authors provide a realistic deployment scenario where cryptographically authenticated provenance is insufficient but SwarmBlame succeeds, despite assuming a trusted harness?
-
Precisely which attacker operations bypass the harness, and what guarantees remain when artifacts are modified outside it?
-
How does the framework distinguish attribution of generated text from responsibility for a small malicious modification?
-
What practical requirement makes anytime-valid sequential auditing preferable to fixed-size auditing?
5 comments
Response (2/2): Small edits, sequential auditing and presentation
W3, Q3. Attribution of text versus responsibility for a small edit. The audit attributes tokens, and an edit is a set of tokens. To decide who made an edit, the auditor scores only the token pairs the edit added to the previous version of the file, which the recovered repository holds, so no log is needed. The host's unchanged lines keep naming the host for those lines, which is correct, and for the edit itself the host is named in 0 of 196,400 audits at δ=2 and 0 of 196,000 at δ=4. An edit made through the harness is written under the composed key host→planter, whose second element is the edit's author; E7 names such a chain from 64 refactoring edits in 100% of audits at δ=4.
Evidence adds up over a planter's edits. Naming one of 512 agents at ε=10⁻³ takes about 19 bits, and new experiment E3 measures what each edit contributes (new appendix table and Figure 11a):
- At δ=2 an edit carries 0.2 to 1.4 bits, so a campaign of tens of edits names the planter: 64 edits of 11 to 20 new pairs in 78% of audits, of 21 to 40 pairs in 100%.
- At δ=4 an edit of 2 to 3 lines carries 2.6 to 3.2 bits: 16 edits name the planter in about 90 to 95% of audits and 32 in 100%, also when the bug is hidden inside a refactor (16 edits: 95.7 to 99.6%).
The revised Section 3 defines attribution (who sampled the tokens), framing (naming an agent who did not, bounded by ε) and responsibility (the operator's judgement, for which attribution is the evidence).
W4, Q4. Why sequential. The practical requirement is that the auditor does not know the right bundle size. Evidence per artifact varies more than tenfold across channels and lengths (0.004 to 0.059 bits per token), and so does the number of files per agent, so a preset size is wrong for many bundles. New experiment E5, on 64-file bundles drawn 3,000 times:
| Decision rule | PR texts | commits | code |
|---|---|---|---|
| Preset size 8: abstains on | 14% | 97% | 99% |
| Preset size 8, re-tested at 16, 32, 64 after abstaining: innocents named | 12 / 3,000 | 7 / 3,000 | 12 / 3,000 |
| E-process (SwarmBlame), same files: innocents named | 0 / 3,000 | 1 / 3,000 | 0 / 3,000 |
Re-testing, the natural repair of a wrong preset, names innocents at up to four times ε, while the e-process stays within ε, stops when the evidence suffices (8.1 PR texts on average), and accepts files that arrive after the incident. When the size is known in advance, the protocol can also run a fixed exact test, which gains power there (69 against 46% on 64 programs, Table 1), with keys, composed keys, exclusion and the union bound unchanged; Appendix D.1 reports all rules side by side. Learned weights close most of that gap, raising the e-process on code to 66.0% (E6).
W5. Presentation. Section 3 now opens with the system and its trust boundary, then the three definitions, then the threat model, and a new Figure 3 follows one text end to end as it is reused, rewritten and posted, showing whom a write log and the mark each name and what the audit of the text alone concludes, with the measured rates. Attacks and statistics follow.
Changes in the revision (highlighted in yellow; the method and all submitted results are unchanged): the threat model and trust boundary now open Section 3 with an end-to-end figure (Figure 3), and Appendix D adds the preset-size and edit-size results.
We thank the reviewer again. We hope these results address the reviewer's concerns, and we would be glad to answer any further questions.
Follow-up: Summary of the revision
We thank the reviewer again for the detailed review. As the discussion period draws to a close, we would be grateful for the reviewer's assessment of the revised manuscript and our responses, which address each concern the reviewer raised:
- Threat model and trust assumptions. Section 3 now opens with the trust boundary: the harness is trusted only as sampler and router, and a new trust table (Appendix A.1) states the guarantee that remains for each operation outside it.
- Watermarking and cryptographic provenance. The two are complementary; the new Figure 3 shows reuse, posting outside the repository and rewriting, where an authenticated record names the writer and the mark names the generator.
- Responsibility for a small edit. The audit scores only the token pairs an edit added, and the host is named for the planter's edit in 0 of 196,400 audits.
- Sequential auditing. When the bundle size is not known in advance, re-testing a preset size names innocents at up to four times ε, while the e-process stays within ε on the same files (E5).
- Presentation. Section 3 is restructured around an end-to-end example (Figure 3).
We are glad to clarify any further questions. We would greatly appreciate the reviewer's feedback on whether these changes resolve the concerns, and, if so, a reconsideration of the assessment in light of the revision. Regards.
Response (1/2): The threat model is now explicit, and content marks complement cryptographic provenance
We thank the reviewer for the careful review. We are glad that the reviewer found the anytime-valid formulation technically interesting and the evaluation extensive. Here are our responses to the questions.
Note: Section and table numbers refer to the submitted PDF. δ=2 is the paper's default mark, and δ=4 is the stronger mark it also evaluates.
W1. Threat model: which operations bypass the harness, and what remains. The harness is trusted only at generation time, as sampler and router. It holds the secret and one label per file, the last keyed writer, which it reads to pick the next composed key; it needs no log, and an operator may optionally keep its output store. At audit time the operator holds the secret, and the audit reads only the recovered text.
Everything else lies outside the boundary: agents with shell and tool access can move, copy, squash, rebase, delete and rewrite files and logs, write directly, call unkeyed tools, and read every file they reach. The revision states this at the start of Section 3, with a new trust table in Appendix A.1, and Section 3.1 now says “mediates every keyed write”. What the framing bound guarantees for each operation:
With seen-pair exclusion, run against the output store when files are deleted, bypassing the harness can remove evidence but does not make the audit name an innocent.
What the defender lacks is a record that binds bytes to the sampler that produced them once the bytes leave the write in which they were recorded.
W2, Q1. Motivation for watermarking over cryptographic provenance, and a deployment where authenticated provenance is insufficient. Cryptographically authenticated, append-only provenance records are exact for text that stays in the file it was written to, and the revised Section 3 presents the two as complementary. Take a swarm whose harness keeps such records.
In each case the record answers who wrote the file, and the mark answers who generated the text, wherever the text has gone; new Figure 3 in the revision shows this side by side.
Rewriting outside the harness, with exclusion, affects power, not validity: after an unkeyed paraphrase 78% of 64 PR texts still name their author. Where every model call goes through the harness, an agent that regenerates its own text is named in 100% (Table 2).
Generation cost (Section 5.2, Appendix D.3) At δ=2 the change is within noise: -2.1 MBPP points on the 7B model (95% interval [-4.8, +0.4]) and -0.3 resolve points on 320 SWE-bench Verified fixes by the 30B model ([-3.4, +2.8]). The 30B model absorbs δ=4 at +0.3 MBPP points; on the 7B model δ=4 costs 13.4, and the gated SwarmBlame-E applies a strong mark at -2.0.