acceptodds
Under review as a conference paper at ICLR 2027

SwarmBlame: Content-Only Attribution for Adversarial Agent Swarms

Abstract

Coding agents increasingly work as swarms that edit one shared repository, so an operator who finds a planted bug or a covert message must determine which agent wrote it. Provenance records such as logs and version history can be rewritten by the suspects and detach from an artifact once it is copied, whereas a watermark puts the evidence into the text each agent generates, under a secret key. A core requirement of attribution is a framing bound, which states that an audit wrongly names an innocent agent only with a small, fixed probability. However, re-testing hundreds of watermark keys while an auditor reads file by file breaks this bound, a rewrite by another agent erases the author's mark, and one short artifact carries too little evidence. We propose SwarmBlame, an attribution protocol in which every agent samples under its own key with the standard KGW watermark and an anytime-valid test over all keys adds up evidence across files, naming an agent as soon as the evidence suffices while bounding framing for any reading order and stopping time. Composed keys record the chain of agents that rewrote a file, and seen-pair exclusion blocks framing by marks stolen from a victim's text. Across twenty models and six prior schemes, sixteen synthetic pull requests name their author in 99.9% of audits with 7 false accusations in 21,000, whereas re-testing detectors frame innocents in up to 8.93%, and optional learned weights nearly double code attribution without the prompt at audit time.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
LLM watermarking, attribution, multi-agent systems, agent swarms, provenance, adversarial robustness

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_CYWsOpenReview ↗
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
AuthorsOpenReview ↗

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:

Operation outside the harnessFraming boundMeasured
Falsify or delete logsholdsthe audit reads no logs
Direct write of unmarked textholds: unmarked bytes carry no keyno agent is blamed for them; spliced into another agent's file they read as that file's text, as for any watermark
Unkeyed paraphrase of 64 PR textsholdsauthor still named in 78%
Forge a victim's mark from text it read (thief)holds with seen-pair exclusion0 of 4,000 (85% without exclusion)
Choose the bundle and its reading order adaptivelyholds with exclusion (new Corollary 1)0 of 4,000 in every cell (E2)
Forge from victim files, then delete themholds with exclusion also against the optional output store0 of 4,000 in every cell (E8)

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.

  1. Agent j reuses agent i's PR descriptions in its own pull requests, lightly edited. The log correctly names j as the writer, and a store of outputs matches only exact copies; the mark names i, and even after a full unkeyed paraphrase 78% of 64 texts still name i.
  2. The swarm's PR texts, commit messages or code are posted outside the repository, to a tracker, a fork or a package, where no log entry follows them. The audit needs only the text: 16 PR texts name their author in 97% of audits.
  3. Agent j rewrites i's text through the harness. The log of that write stays with the file, while the composed key puts the chain into the text itself: a plain key names only j (97% of 64-text audits), the composed key names i→j (96%).

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.

AuthorsOpenReview ↗

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 rulePR textscommitscode
Preset size 8: abstains on14%97%99%
Preset size 8, re-tested at 16, 32, 64 after abstaining: innocents named12 / 3,0007 / 3,00012 / 3,000
E-process (SwarmBlame), same files: innocents named0 / 3,0001 / 3,0000 / 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.

AuthorsOpenReview ↗

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.

Reviewer_LfE9OpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper introduces SWARMBLAME, a method to attribute the contributions of individual agents in a swarm when collaborating within a shared repository. Because agents can write over each other’s content, simple per-agent watermarks can lead to misattribution. The authors address this by coupling per-agent keys with composed keys derived from a record of the previous and current editing agents to mark edits and preserve the chain of attribution when multi-agent interactions occur. Rather than test every key per file independently, evidence is instead accumulated sequentially over new files, overcoming cases when too little information is available in single files while preventing false attribution due to repeated independent testing. In their testing environment with 8 agents, their method is able to correctly name the authoring agent given a bundle of 16 PRs 99.9% of the time, and in the rewriting scenario, 64 rewritten PR texts are attributed to the correct agent revision chain 96% of the time. In settings where no agent authors the contribution, their method only yields false positives 7/21000 times.

