acceptodds
Under review as a conference paper at ICLR 2027

LoRo-Mark: Provably Lossless And Robust Agent Watermarking

Abstract

As large language model (LLM) agents are increasingly deployed as commercial services, protecting their proprietary orchestration logic and tool-use policies has become an important concern. We consider a realistic infringement scenario, termed **agent repackaging**, in which an adversary integrates a protected agent into its own application through an API and presents it under its own service identity. The adversary may further modify parts of its execution process to obscure the original source. In such cases, the owner typically has access only to the repackaged service interface, making black-box ownership verification essential. Agent watermarking provides a natural way to embed ownership evidence into the agent’s behavior for later verification. Under this setting, we argue that an effective watermark should satisfy two key requirements: losslessness, requiring watermarking to preserve the agent’s original functionality, and robustness, requiring ownership evidence to remain recoverable after partial modification of the execution process. Existing methods, however, typically embed ownership signals into behavior selection or execution trajectories, intervene in normal agent decisions and provide limited robustness to behavior modification. To address these limitations, we propose **LoRo-Mark**, a provably **lo**ssless and **ro**bust agent water**mark**ing mechanism. For losslessness, LoRo-Mark isolates watermarking into a cryptographically authenticated forensic branch that remains inactive during normal execution and can only be activated by owner-authorized requests. By reducing unauthorized branch activation to standard MAC security, LoRo-Mark provides a formal cryptographic guarantee of performance preservation. For robustness, it redundantly distributes ownership information across forensic behavior sequences, enabling reliable recovery under partial behavior substitution and sequence truncation. Experiments across multiple LLM agents demonstrate zero degradation on normal tasks and reliable ownership verification under sequence modifications.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
agent, watermarking, cryptography

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_y5EeOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes LoRo-Mark, an agent watermarking framework for black-box ownership verification under agent repackaging. The method separates watermarking from normal execution through a MAC-authenticated forensic branch, allowing ordinary requests to follow the original execution path. Within the forensic branch, copyright information is redundantly encoded into behavior sequences using keyed pseudorandom mappings. The paper provides theoretical guarantees under specified assumptions and evaluates utility preservation and watermark recovery under behavior substitution and sequence truncation.

Critical strengths
  • A well-motivated separation of watermarking and normal execution. The MAC-authenticated forensic branch provides a clear way to preserve ordinary agent behavior while supporting ownership verification. The accompanying theoretical analysis formalizes this property under standard cryptographic assumptions.

  • Useful evaluation of watermark robustness and redundancy. The paper compares LoRo-Mark with existing agent watermarking methods and evaluates recovery under behavior substitution and sequence truncation. The analysis of different repetition factors also illustrates the trade-off between robustness and forensic sequence length.

Critical weaknesses
  • Clarification Needed on Context Reconstruction Under Repackaging. Watermark extraction relies on reconstructing the per-step execution contexts and candidate behavior sets used during embedding. However, the threat model allows the repackaging adversary to modify displayed observations and execution traces. It is unclear how the verifier can reliably reconstruct the original contexts from potentially modified information. The robustness analysis appears to assume that this reconstruction remains valid, and further clarification would strengthen the connection between the theoretical guarantees and the proposed threat model.

  • Potential Vulnerability to Targeted Trace Manipulation. The robustness evaluation mainly considers random behavior substitution and prefix truncation. However, the repetition encoding places copies of each watermark bit at predictable positions. Under the default fixed-capacity configuration, selectively replacing three particular behavior steps with erasures could eliminate all copies of one watermark bit and cause verification to fail. This suggests a possible vulnerability to targeted modifications that is not covered by the current evaluation, although it does not contradict the guarantees established under the paper's stated assumptions.

Questions for authors
  • Context Reconstruction Under Modified Observations. Could the authors clarify how the verifier reconstructs the original execution contexts and candidate behavior sets when a repackaging adversary modifies the displayed observations? It would be helpful to evaluate whether watermark extraction remains reliable under such modifications.

  • Robustness Against Targeted Trace Manipulation. Could the authors evaluate targeted behavior erasure attacks, where an adversary deliberately modifies a small number of selected positions rather than randomly substituting behaviors? This would help clarify the robustness of the proposed repetition encoding against more deliberate trace manipulation.

9 comments

Question-1: Context Reconstruction Under Modified Observations. Could the authors clarify how the verifier reconstructs the original execution contexts and candidate behavior sets when a repackaging adversary modifies the displayed observations? It would be helpful to evaluate whether watermark extraction remains reliable under such modifications.

Response-1: Context Reconstruction Under Modified Observations

Thank you for highlighting the reconstruction requirements. Algorithm 4 in Appendix A presents the standard context-dependent instantiation of LoRo-Mark, in which the per-step mapping is defined as

\operatorname{PRF} \bigl(k_{\mathrm{step}},o_t,\mathcal{B}_t\bigr).$$ This instantiation requires the verifier to reproduce the observation context and candidate set used during embedding. To remove the dependence of mapping reconstruction on potentially modified observations, **we now specify an observation-independent instantiation within the same framework**. For an authenticated forensic request $T^*$, the owner and the protected harness share a predefined forensic candidate table $\mathcal{B}^{\mathrm{F}}$. Let $\eta$ be an owner-generated forensic timestamp included in the authenticated request content and retained locally by the owner. Using the request-specific key $k_{\mathrm{step}}$, both parties derive $$s_t = \operatorname{PRF} \bigl( k_{\mathrm{step}}, \operatorname{Encode}(\eta,t) \bigr),$$ and $$\pi_t = \operatorname{Permute} \bigl( \operatorname{Canon}(\mathcal{B}^{\mathrm{F}}); s_t \bigr).$$ Here, $\operatorname{Encode}$ provides an unambiguous encoding of the timestamp and original step index, $\operatorname{Canon}$ fixes the candidate identities and their canonical ordering, and $\operatorname{Permute}$ generates a permutation deterministically from the seed $s_t$. The next copyright-code chunk determines an index $j_t$, and the harness selects $$b_t = \pi_t[j_t], \qquad b_t \in \mathcal{B}^{\mathrm{F}},$$ producing the forensic behavior sequence $$\tau = (b_1,\ldots,b_S).$$ During verification, the owner obtains the request information from its locally retained authenticated query and the candidate table from its own configuration. For each identifiable surviving behavior whose original step index $t$ is available, the verifier reconstructs the same permutation and maps the behavior back to its corresponding code chunk. Neither permutation generation nor this inverse mapping uses the displayed observation $o_t$ or a candidate set reconstructed from the frontend. **Consequently, modifying or suppressing the displayed observations does not, by itself, disrupt reconstruction of the forensic mapping in this instantiation.** The timestamp need not be secret: pseudorandomness is supplied by the secret key, while the original step index distinguishes the per-step inputs within the request. This construction changes the inputs used to generate the per-step mapping; the authenticated branch and redundant encoding procedure remain unchanged. Ordinary requests continue along the original execution path. We will include this instantiation and its reconstruction requirements explicitly in the revised manuscript.

Question-2: Robustness Against Targeted Trace Manipulation. Could the authors evaluate targeted behavior erasure attacks, where an adversary deliberately modifies a small number of selected positions rather than randomly substituting behaviors? This would help clarify the robustness of the proposed repetition encoding against more deliberate trace manipulation.

Response-2: Robustness Against Targeted Trace Manipulation

Thank you for highlighting attacks that deliberately target the repetition layout. We have analyzed the effect of such erasures and distinguish their consequences from the guarantees for independent random substitution and prefix truncation.

Layout-aware targeted erasure.

Under the default configuration, the copyright payload has n=104n=104 bits, the repetition factor is r=3r=3, and each step carries β=6\beta=6 bits, giving S=52S=52 steps. Copy kk of payload bit cic_i is embedded at step