Critical strengths
  • The problem of collaborative contribution attribution is interesting and increasingly relevant with swarm deployments and multi-agent systems. The proposed method is also practical for implementation.
  • The proposed techniques such as the composed keys, evidence accumulation (accompanied by a theoretical framing bound), and seen-pair exclusion are well-motivated and their necessity in the auditing framework is made clear through results from supporting experiments.
Critical weaknesses
  • The settings that motivate the work most, namely where agents interact extensively over the same files (with some possibly adversarial) are only lightly explored. For example, Algorithm 1 states a framing game where an adversary coalition can try to construct a bundle to fool an auditor. However, I can’t find a setting that fully matches this game setup: Section 5.3 considers two colluders, but they only interact with each other; there is also a thief setting, but its outputs are bundled separately for analysis; Section 5.4 has an interactive setting, but all contributors are honest and cooperative (there is a second setting with an adversarial planter, but only one scripted attack method is tested); and all bundle constructions are created prior to evaluation rather than as an adaptive step. Some other gaps that I think should be addressed with experimental settings are 1) analyzing different bundles where the number of authors contained vary (e.g., 2-author bundles are reported in D.1 as a start), and reporting how attribution rate changes as bundles have an increasing number of authors; and 2) studying settings where the files are edited more than once with edits overlapping.
  • Most experiments demonstrate that attribution success occurs with rather large bundle sizes, and the artifacts within the bundles themselves also have to be quite extensive (e.g., Table 6 indicates the PR text has the most bits compared something like the code itself, so some smaller artifacts require bundles with >64 artifacts). Smaller changes, such as the two-line bug planting experiment in 5.4, seem to suggest much lower success rates, even though in practical settings, swarm contributions may more likely be such small code diffs. As a result, the results don’t strongly support scenarios such as the motivating one in the introduction where a single small bug is planted. The authors should report attribution success as a function of edit size rather than just bundle count to further clarify when the method is effective.
Questions for authors
  • Can this method be translated to using distortion-free watermarking techniques such as Gumbel sampling or SynthID [1]? If so, what’s the performance like compared to using KGW.
  • The paper is clear about the assumptions being made (e.g., provenance from the artifacts only), but I am partly unconvinced of the motivation given how the method is designed, so I’ll leave it as a question. Specifically, the harness already has to keep some semblance of a trusted provenance record to track the composed keys. If this is so, why couldn't it just keep a more detailed record of the provenance?
  • How should bundles be constructed in practice? All experimental settings have the analyzed bundle pre-constructed, so how would performance change if an auditor also needs to look into creating the bundle.

[1] Dathathri, S., See, A., Ghaisas, S., Huang, P.-S., McAdam, R., Welbl, J., et al. (2024). Scalable watermarking for identifying large language model outputs. Nature, 634(8035), 818–823. https://doi.org/10.1038/s41586-024-08025-4

5 comments
AuthorsOpenReview ↗

Response (1/2): Adaptive framing, multi-author bundles and repeated edits

We thank the reviewer for the thoughtful review and the concrete experimental requests, and appreciate that the reviewer found the problem increasingly relevant and the proposed method, SwarmBlame, practical.

Below, each weakness and question raised by the reviewer is addressed in turn. New experiments answer each request on the submitted swarm (7B, δ=2, 512 keys, ε=10⁻³) unless stated. This part answers W1; part 2 answers W2 and Q1 to Q3. Section and table numbers refer to the submitted PDF; δ=4 is the stronger mark the paper also evaluates.