\left\lfloor \frac{i+kn}{\beta} \right\rfloor+1, \qquad k=0,\ldots,r-1.$$ For the first payload bit, these steps are $$t_{0,0}=1, \qquad t_{0,1}=18, \qquad t_{0,2}=35.$$ Erasing these three steps removes all copies of $c_0$. Algorithm 5 then rejects because the corresponding voting group is empty. This attack therefore causes verification failure even when the remaining mappings and step positions are correctly reconstructed. It affects only $3/52\approx5.77\%$ of the trace and does not require the secret key: the keyed mapping determines which behavior represents a code chunk, while the locations of the repeated chunks follow the public encoding layout. This confirms the targeted-erasure failure case identified in the review. As the reviewer notes, it does not contradict the guarantees for independent random substitution or prefix truncation. We will distinguish these attack models explicitly in the revised manuscript. **Recovery under bounded targeted corruption.** The repetition code also provides a deterministic recovery guarantee for a bounded number of deliberately selected modifications. Let $u_i$ and $v_i$ be the numbers of substituted and recognizably erased copies of payload bit $c_i$. With the original step correspondence and keyed mappings available, majority decoding recovers the entire message whenever $$2u_i+v_i<r \qquad \text{for every } i.$$ At least $r-u_i-v_i$ copies remain correct, while at most $u_i$ can vote for the wrong value. The inequality therefore ensures a strict correct majority among the surviving votes. Because $n\geq\beta$, different copies of a given bit occupy different steps. Consequently, any $a$ substituted steps and $b$ recognizably erased steps are correctable whenever $$2a+b<r,$$ regardless of how the attacker selects those positions. For $r=3$, this guarantees recovery from any one substituted step or any two erased steps. Three appropriately selected erasures can defeat verification, as shown above. Increasing $r$ raises the absolute number of edits covered by this guarantee, but does not conceal the repetition layout. **Contiguous-block corruption.** For completeness, a single contiguous block has a different recovery condition because copies of the same bit are separated by $n$ encoded positions. For $r=2h+1$, arbitrary substitutions and recognizable erasures confined to one block of $m$ steps are correctable whenever $$m\beta\leq hn.$$ Under the default configuration, this guarantees recovery for any contiguous block of at most $17$ steps. For pure erasure, it is sufficient that at least one correct copy of every bit survives. A single contiguous erasure block is therefore correctable under the stronger condition $$m\beta\leq(r-1)n,$$ which gives up to $34$ steps in the default configuration. These statements require the original positions to remain identifiable; they concern erasures with preserved alignment, rather than deletions that destroy step correspondence. The following table summarizes the deterministic consequences of the encoding layout and decoder. | Attack under the default configuration | Budget or selected positions | Deterministic result | | :--- | :--- | :--- | | Arbitrary recognizable step erasures | Any two steps | Exact recovery | | Layout-aware targeted step erasure | Steps 1, 18, and 35 | Verification rejects | | Arbitrary behavior substitution | Any one step | Exact recovery | | One contiguous block of substitutions and/or recognizable erasures | At most 17 steps | Exact recovery | | One contiguous block of recognizable erasures only | At most 34 steps | Exact recovery | This analysis identifies the recovery boundary of the current repetition construction: it tolerates bounded targeted corruption and substantially larger contiguous blocks, while an attacker who erases every publicly located copy of a selected bit can prevent verification. We will state these distinct guarantees and failure cases explicitly in the revision.

We noticed that we have not yet received your feedback and would like to ask whether any part of our explanation may have been unclear. We would be more than happy to provide further clarification if needed, and sincerely hope that we can address any remaining concerns. We would greatly appreciate it if you could take the time to review our response.

Thank you very much for your time and consideration.

Reviewer_N8oDOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
3
Soundness
2(+1)
Read review
Paper summary

This paper proposes LoRo-Mark, a provably lossless and robust watermarking method for detecting agent repackaging. The method employs MAC-based authentication to activate a separate forensic branch, ensuring that normal agent execution remains unaffected. It further embeds copyright information into agent behavior sequences using redundant encoding to resist partial behavior substitution and trajectory truncation. The paper provides theoretical guarantees for losslessness and experimentally evaluates watermark robustness.

Critical strengths
  1. The paper addresses the protection of system-level intellectual property in LLM agents, which is a relevant and meaningful research problem.

  2. The method is clearly designed, separating normal execution from watermark verification through cryptographic authentication, with supporting theoretical analysis.

  3. The experiments cover multiple models and different degrees of trajectory modification, evaluating both losslessness and robustness.

Critical weaknesses
  1. Unrealistic threat model. The paper assumes that the copyright owner can obtain detailed agent execution trajectories through a black-box API. However, existing agents are typically deployed either locally or as cloud-based services. In local deployments, users may have direct access to and the ability to modify the agent framework. For cloud-based services, exposing internal execution trajectories is not necessarily required for providing the intended functionality. In particular, under the repackaging scenario considered in this paper, an adversary could simply return the final execution results without exposing any intermediate trajectories. This straightforward strategy would render the proposed watermark verification ineffective.

  2. Insufficient justification for behavioral watermarking and limited technical novelty. The proposed method achieves losslessness by introducing a separate authenticated forensic branch. Under this design, a much simpler alternative would be to detect authenticated requests at the API backend and directly encode watermark information into the agent's final output, without requiring complex behavioral sequence encoding. Such a mechanism would likewise require no model training, preserve normal execution, and avoid dependence on the observability of intermediate trajectories. The paper does not sufficiently explain the unique advantages of behavioral encoding over output-level watermarking, nor does it compare against such simple baselines.

Questions for authors
  1. In realistic commercial agent API deployments, why should a repackaging adversary be assumed to expose intermediate execution trajectories? How would the proposed method verify ownership if the adversary only returns the final execution results?

  2. Why is it necessary to embed watermarks into agent behavior sequences rather than directly into the final output through an authenticated forensic branch? What unique advantages does the proposed approach offer over a simple API-level challenge-response mechanism?

5 comments

Question-1: In realistic commercial agent API deployments, why should a repackaging adversary be assumed to expose intermediate execution trajectories? How would the proposed method verify ownership if the adversary only returns the final execution results?

Response-1: Observability of execution records and verification with final outputs only.

Thank you for raising this concern. We clarify the interface assumption of the behavioral construction and how the authenticated forensic branch can accommodate a different evidence carrier.

1. Practical relevance and scope of action-visible interfaces.

Action-visible interfaces have a practical basis. Wang et al. report that 24 of 29 surveyed agent platforms and frameworks (82.8%) provide grey-box default observability, exposing action sequences for billing and debugging while withholding raw internal reasoning. Their examples include Coze and Dify [1, Section II-A and Appendix A].

In our repackaging scenario, the adversary accesses the protected agent through an API and integrates its capabilities into another application. For services offering execution monitoring, auditing, and user intervention, action records form part of the user-facing functionality. These services motivate our focus on action-visible repackaging interfaces.

The behavioral instantiation uses externally exposed action records and does not require access to model parameters, source code, or private reasoning traces. Its visibility requirement is that the returned records retain sufficient action information and step correspondence for decoding. We will state this interface assumption explicitly in the revision.

2. Verification when only final results are returned.

LoRo-Mark’s authenticated-branch architecture can also support ownership verification through final responses alone. In this output-level instantiation, the protected harness encodes the ownership identifier and a request-bound response MAC into the final response using an error-correcting code. The owner then decodes the identifier and verifies the MAC directly from the returned response, without requiring intermediate execution records. We have implemented this output-carrier option in the MAC+ECC baseline used in our comparison.

This instantiation preserves ordinary execution through the same authenticated branch isolation and enables verification whenever sufficient encoded evidence survives frontend processing. The forensic branch can therefore accommodate different carriers according to the information exposed by the service interface.

When action records are also available, behavioral encoding provides a carrier that can retain ownership evidence under filters that remove explicit response identifiers while preserving ordered action records. Our response to Q2 evaluates this advantage over the output-level baseline.

[1] Wang et al., On Protecting Agentic Systems’ Intellectual Property via Watermarking, Section II-A and Appendix A.

Question-2: Why is it necessary to embed watermarks into agent behavior sequences rather than directly into the final output through an authenticated forensic branch? What unique advantages does the proposed approach offer over a simple API-level challenge-response mechanism?

Response-2:

The authenticated forensic branch supports both output-level and behavioral carriers, as discussed in our response to Q1. Both can preserve ordinary execution through branch isolation. Behavioral encoding provides an additional verification channel when frontend processing removes explicit response proofs while retaining ordered action records.

Why the evidence carrier matters.

We instantiate the output-level alternative you suggest as a MAC-authenticated response identifier protected by ECC. Without tampering, both this baseline and LoRo-Mark successfully recover and verify the identifier.

In the output-level baseline, the encoded proof is returned as an explicit receipt, either in an auxiliary field or within the final answer. Such receipts can be targeted by field-based or encoded-string filtering. Removing them does not require breaking the MAC or decoding the payload. Once the complete encoded receipt is removed, additional ECC redundancy cannot restore the missing evidence.

LoRo-Mark instead embeds ownership information in the agent’s selected behaviors. In action-visible interfaces, execution records also provide information used for auditing, monitoring, and user intervention. When the wrapper continues to return identifiable, ordered action records, these records provide a carrier that does not depend on retaining a separate textual receipt. Our comparison evaluates this setting: explicit response proofs are filtered, while ordered action records remain available for verification.

Executable task and filtering results.