W1. The framing game, played adaptively. E2 plays Algorithm 1 literally: a thief estimates the victim's green pairs from 500 of the victim's tasks, then picks and orders its bundle to maximise the victim's evidence (4,000 audits per cell).

  • With seen-pair exclusion, the victim is framed in 0 of 4,000 audits in every cell, against 52.4% of 16-text audits without it.
  • Colluders that select their bundle from real repository text frame the victim in 0 of 4,000 even without exclusion; the audit names one of the colluders instead, in up to 69% of audits.
  • A thief that forges only from victim files it then deletes (E8) frames the victim in 0 of 4,000 in every cell once exclusion also runs against the operator's optional output store.

New Corollary 1 proves that exclusion keeps the framing bound under any adaptive choice of the bundle and its order made from text in the recovered repository (new Figure 11d plots E2), and a new paragraph in Section 5.3 reports this adaptive framing game. A second attack, a planter that hides its bug inside a refactor, is answered under W2.

W1(1). Bundles with k authors (E1). k of the eight agents share a bundle in equal parts, 2,016 bundles per cell:

k authors, one of them named16 PR texts3264128256
196.6%100%100%100%100%
225.1%88.0%99.9%100%100%
42.4%9.8%40.9%79.9%96.2%
80.8%1.1%3.3%5.0%8.5%

Mixing authors keeps false names far below ε: 5 of 80,640 audits (0.006%). The scaling law is simple: a 1/k share dilutes the green-rate excess k-fold, and evidence per pair grows with its square, so the bundle grows about k²-fold (16, 64 and 256 texts for k = 1, 2, 4). Splitting a mixed bundle along the repository structure that separates authors (Q3) returns it to the k=1 row. New Figure 11b plots these curves.

W1(2). A file edited twice with overlapping edits (E7). Agent i writes a program, agent j refactors it under the composed key i→j, then agent k refactors it again under j→k; 92.6% of the second refactor's lines overlap the first's. Audited over 568 keys (512 agent keys and the 56 composed keys of the active agents):

Chain j→k named16 files64 fileswrong chain or agent
pairs the second edit added, δ=487.8%100%0
final file, δ=444.8%100%0
pairs the second edit added, δ=20.8%40.6%0

No wrong chain, active agent or prior author is named in 61,600 audits. At δ=2 a 5.6-line overlapping refactor is attributed nearly as well as a whole program (40.6% against 46% for 64 programs, Table 1), so overlapping edits cost almost nothing, and at δ=4 the chain is named in 100% of 64-file audits.

AuthorsOpenReview ↗

Response (2/2): Edit size, distortion-free watermarks, records and bundles

W2. Attribution as a function of edit size. We agree with the reviewer; the revision reports exactly this, and the introduction now speaks of a campaign of planted edits. Naming one of 512 agents at ε=10⁻³ takes about 19 bits, and new experiment E3 measures what each edit contributes:

Planted edit, by new token pairsbits per edit16 edits32 edits64 edits
δ=2, 11 to 20 pairs0.834.9%35.2%78.2%
δ=2, 21 to 40 pairs1.3530.3%78.1%100%
δ=4, 1 to 5 pairs0.8610.3%48.9%96.5%
δ=4, 11 to 20 pairs2.8194.1%100%100%

Evidence adds up over a planter's edits: tens of edits name it at δ=2, and about sixteen at δ=4. A planter that instead hides the bug inside a refactor is named by 64 edits in 44 to 80% at δ=2 and by 16 edits in 95.7 to 99.6% at δ=4. The host is never named for an edit (0 of 196,400 audits at δ=2, 0 of 196,000 at δ=4). Within a channel, bits are proportional to tokens: about 0.05 bits per token for PR text, commit messages and branch names, and 0.004 to 0.009 for code at δ=2, so any edit size converts to a bundle size (Table 6, Appendix D.8). A keyed contribution (PR text, commit message, branch name and edited lines) carries 5 to 6 bits, and 16 such PR bundles name their author in 100% of audits.