We evaluated this distinction on a file-auditing task involving 32 files, using DeepSeek-V4.1-Flash-1017 and a custom harness implementing LoRo-Mark. The harness performed actual file reads and integrity and format checks. A simulated frontend wrapper applied the same filtering rules to each backend response, scanning all string values, including answers, additional fields, action parameters, and observations. Verification used only the resulting client-visible JSON and owner-held verification information.

Both methods transmitted the same 104-bit identifier and a 128-bit request-bound response MAC, used the same repetition code, and made two model requests each. We evaluated the output-level baseline with the encoded proof placed either in an auxiliary proof field or in the final answer.

Frontend filtering policy, with ordered action records retainedLoRo-MarkID+ECC in an auxiliary proof fieldID+ECC in the final answer
Recursive filtering of long encoded stringsRecoveredNot recoveredNot recovered
Field allowlist plus encoded-string filteringRecoveredNot recoveredNot recovered

These entries report the observed recovery outcomes for the executable task instance. Both baseline placements verified successfully before filtering. After filtering, their encoded receipts were removed, while LoRo-Mark remained verifiable from the retained behavior sequence.

These results demonstrate a carrier advantage under the tested receipt-filtering policies. With the payload, repetition code, and model-request count held fixed, behavioral encoding preserves recoverable ownership evidence in the retained action records, whereas neither placement of the explicit response proof remains recoverable.

Thank you to the authors for their detailed responses and additional experiments. I acknowledge that the proposed method is technically sound under its specified threat model, and the new experiments provide further evidence of its feasibility and advantages in the considered setting.

However, I still have concerns about the practical realism and generalizability of the threat model, particularly the assumption that a repackaging adversary would preserve sufficiently detailed and identifiable execution trajectories for watermark verification.

Overall, the rebuttal has partially addressed my concerns and improved my assessment of the paper. I would prefer to raise my score to 2.5, but since this option is unavailable, I have decided to increase my rating from 2 to 3, while maintaining my reservations about the practical applicability of the proposed approach. I hope the AC will take this into account when making the final decision.

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

The paper studies agent-attribution verification for services accessed and wrapped through an API. LoRo-Mark authenticates requests with a MAC, only legitimate forensics requests enter the watermarking branch, while ordinary requests follow the original execution path. In the forensics branch, a 104-bit identifier is encoded with repetition and then transmitted through key-controlled behavioral choices. The paper gives a reduction establishing losslessness for ordinary requests, along with recovery bounds under random action substitution and prefix truncation at fixed context, and validates the design on function-calling tasks.

Critical strengths
  1. Turning "everyday service is unaffected" into a checkable design property. Theorem 1 does not require the LLM to obey a hidden trigger prompt: when the trigger is absent, the original path runs, and the trigger probability is controlled by authentication security. Compared with the trigger-based black-box watermarking of Adi et al. [1], the most valuable advance here is that isolation is enforced at the agent harness rather than requiring the model to learn two non-interfering behaviors.
  2. Making the redundancy cost of active forensics explicit. Per-request key mapping and repetition coding make recovery independent of any single action; Table 2 reports both recovery rate and the cost at 52, 87, and 122 steps, which is more informative than reporting detection only in the no-attack setting.

[1]. Adi, Yossi, et al. "Turning your weakness into a strength: Watermarking deep neural networks by backdooring." 27th USENIX security symposium (USENIX Security 18). 2018.

Critical weaknesses
  1. The decoding context the error-correction guarantee depends on is exactly what a wrapper is allowed to modify. §3.1 permits rewriting the presented thoughts, actions, and observations, yet Algorithm 5 requires reconstructing the same (ot,Bt)(o_t, B_t) from the exposed context, and Appendix A folds original step identifiers into the key input. If observations are rewritten or the step correspondence is lost, the problem is no longer a few corrupted code symbols — it can become a wholesale mapping mismatch. The proofs in Appendix B assume a reconstructable context and do not close this gap. What is proved today is therefore recovery on a synchronous channel, which is insufficient to support the claimed black-box verification of a wrapped service.
  2. The lossless comparison changes the verification task, and the robustness benefit leans heavily on artificial capacity. LoRo-Mark leaves no evidence on ordinary requests, yet Table 1 compares utility against behavior watermarking on everyday trajectories; zero loss does not mean the same detection problem is being solved. In active forensics, Table 2 fixes 64 candidate actions, a 104-bit message, and 52 steps: under the default configuration, recovery is only 33.6% at 20% random substitution and 4.7% at 30%. The 34.6% prefix recovery corresponds to leaving the first complete message intact and cannot be extrapolated to arbitrary deletion or adaptive wrapping. The paper should explain why a real forensics task supplies so many executable choices, and should compare against baselines that are also allowed an independent forensics branch.