Q1. Distortion-free watermarks. Yes. The audit needs only a per-pair score with a known distribution under an innocent key. For Gumbel sampling, r ∼ U(0,1) for every distinct pair under an innocent key, so the tilted Aaronson score (1-λ)(1-r)^(-λ) has unit mean for every λ; its mixture over a fixed grid is an e-process, and Theorem 1, Corollary 1, composed keys and exclusion carry over. E4 on the Gumbel swarm of Table 1: 64 PR texts 100%, 16 PR bundles 98.7%, 16 PR texts 80.2%, 64 commits 67.1%, 64 programs 35.4%, and 0 of 6,000 fresh-key audits name an innocent. On a task split, the grid chosen on even-ranked tasks gives similar figures on the held-out odd-ranked tasks (82.0% on 16 PR texts). KGW reaches these rates at smaller bundles (97% on 16 PR texts), so it remains the default in SwarmBlame. SynthID's g-values are Bernoulli(1/2) under an innocent key, so the same construction applies directly, as the revised Section 4.2 states.

Q2. Why not a more detailed record. The harness's only required state is one label per file, read to pick the next composed key; the audit never reads it. A detailed record is welcome where it survives, and the revised Section 3 presents the two as complementary. A record binds bytes to the write that submitted them; a mark binds them to the sampler, so it still names the generator of text that was copied, rewritten or posted outside the repository. For example, when agent j reuses agent i's PR texts with light edits, a write log names j and the mark names i; even after a full unkeyed paraphrase, 78% of 64 texts name i.

Q3. Forming bundles in practice. A bundle is the auditor's hypothesis that a set of artifacts shares an author, formed from structure the repository shows: a branch, a pull request or a session directory. The hypothesis affects power, never validity: a mixed bundle names one of its authors or abstains, with innocents within ε (E1), and a bundle formed by an adversary names no innocent (E2). An auditor who forms m bundles runs each at ε/m; m=1,000 costs about 10 bits, two to three more PR texts per bundle. The session directories of the interacting swarm are such structure-based bundles, and 64 artifacts name their agent in 99.97% of audits (Table 3).

Changes in the revision (highlighted in yellow; the method and all submitted results are unchanged): Corollary 1 and the adaptive framing game (Sections 4.2 and 5.3), and the requested experiments on multi-author bundles, overlapping edits, edit size and Gumbel sampling (Appendices D.8 to D.10).

We thank the reviewer again. We hope these results address the reviewer's concerns, and we would be glad to answer any further questions.

I appreciate the new experiments and insights, and find most of my questions/weaknesses addressed. However, there are still a few points that leave me unconvinced.

Bundles with kk authors. The authors define the success criterion as naming any one of the kk authors in the bundle. However, this attribution is not strong enough given the motivation of the problem. For example, suppose a bundle contains both an adversary's edits and an honest agent's edits, and then the bundle is flagged as malicious. If the honest agent is named, the audit is technically correct, yet the wrong agent has been held accountable. Furthermore, if more contributions lead to higher chance of being named, this leads to further exploitable scenarios, such as an honest agent making most of the contributions, then the adversary sneaking in a small edit, with the honest agent then taking the blame. For this experiment, it would be helpful to report all keys that exceed the threshold and report how often all authors are named in the bundle correctly.

Building bundles. My other concern is still related to bundle construction, which applies to the above point. I appreciate the authors' response to Q3 clarifying why the method retains safety no matter how a bundle is constructed, but I am not convinced of the method's usefulness when the auditor must also construct candidate bundles, particularly if the adversary uses its knowledge of the repository structure to evade detection (e.g., burying edits in large shared PRs). My understanding is the Table 3 session bundles still use ground-truth attribution to be built, so I'd still like an experiment where the auditor builds its own bundles.

Edit size. I appreciate the new results varying edit and bundle size. However, the new audit performance results seem to drop quickly at smaller scales, or require notable tradeoffs (e.g., task performance with greater δ=4\delta=4). If this is a current limitation, then it would be helpful for the authors to motivate why bigger edit sizes (e.g., 32, 64) are perhaps the more common scenario (e.g., a qualitative example?).