Questions for authors
  1. After the presentation-level modifications allowed by the threat model, through what trustworthy information does the verifier reconstruct the original context, candidate set, and step identifiers? If this information is unavailable, which part of the guarantee survives?
  2. Are the 52 steps and 64 candidates per step drawn from a real executable forensics task, or from an artificially expanded action table? Under the same active-forensics permissions and call budget, what is the substantive difference between LoRo-Mark and a MAC-authenticated response identifier plus an error-correcting code as a baseline?

Branch isolation is a sound engineering design, but the current evidence is insufficient to distinguish a "robust agent watermark" from "an authenticated forensics interface that depends on a reconstructable trajectory." I would reconsider if the authors can clarify the verification channel and demonstrate superiority over an equal-privilege baseline on a real forensics task.

2 comments

Question-1: After the presentation-level modifications allowed by the threat model, through what trustworthy information does the verifier reconstruct the original context, candidate set, and step identifiers? If this information is unavailable, which part of the guarantee survives?

Answer-1: Thank you for highlighting the reconstruction requirements of the verification procedure. We address this concern in four parts: verification without relying on displayed observations, the source of the forensic candidate set, the identification of original step indices, and the guarantees that remain when the required information is unavailable.

Verification when observations are modified or unavailable.

Thank you for highlighting the reconstruction requirements of the verification procedure. We clarify below how an observation-independent instantiation of LoRo-Mark removes the dependence on displayed observations, together with its remaining requirements.

Algorithm 4 in Appendix A presents the standard context-dependent instantiation of LoRo-Mark, in which the per-step mapping is defined as

\operatorname{PRF}\bigl(k_{\mathrm{step}}, o_t, \mathcal{B}_t\bigr).$$ This instantiation assumes that the verifier can reconstruct the observation context and candidate set used during embedding. Under this assumption, the encoder and verifier generate the same permutation and can consistently map between behaviors and code chunks. We agree that this reconstruction is not guaranteed if the required context is obtained solely from observations that a repackaging adversary can modify or suppress. **To address this concern, we now specify an observation-independent instantiation within the same framework.** This instantiation derives the per-step mapping from information already available to the owner and the protected harness, removing its dependence on the displayed observations. We will include this construction and its assumptions explicitly in the revised manuscript. For an authenticated forensic request $T^*$, let $\eta$ be an owner-generated forensic timestamp included in the authenticated request content and retained locally by the owner. Let $\mathcal{B}^{\mathrm{F}}$ be a predefined forensic candidate table shared by the owner and the protected harness. Using the request-specific key $k_{\mathrm{step}}$, both parties derive $$s_t = \operatorname{PRF} \bigl( k_{\mathrm{step}}, \operatorname{Encode}(\eta,t) \bigr),$$ and $$\pi_t = \operatorname{Permute} \bigl( \operatorname{Canon}(\mathcal{B}^{\mathrm{F}}); s_t \bigr).$$ Here, $\operatorname{Encode}$ provides an unambiguous encoding, $\operatorname{Canon}$ fixes the candidate identities and their canonical ordering, and $\operatorname{Permute}$ generates a permutation deterministically from the seed $s_t$. The next copyright-code chunk determines an index $j_t$, and the harness selects $$b_t = \pi_t[j_t], \qquad b_t \in \mathcal{B}^{\mathrm{F}},$$ producing the forensic behavior sequence $$\tau = (b_1,\ldots,b_S).$$ For each identifiable surviving behavior whose original step index $t$ is available, the verifier reconstructs the same permutation and maps the behavior back to its corresponding code chunk. The required request information comes from the owner's locally retained authenticated query, and the candidate table comes from the owner's configuration; neither needs to be reconstructed from the displayed observations. The timestamp need not be secret, since the pseudorandomness is supplied by the secret key. **Consequently, modifying or suppressing the displayed observations does not, by itself, disrupt reconstruction of the per-step mapping in this instantiation.** This change concerns the inputs used to generate the mapping; the authenticated branch and redundant behavioral encoding remain unchanged. The construction still requires identifiable surviving behaviors and their original step indices. It removes the dependence on displayed observations but does not, by itself, recover step alignment after arbitrary deletions or reordering. We will make this distinction explicit in the revision so that the reconstruction requirements and the scope of the robustness guarantees are clearly stated.

Question-2: Are the 52 steps and 64 candidates per step drawn from a real executable forensics task, or from an artificially expanded action table? Under the same active-forensics permissions and call budget, what is the substantive difference between LoRo-Mark and a MAC-authenticated response identifier plus an error-correcting code as a baseline?

Answer-2: Thank you for suggesting this comparison. For ordinary requests, candidate behaviors come from the model-generated list along the original execution path. For authenticated forensic requests in the observation-independent instantiation described above, candidates come from a table predefined by the copyright owner and shared with the protected harness. The paper uses a constructed 64-behavior table as an illustrative capacity configuration. At six bits per step, the original 104-bit identifier with threefold repetition requires 52 steps. In practical deployments, the table size can be adapted to the forensic task, provided that its entries correspond to valid, distinguishable behaviors.

The substantive difference is the evidence carrier under frontend filtering.

We implemented the suggested MAC-authenticated response identifier plus ECC baseline. Without tampering, both methods successfully recover and verify the identifier. However, an explicit authentication receipt—such as an auxiliary proof field or a long encoded string unrelated to the task answer—can be targeted by field-based or format-based filtering. A repackager can remove such content before displaying the response without breaking the MAC or decoding the payload. Once the entire encoded receipt is removed, increasing ECC redundancy cannot restore the missing evidence.

LoRo-Mark embeds the information in the agent's selected behaviors. In trajectory-exposing interfaces, execution records support auditing, billing transparency, progress monitoring, and user intervention. Preserving these interface capabilities requires retaining the corresponding execution information. Our comparison examines frontend wrappers that retain ordered action records while filtering explicit textual receipts. In this setting, LoRo-Mark can recover ownership evidence from the retained behavioral choices even when auxiliary proof fields or encoded strings are removed.

Executable task and filtering results.

As requested, we evaluated this distinction on a file-auditing task involving 32 files, using DeepSeek-V4.1-Flash-1017 and a custom harness implementing LoRo-Mark. The harness performed actual file reads and integrity and format checks. A simulated frontend wrapper applied the same filtering rules to each backend response, scanning all string values, including answers, additional fields, action parameters, and observations. Verification used only the resulting client-visible JSON and owner-held verification information.

Both methods transmitted the same 104-bit identifier and a 128-bit request-bound response MAC, used the same repetition code, and made two model requests each. We evaluated two baseline placements: an auxiliary proof field and the final answer.

Receipt-filtering policy, with ordered action records retainedLoRo-MarkID+ECC in an auxiliary proof fieldID+ECC in the final answer
Recursive filtering of long encoded stringsRecoveredNot recoveredNot recovered
Field allowlist plus encoded-string filteringRecoveredNot recoveredNot recovered

These entries report the observed recovery outcomes for the executable task instance. Both baseline placements verified successfully before filtering. After filtering, their encoded receipts were removed, while LoRo-Mark remained recoverable from the retained behavior sequence.

The demonstrated advantage is resistance to explicit-receipt removal when ordered behavioral evidence remains available. Under the tested filtering policies, embedding ownership evidence in behavioral choices preserves a verification channel that is lost when the evidence is returned as an explicit authenticated identifier protected by ECC.

Comments on the paper

2 comments
Area_Chair_cNhpOpenReview ↗

Please engage with the authors responses

Dear Reviewers,

This is a polite reminder to engage with the authors responses to your comments.

Thank you again for your time and effort in reviewing,

Kind regards,

Your ICLR Area Chair

Area_Chair_cNhpOpenReview ↗

Last 24 hours of the reviewer discussion period

Dear Authors and Reviewers

Just a reminder we are soon to be entering the last 24 hours of the reviewer discussion period.

Authors: If you have not yet responded to the reviews and intend to please do so ASAP. Please note reviewers will most likely not have time to respond to any late rebuttal comments so please make sure any comments are clear and not in need of further clarification.

Reviewers: If the authors have responded to your reviews and you have not yet responded please do so, even if it is a one line response acknowledging you have read the rebuttal.

Thanks for all your time, and I hope you all learnt something interesting during the process.

Kind regards,

Your ICLR Area Chair

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.