All together, I will maintain my original score.

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

This paper introduces SWARMBLAME, a content-only attribution framework for identifying responsible agents in adversarial coding swarms while preventing innocent agents from being falsely accused. Rather than introducing a new watermark, the authors propose independent per-agent keys, composed keys for tracking agent rewrites, and anytime-valid statistical tests that aggregate evidence across multiple artifacts. Seen-pair exclusion further mitigates framing by using stolen-watermark evidence.

The authors establish a theoretical framing bound and evaluate their approach across 20 models, multiple watermarking baselines, and adversarial settings involving rewriting, collusion, and watermark theft. The results demonstrate strong attribution accuracy and low false-accusation rates.

Critical strengths
  1. Interesting formulation with meaningful security guarantees: The anytime-valid attribution framework is an interesting contribution. The authors establish a framing bound using nonnegative martingales, Ville's inequality, and a union bound over agent keys. The extension to learned, key-independent evidence weights through a supermartingale argument is particularly compelling. The proofs appear mathematically sound under their stated assumptions.
  2. Principled statistical framework with practical applicability: The paper addresses a meaningful problem in multi-agent systems, namely the risk that malicious agents may frame innocent agents. Composed keys and seen-pair exclusion provide practical mechanisms for handling rewrites and stolen watermark evidence. The evaluation across multiple models, artifact types, and adversarial scenarios supports the effectiveness of the proposed approach.
Critical weaknesses
  • Scope of theoretical guarantees: The framing theorem relies on independence between an innocent key and the evaluated evidence. While the proof is sound under this assumption, the guarantee is less clear for adaptive adversaries that learn about the watermark or manipulate evidence selection. The authors should clarify which adaptive attacks are formally covered, particularly given the residual framing observed for deletion-aware thieves.
  • Validity of learned evidence weights: Proposition 1 assumes weights are independent of the tested key's watermark colors. However, the student model is trained using marked texts from active agent keys. The authors should clarify how this independence is maintained for active keys and whether the theoretical guarantee extends to them.
Questions for authors
  • Theorem 1: Does the framing guarantee hold when an adversary adaptively selects artifacts or their reading order using information correlated with an innocent agent's watermark? What restrictions on evidence selection are necessary?
  • Proposition 1: Since the student model is trained on texts watermarked with active keys, how is key independence guaranteed for those keys, beyond the empirical false-accusation evaluation?
3 comments
AuthorsOpenReview ↗

Response (1/2): Adaptive selection, covered by a new corollary

We thank the reviewer for the precise reading of the proofs and appreciate that the reviewer found the anytime-valid framework of SwarmBlame an interesting contribution and its extension to learned key-independent weights compelling.

Below, each weakness and question raised by the reviewer is addressed in turn. Both now have formal answers: a corollary for adaptive selection (this part, W1 and Q1), and a student that is key-independent by construction (part 2, W2 and Q2). Section and table numbers refer to the submitted PDF.

W1, Q1. Adaptive selection. New Corollary 1 (Section 4.2, proof in Appendix A.4):

Let k be innocent: no text in the bundle was sampled under k or under a composed key from k, nor is a copy or rewrite of such text. Assume per-pair hashed colours, a decoder in which raising the biased token's logit never raises another token's probability (softmax at any temperature, top-k truncation), seen-pair exclusion against the recovered repository R with each distinct pair scored once, and weights that are fixed functions of the audited text not learned from text under k. Let the adversary, which cannot sample under k and uses randomness independent of the colours, choose the bundle, its reading order and any artifact appended during the audit from a view that depends on k's colours only through text under k in R. Then Theorem 1 holds for k at every stopping time.

Proof idea. Let F_t be generated by the view, R, the adversary's randomness and the colours under every key of the first t kept pairs, so that the stopping rule is adapted. A kept pair (u,v) occurs nowhere in R outside the bundle, so in every text under k in R, v never followed u. Given all other colours, each such observation has likelihood ratio at most one for “green” against “red”, so by Bayes the conditional probability that the pair is green is at most γ. Each factor of the mixture then has conditional expectation at most one, the e-process is a supermartingale, and Ville's inequality and the union bound apply as before.

What evidence selection requires. Exclusion must run against every text under k the adversary could read. Text under k that the adversary read and then removed from R is the one case the view condition leaves to the operator: the deletion-aware thief of Table 2 (0.6 and 3.5% of 64-text audits; 0.9 and 1.8% with greedy selection, E8). An output store the operator may keep supplies those files: with it, the deletion-aware thief of Table 2, now selecting its forgeries greedily (E8), frames the victim in 0 of 4,000 audits in every cell. Weights must not be learned from text under k, which part 2 provides. For nucleus sampling, which applies the bias before truncation, the per-occurrence likelihood ratio is bounded by 1/p rather than one, so we report that case empirically: E2 at p=0.95, a thief that picks and orders its forgeries by the victim's estimated green pairs, frames the victim in 0 of 4,000 audits in every cell with exclusion (52.4% of 16-text audits without; new Figure 11d).

AuthorsOpenReview ↗

Response (2/2): Key-independent learned weights

W2, Q2. Key independence of the student for active keys. The submission checked the eight active keys empirically (at most 1 false accusation in 6,800 audits per student, Table 5). We now guarantee it by construction. New experiment E6 trains the student only on the unwatermarked control generations: every training prompt is a single-turn task prompt that contains no text sampled under any registry key, and the targets are the generator's entropies given the prompt. The weights are then a function of the text and of a model that never saw a registry key, and the weighting rule is the submission's fixed top-half rule, so Proposition 1 holds for every innocent key, the eight active ones included, with the student frozen before the audit.

1.5B student on 14,050 unwatermarked artifacts, 1,600 audits per cell, identical bundle draws in every row:

Weights4 PR bundles64 commits64 programsunmarked framedfresh keys framed
none27.1%81.7%46.5%4 / 16,0000 / 2,000
key-independent student (new)63.2%97.8%66.0%5 / 16,0000 / 2,000
submitted student, trained on marked text61.4%97.1%70.7%1 / 16,0000 / 2,000

The key-independent student matches or exceeds the submitted one on PR bundles and commits, lifts code from 46.5 to 66.0%, and keeps every false-accusation count within ε. Both key-independent students we trained, on 2,000 and 14,050 artifacts, are reported in Appendix B; the guarantee also covers the choice between them, at 2ε by the union bound. The revised Section 4.3 names the 14,050-artifact student as the one that carries the guarantee.

Changes in the revision (highlighted in yellow; the method and all submitted results are unchanged): Corollary 1 with its proof (Section 4.2, Appendix A.4) and the key-independent student (Section 4.3, Appendix B).

We thank the reviewer again. We hope these results address the reviewer's concerns, and we would be glad to answer any further questions. Regards.

AuthorsOpenReview ↗

Follow-up: summary of the revision

We thank the reviewer again for the supportive and precise review. Both concerns the reviewer raised now have formal answers in the revised manuscript:

  • Adaptive adversaries (W1, Q1). New Corollary 1 (Section 4.2, proof in Appendix A.4) proves that the framing bound holds when the adversary adaptively chooses the bundle, its reading order and artifacts appended during the audit, under seen-pair exclusion. An adaptive thief frames the victim in 0 of 4,000 audits in every cell (E2), as does the deletion-aware thief once exclusion also runs against the operator's optional output store (E8).
  • Learned weights (W2, Q2). The student is now trained only on unwatermarked text, so Proposition 1 holds by construction for every innocent key, the eight active keys included, and code attribution rises from 46.5 to 66.0% (E6).

We are grateful for the reviewer's positive assessment and the time spent on SwarmBlame.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.