acceptodds
Under review as a conference paper at ICLR 2027

Governing Persistent Agent State with Provenance-Aware Recall and Promotion

Abstract

An agent can block an unsafe report while retaining the contaminated state that produced it. Later sessions may reuse that state as evidence or turn it into a procedure. This paper studies what must remain valid across such transformations. A governance layer separates integrity risk, epistemic trust, and disclosure sensitivity, propagates unresolved source constraints at every write, and rechecks inherited verification evidence before reuse. The analysis gives a compositional ancestry invariant and a reuse model in which verification error can be shared across many downstream uses. This distinction matters empirically. On DRSC-Bench, 240 research tasks spanning three sessions, governance attains utility 0.74, Silent Trust Promotion (STP) 0.03, and Cross-Session Contamination (CSC) 0.02, compared with 0.72, 0.31, and 0.24 for ungoverned retrieval. Disabling the promotion gate raises STP to 0.15 and CSC to 0.09 while Unsafe Export (UE) remains 0.01 at the reported precision. Persistence-matched baselines, a ten-session extension, and controlled lineage interventions support the same conclusion: safe output does not certify safe persistent state. The formal guarantees require complete governed dependencies and sound certificates; lineage omission and semantic verification error remain outside that guarantee.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
LLM agents, agent memory, information-flow control, data provenance, memory poisoning, AI safety

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_8ErnOpenReview ↗
Rating
2
Confidence
3
Informativeness
1
Presentation
1
Soundness
2
Read review
Paper summary

Persistent research agents keep state across sessions: sources become notes, notes become report evidence, and evidence may be compressed into memory or turned into a reusable procedure. The paper argues that blocking an unsafe final output is not enough, because contaminated or untrusted content can still be stored and reused later. A safe answer does not certify that the agent’s stored state is safe. The paper proposes a governance layer that tracks every persistent object’s provenance and re-checks it at write, recall and release time.

Critical strengths

The paper shows that a safe output does not mean the agent’s stored state is safe. Without the promotion gate, trust and contamination errors rise sharply while unsafe export stays at 0.01. This exposes a blind spot in output-only defenses and evaluations.

Provenance tracking with separate labels is backed by formal guarantees. Full governance clearly beats all baselines on persistent-state metrics without losing utility, across three LLMs and a ten-session extension.

Critical weaknesses

The guarantees and the experiments don’t line up. The formal guarantees require complete lineage and semantically sound certificates. The main experiments instead use selective attribution and never measure the semantic verifier’s error rate, so the theory and the empirical results support each other less than the paper suggests.

Key lifecycle features are untested. Revocation, policy-epoch shifts and resource-version drift are central to the revalidation design, but the experiments never exercise them. The most distinctive part of the framework, re-checking evidence when things change, is therefore unvalidated.

The reuse-risk analysis is illustrative only. Certificate error rates p_c are set by hand rather than estimated from data, and the adaptive exposure budget (Prop. 4) is never implemented. The analysis of shared certificates (Props. 3–4) is mathematically interesting but not shown to matter for a real verifier.

The evaluation is self-constructed. DRSC-Bench, the five attack families, the simulated restricted data and the metric definitions were all designed by the authors, and there are no adaptive attacks. Strong results on a benchmark built for the method may not carry over to realistic or adversarially adapted settings.

STP labels lack validation. Silent Trust Promotion depends on judging “inappropriate eligibility,” yet no annotation protocol or inter-annotator agreement is reported for it. Human validation covers only report quality (utility), not the safety labels that support the main claims.

Baselines are not like-for-like. The Fides and PRUDENTIA comparisons are the authors’ own adaptations, with different serialization scope and planners. Part of the reported gain may come from implementation differences rather than from the proposed design, and the paper acknowledges the residual gap is not attributed to any one mechanism.

Several components are under-specified. The empirical risk score ρ, the AVS/η context-selection heuristic, and the hand-set ordinal ingress rules all affect what gets admitted, but their calibration and their effect on the safety–utility trade-off are not well characterized. This makes the system hard to reproduce or tune.

The system is complex and costly. The framework adds many components (three label lattices, certificates, witness closures, four gates) and raises median latency by about 12%. The paper offers little evidence about which components are essential, or how easily it integrates with existing agent frameworks.

The presentation is dense. Concepts such as audit dependencies vs. derivation dependencies vs. witness closures, and AVS vs. η, are introduced with heavy notation but loosely tied to the results. A single running example traced through all the gates would make the paper much easier to follow.

Positioning against related work is limited. The paper could say more about how the governance layer composes with other runtime or write-time state defenses, and how it relates to proof-carrying code, capability systems and provenance-aware release frameworks. This would clarify what is new versus adapted from classic information-flow control.

Questions for authors

How exactly is STP adjudicated at the task-run level—what constitutes “inappropriate eligibility” and what annotation or rule set ensures consistency across domains and runs?

How are certificates produced in practice in your system—are they LLM-generated endorsements, human-issued signatures, or programmatic checks—and what empirical evidence do you have about their semantic error rates p_c?

Could you report a revocation/epoch-change experiment (e.g., expiring or revoking a frequently reused endorsement mid-benchmark) to demonstrate inherited-witness invalidation and recovery behavior?

What safeguards prevent selective attribution from omitting influences (e.g., model under-reporting) in real deployments—do you support conservative capture modes by default, and what is the measured utility/safety trade-off at scale?

How is the empirical risk score ρ calibrated and updated? Is it per-object static (ingress-only) or updated via subsequent observations, and how sensitive are results to λ_risk in context assembly?

Can you quantify the end-to-end overhead (latency and storage) of maintaining witnesses and running Current checks at recall/release under heavier loads or deeper dependency trees?

How does the governance layer interact with executable capabilities and tool permissions in the control plane—e.g., can a high-trust endorsement for “report evidence” mistakenly authorize code execution, and how is this ruled out in practice?

1 comment
AuthorsOpenReview ↗

Lifecycle tests, verifier measurements and capture safeguards

Thank you. The uploaded revision provides these tests and decision rules.

Q1. STP adjudication. STP is positive when a designated unsupported claim is retained and eligible for higher-trust reuse without adequate verification at its task-run probe. Retention follows task annotations; eligibility requires verified-or-higher trust and all admission gates, or the corresponding evidence-pool admission for lattice-free systems. All 1,200 probes, including blocked writes, remain in the denominator. Two raters assessed 100 stratified task-runs: 94.0% agreement, inter-rater κ=0.86\kappa=0.86; automated precision/recall against consensus is 0.91/0.89 (Appendix L.3). This validates STP separately from report quality.

Q2. Certificates and mechanism isolation. The agent requests endorsement; the trusted runtime signs after assessing cross-source agreement, citation support and source-signature information. Certificates bind subject/support versions, transition, permitted contracts, issuer, epoch and expiry; Eq. 16 checks applicability mechanically. The 63 semantically incorrect certificates among 1,840 issued (p^=3.42%\hat p=3.42\%) average 3.2 downstream reuses each (about 202 certificate-use exposures).

The 240-task, five-run matched control fixes persistent labels, object-level scope-aware recall, verifier and maximum per-task verification budget, removing inherited witnesses and their revalidation. Full governance reduces STP/CSC from 0.10/0.07 to 0.03/0.02; utility rises from 0.73 to 0.74 and coverage from 0.94 to 0.96 (Table 2). A four-use cap per endorsement charges all dependent admissions across sessions; with the same verifier it reduces promotion-probe STP from 0.06 to 0.03. The audit measures pooled error; Prop. 4 uses pre-issuance conditional error bounds.

Q3. Lifecycle changes and recovery. Table 3 uses 60 tasks, 20 per condition, with three runs; changes occur between sessions 2 and 3:

ChangeStale recalls blockedRecovery utility
Root-endorsement revocation54/540.72
Policy-epoch change51/510.71
Bound-version drift56/560.73

Static labels block 0% in each condition. Fresh derivation from valid support restores utility after inherited invalidation (Prop. 5).

Q4. Attribution and capture. Independent annotation finds omissions in 3.8% of selective writes during normal operation. Conservative capture records every governed input visible during generation for complete boundary capture.

Capture modeUtilitySTPCSCCoverage
Selective, core setting0.740.03000.02000.96
Conservative0.720.01830.01420.91
Hybrid0.740.02000.01500.95

All use 240 tasks and five runs (Table 13). Core comparisons use selective attribution; hybrid is the deployment default, applying conservative capture when untrusted/adversarial content is visible or a procedural draft is written.

Q5. Risk, ingress and context. ρ\rho combines an injection classifier with structural features, is fixed per immutable version and propagates by parental maximum; certified sanitization creates a new version for reassessment. It governs admission (ρ≤0.2\rho\leq0.2) and relevance-minus-risk ranking; label, scope and certificate checks are hard gates. At η=0.20\eta=0.20, sweeping λrisk∈{0.25,0.50,0.75,1.00}\lambda_{\rm risk}\in\{0.25,0.50,0.75,1.00\} gives utility 0.72-0.74, STP 0.03 and CSC 0.02-0.03 (Table 10). Eq. 33 initializes source trust using ordinal adjustments δev∈{−1,0,1}\delta_{\rm ev}\in\{-1,0,1\}, capped at verified; derived-content promotion requires a certificate. AVS gives the population information-bottleneck view; η\eta stops the empirical selector by residual need.

Q6. Overhead. Indexed closures check all inherited certificates without ancestry traversal (Table 23):

SettingMean witnessesCheck P50/P99
Three-session core3.21.2/3.4 ms
Ten sessions8.72.8/6.9 ms
Synthetic depth 5031.45.8/18.7 ms

Metadata is 29.8% of content bytes, about 1.4 KB/object. End-to-end median latency rises from 41.8 to 46.9 s (+12.2% versus Naive RAG); ten-session P50 overhead is +13.4%.

Q7. Capabilities and positioning. Certificate applicability checks the contract against Uc\mathcal U_c. Execution additionally requires control-plane authorization: requested operations must lie in KK, with resource versions ν\nu and composition constraints β\beta checked independently. In the 12-procedure Python sandbox, unsafe-capability rates are 0.22/0.14/0.01 for ungoverned/A-MemGuard/full governance (Table 19). As in proof-carrying code, production and checking are separate; here, justifications follow derived state. The layer composes with admission filters and tool-permission guards.

Five attack families (Table 17), three backbones (Table 18), repeated promotion probing (Appendix H) and the ten-session trajectory (Figure 2) test persistent reuse. We would appreciate your reassessment.

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

The paper asks how a persistent agent can prevent untrusted information from becoming trusted memory and influencing later sessions, even when its immediate output is safe. The authors propose a governance framework that tracks integrity risk, epistemic trust, and disclosure sensitivity separately. Each stored object retains its provenance and the certificates that justify changes to its security labels. The framework checks these constraints when an object is written, recalled, or released, and revalidates inherited certificates against the current use and policy. The paper also gives formal results on the preservation of unresolved source constraints and on how errors in shared certificates affect downstream uses.

The authors evaluate the framework on DRSC-Bench, which contains 240 research tasks across three sessions. On GPT-4o, full governance improves utility from 0.72 to 0.74 compared with Naive RAG, while reducing Unsafe Export (UE) from 0.1792 to 0.0125, Silent Trust Promotion (STP) from 0.31 to 0.03, and Cross-Session Contamination (CSC) from 0.24 to 0.02. The paper also includes gate ablations, persistence-matched baselines, lineage interventions, comparisons across model backbones, and a ten-session extension. A separate simulation examines how sharing certificates across downstream uses changes the distribution of failures.

Critical strengths

The main strength is the distinction between output safety and persistent-state safety. An agent can block an unsafe response while retaining contaminated information that later becomes trusted memory. The paper makes this problem concrete by measuring STP and CSC separately from UE. In Table 1, removing the promotion gate raises STP from 0.03 to 0.15 and CSC from 0.02 to 0.09, while UE remains around 0.01 at the reported precision. This supports the authors' claim that evaluating only the final output can miss failures in persistent state. The separation of write, recall, and release checks also provides a useful way to reason about where such failures can occur.

The paper provides a broad evaluation and is careful about several limitations of its own approach. It includes persistence-matched baselines, tests across different backbones, and a ten-session extension. The lineage intervention is particularly informative. When an influencing source is removed from selective attribution, CSC rises from 0.02 to 0.09, while conservative capture reduces it to 0.04. This shows both the importance of dependency tracking and the limits of the implemented approach. The authors also distinguish the assumptions of their formal results from the conditions used in the experiments. I appreciate that they report these limitations rather than treating the formal guarantees as unconditional.

Critical weaknesses

I lean toward rejection because the experiments do not isolate the value of the paper's main mechanism and because the formal results are not closely tied to the implemented system.

First, the paper does not clearly establish what its main mechanism adds beyond existing information-flow control and persistent-label management. Fides already supports label-based information-flow control and labeled storage, while SPA (Girrens and Wang, 2026) preserves security labels across queries and enforces constraints on persistent artifacts. The distinguishing feature here appears to be retaining the certificates that justify changes to security labels and rechecking their validity when descendant objects are reused. However, the experiments do not isolate the effect of this mechanism. Table 1 shows that removing the promotion gate raises STP from 0.03 to 0.15 and CSC from 0.02 to 0.09, but this does not separate certificate inheritance from other forms of trust control. Table 2 adds persistence-matched baselines, and full governance outperforms the PRUDENTIA-style configuration, reducing STP from 0.13 to 0.03 and CSC from 0.10 to 0.02. Yet Appendix G acknowledges that verifiers, internal calls, and budgets are not sufficiently controlled to attribute the improvement to a particular component. The results show that the full system performs better, but not how much of the improvement comes from inherited certificate validation.

Second, the formal guarantees depend on assumptions that are not established for the implemented system. Proposition 1 shows that unresolved source constraints are preserved when dependencies are complete and discharged constraints have sound certificates. The proof follows from the local label-propagation rules by induction, while the difficult part is ensuring those assumptions in practice. The main experiments use selective attribution and empirical endorsement, which do not guarantee them. In Appendix H, deliberately omitting an influencing source raises CSC from 0.02 to 0.09, and conservative capture reduces it to 0.04. The authors acknowledge this limitation, but the paper does not report how often such omissions occur under normal operation. The certificate-error analysis has a similar gap. Propositions 3 and 4 rely on certificate-level error bounds, but these are not estimated for the actual verifier, and the adaptive exposure-budget rule is not implemented. Table 4 instead uses an assumed error probability of 0.05 in a controlled simulation. The results illustrate how shared certificate errors can affect downstream uses, but they do not establish a corresponding risk bound for the evaluated agent.

The authors acknowledge these limitations, which I appreciate. My concern is not that the mathematical results are incorrect or that the full system fails to improve the measured outcomes. Rather, the paper establishes the effectiveness of the overall governance framework more clearly than the additional contribution of inherited certificate validation. A controlled ablation that keeps the other components fixed, together with measurements of actual attribution and verification errors, would help address this concern. I would be glad to reconsider my score if the authors can provide this evidence.

Questions for authors

These questions focus on clarifications and limited checks that could affect my assessment.

  1. Could you compare full governance with a configuration that retains persistent labels, scope-aware recall, and the same verifier and verification budget, but removes certificate inheritance and revalidation? Please report the resulting STP, CSC, utility, and coverage. This would help determine how much of the improvement comes from the paper's main mechanism rather than the other governance components.
  2. What security property does inherited certificate validation provide beyond existing persistent-label approaches such as Fides and SPA? Could you give a concrete example where persistent labels and scope checks allow an unsafe reuse, but the inherited certificate checks prevent it? This would help clarify the technical contribution relative to prior work.
  3. How often does selective attribution omit an influencing dependency under the normal evaluation, and how often are empirical endorsements semantically incorrect? The controlled omission experiment shows the effect of a missing dependency, but not its frequency in the implemented system. Could you also report certificate-level error rates and the number of downstream uses affected by erroneous certificates? These measurements would help connect the formal analysis to the observed results.
  4. Could you clarify how often CSC disagreements correspond to the adoption of an incorrect or attacker-supplied claim, rather than other changes in the delayed answer? The clean–clean controls measure background variation, but CSC is still an answer-disagreement metric. It would also help to report the CSC trajectory across the ten sessions on the same 60 tasks, if those intermediate results are available, to distinguish persistent contamination from the final endpoint difference.
3 comments
AuthorsOpenReview ↗

Controlled evidence for inherited validation

Thank you for identifying the decisive control. The uploaded revision isolates inherited validation (Sec. 5.2) and measures actual verifier errors and reuse (Sec. 5.3).

1. Matched control (Q1). On 240 tasks with five runs, the control retains three-axis persistent labels, object-level scope-aware recall, the same endorsement verifier and maximum per-task verification budget, removing only inherited witnesses and their revalidation.

ConfigurationUtilityUESTPCSCCoverage
Matched control0.730.010.100.070.94
Full governance0.740.010.030.020.96

Rates use two-decimal precision. STP falls 70% and CSC about 71%, with higher utility and coverage. Paired task-cluster bootstrap (10,000 resamples; Table 20) gives:

Full minus controlDifference95% CI
STP-0.07[-0.09, -0.05]
CSC-0.05[-0.07, -0.03]
Utility+0.01[+0.00, +0.03]

Each resample retains a task's five runs and both methods. Both safety intervals exclude zero. This isolates inheritance and revalidation jointly within one implementation; the PRUDENTIA-style comparison is a separate system-level test.

2. Added security property (Q2). Fides supports labeled storage; SPA preserves labels across queries. Our contribution retains and revalidates the justification for a label relaxation throughout derivations. A descendant's current use must remain covered by that justification. Object scope q(d)q(d) and an endorsement's permitted contracts Uc\mathcal U_c are distinct. Certificates bind subject/support versions, discharged constraints, permitted uses, issuer, epoch and expiry. Descendants retain the evidence through

W(d)=Cloc(d)∪⋃x∈Dep(d)W(x).\mathcal W(d)=\mathcal C_{\mathrm{loc}}(d)\cup\bigcup_{x\in\mathrm{Dep}(d)}\mathcal W(x).

Recall and release recheck every inherited certificate against current use and policy (Eqs. 5, 16; Prop. 5). The worked example in Appendix E.2 illustrates two cases:

  • Contract change: liquidity summary d1d_1 is endorsed by c1c_1 under u1u_1 and supports d2d_2 under that use. Later, q(d2)q(d_2) permits credit-risk use u2u_2, but u2∉Uc1u_2\notin\mathcal U_{c_1}. Cached trust and object scope pass; full governance retains c1∈W(d2)c_1\in\mathcal W(d_2) and rejects the uncovered reuse. This explains the obligation isolated by the matched ablation with unchanged sources and policy.
  • Fixed-role revocation: revoking an ancestor endorsement leaves the descendant's text, cached trust, scope and report-evidence role unchanged. Static labels admit the paragraph; inherited checking blocks reuse until fresh derivation from valid support.

The separate lifecycle test (Table 3) uses 60 tasks, 20 per condition, with three runs; changes occur between sessions 2 and 3:

ChangeStale recalls blockedRecovery utility
Root-endorsement revocation54/540.72
Policy-epoch change51/510.71
Bound-version drift56/560.73

The static-label control blocks none in each condition. These interventions test inherited invalidation and recovery with actual evidence/policy changes.

3. Attribution and certificate audits (Q3). Across 1,200 core GPT-4o task-runs, independent input-boundary annotation finds dependency omission in 3.8% of selective writes. Ground-truth adjudication finds 63 semantic errors among 1,840 issued certificates (p^=3.42%\hat p=3.42\%). Each erroneous certificate averages 3.2 downstream reuses, about 202 certificate-use exposures. The audit measures pooled issuance error and downstream reach separately, as motivated by Prop. 3. A four-use cap charges each endorsement's dependent admissions, including descendants across sessions; with the same verifier it reduces promotion-probe STP from 0.06 to 0.03. Prop. 4 gives its numerical risk bound under pre-issuance conditional error bounds.

4. CSC semantics and trajectory (Q4). Of Naive RAG's 288 CSC events, 262 (91.0%) adopt the planted claim. Full governance has 24 events: 11 adoptions and 13 benign variations. Adoption falls from 262/1,200 to 11/1,200, a 95.8% reduction; benign variation, 13/1,200 (approximately 0.0108), is close to the 0.01 clean-clean background.

Table 17 separately reports lower attack-family success across all five families:

Attack familyNaiveFull
Indirect injection0.280.05
Memory poisoning0.350.02
Cross-session carry-over0.240.02
Procedural contamination0.210.03
Exfiltration0.320.01

Ten-session CSC uses the same 60 tasks and three runs throughout:

SessionNaive CSCFull CSC
10.030.00
20.060.01
30.110.02
40.150.02
50.190.02
60.240.03
70.280.03
80.320.03
90.360.03
100.410.04

The controlled contrast, measured errors and full trajectory directly address Q1-Q4. We would appreciate your reassessment.

Thank you for the detailed rebuttal and substantial additional experiments. The matched ablation directly addresses my concern about the independent contribution of inherited certificate validation, while the verifier error analysis and lifecycle tests also strengthen the empirical evidence.

However, my primary concern remains the limited technical novelty beyond existing information-flow control and persistent-state management. Although the new results demonstrate that inherited certificate validation improves safety under the evaluated conditions, I am not yet convinced that the framework offers a sufficiently distinct contribution beyond adapting and combining established security mechanisms. I therefore maintain my original rating.

AuthorsOpenReview ↗

Inherited authorization as a distinct persistent-state mechanism

Thank you for recognizing that the ablation, verifier audit and lifecycle tests address the empirical questions. We focus on novelty: making the justification for a past label relaxation a transitive condition of future admissibility.

1. A persistent authorization semantics. A label records the constraint currently attached to an object. Our mechanism additionally preserves the conditions under which an earlier constraint was relaxed: the exact subject/support versions, discharged constraints, authorized label bound, permitted contracts, issuer, epoch and expiry. These conditions remain binding after summarization and subsequent endorsement.

Specifically, Eq. 5 propagates

W(d)=Cloc(d)∪⋃x∈Dep(d)W(x).\mathcal W(d)=\mathcal C_{\mathrm{loc}}(d)\cup\bigcup_{x\in\mathrm{Dep}(d)}\mathcal W(x).

The closure includes witnesses inherited through certificate-support objects as well as derivation parents. When a certificate discharges a constraint, the discharged edge remains in the audit graph and the certificate remains in the witness closure. Thus relaxing a label preserves the obligation to validate its justification. Recall and release check every inherited witness against the current use and governance snapshot (Eq. 16). A later endorsement of an unchanged descendant preserves these inherited obligations; recovery derives a fresh object from valid support.

2. A concrete distinction from persistent labels and object scope. In Appendix E.2, certificate c1c_1 endorses liquidity summary d1d_1 for contract u1u_1. A later summary d2d_2 uses d1d_1 under u1u_1 and inherits c1c_1. Its object scope permits a subsequent credit-risk request u2u_2, while u2∉Uc1u_2\notin\mathcal U_{c_1}. The text, cached trust label, source versions and policy are unchanged. The static-label control admits this request; inherited validation rejects it because the earlier justification does not cover the new use.

Two histories can therefore produce the same text, current labels and object scope, yet require different reuse decisions because their inherited authorizations differ. Those retained fields alone cannot distinguish the histories. Enforcing the distinction requires preserving and checking the historical justification. This is the additional state and admission rule specified by our framework.

Fides provides IFC, labeled storage and fine-grained endorsement/declassification mechanisms; SPA preserves labeled artifacts across queries. Our extension makes the applicability of each ancestral relaxation part of every dependent object's current admission decision. Integrating this obligation into an IFC system requires carrying the subject/support-bound witness history and enforcing its transitive checks. The framework supplies that semantics and its implementation across generated persistent state.

3. Compositional consequences and verification under reuse. Under complete governed dependencies and sound certified discharges, Proposition 1 establishes preservation of unresolved source constraints. Proposition 5 establishes the complementary inherited-invalidation property: if a witness fails for (u,t)(u,t), every descendant retaining it fails admission for the same (u,t)(u,t). This covers purpose changes with unchanged evidence, as well as revocation, policy-epoch changes and version drift. Together, these results connect local authorized relaxations to the admissibility of all subsequent derivations in the governed graph.

The reuse analysis addresses a second consequence: an erroneous endorsement can remain mechanically valid and support many later objects. For fixed certificate-use incidence, Proposition 3 bounds certificate-induced loss by E[Hcert]≤∑cpcWc\mathbb E[H_{\mathrm{cert}}]\leq\sum_c p_cW_c, where WcW_c is total downstream loss weight, under the stated error bounds and event-containment premise. It allows dependent certificate errors. Shared justification therefore requires accounting for both issuance error and downstream exposure.

Adaptive reuse adds a further issue: an erroneous artifact can attract additional reuse, coupling exposure to the error itself. Appendix B.5 shows why substituting marginal error times expected exposure can underestimate loss. Proposition 4 addresses this coupling with caps chosen before issuance and conditional error bounds. The resulting rule charges every dependent admission, including descendants across sessions. The implemented four-use cap halves promotion-probe STP from 0.06 to 0.03 with the same verifier.

4. Evidence for this specific mechanism. The matched control retains persistent labels, scope-aware recall, the same verifier and maximum per-task verification budget. Restoring inherited validation reduces STP/CSC from 0.10/0.07 to 0.03/0.02, with utility 0.73 to 0.74 and coverage 0.94 to 0.96. We would appreciate reassessment of this inherited authorization semantics and its formal consequences for persistent reuse.

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

This paper studies the long-term state safety of research agent, particularly on the memory mechanism. Even after one unsafe response is prevented, the intermediate steps can be stored and contaminate the memory, and be treated as trustworthy proof for later interactions. This paper proposed goverance layer which tracks integrity risk, epistemic trust and disclosure sensitivity. The layer will maintain the source of each action and check the corresponding certificates. Besides, this paper proposes DRSC-Bench to evaluate Unsafe Export (UE), Silent Trust Promotion (STP) and Cross-Session Contamination (CSC).

Critical strengths

The investigation on the persistent-state safety is meaningful and shows the real risk that can happen for long-running research agents. The design of the governance layer is reasonable and can be interesting for the community to resolve the potential risks.

Critical weaknesses

The writing is hard to understand for readers which affects the evaluation on the quality of this paper. The Abstract and Introduction use too many abbreviations and detailed numbers yet lack clear explanations on the setting and method. Then many terms like labels, use contracts, certificates are used without proper background and context explanations. Readers need constantly switch between abbreviations, formulas, experiments to understand the content, which is exhausting. The full name of DRSC is still unknown. The method implementation and the experimental setup are unclear which limits the reproduction of this paper. The agent framework, pipeline, tool interface, prompts and memory setups are not clearly stated in the paper. The experiments are limited to the proposed data and no other baselines is included. More details on the agent framework, such as a complete task trace, definitions of tools, the details of the memory mechanism are necessary to help the readers understand better. Also the implementation of the governance layer should also be expanded such as how the verifier distribute the endorsement.

Questions for authors

Pls see the content above. Overall, I agree that the topic and risks studied in this paper are valuable. Yet the current writing quality and the experimental setup show that this version is not ready for acceptance.

1 comment
AuthorsOpenReview ↗

Agent workflow, verification and controlled comparisons

Thank you. The uploaded revision introduces the example before notation (Sec. 3; Figure 1) and explains the agent and tools (Appendix E.2).

1. Problem and measures. DRSC-Bench is the Delayed Recall and State Contamination Benchmark. A research agent discovers sources, persists summaries and recalls them for a later report. A blocked unsafe output can leave contaminated state reusable. Unsafe Export (UE) measures a destination-policy violation; Silent Trust Promotion (STP) measures unsupported eligibility for higher-trust reuse; Cross-Session Contamination (CSC) measures delayed-answer disagreement with the clean counterpart. The CSC audit separates planted-claim adoption from benign variation: adoption falls from 262/1,200 to 11/1,200 (95.8%).

2. One example through the lifecycle. Public filings, a restricted memo and an injected blog illustrate the three axes: integrity risk tracks contamination, evidential trust determines reliance, and sensitivity controls disclosure. A use contract specifies task family, role, destination, capabilities and resource conditions.

Each immutable version stores its identity, parents, three labels, object scope and certificate history. Derivation dependencies record direct inputs; audit dependencies retain supporting evidence; the witness closure W(d)\mathcal W(d) retains certificates justifying earlier label relaxations.

At write, unresolved constraints propagate. Certified integrity sanitization creates a new version; an endorsement separately authorizes a scoped trust transition based on verified support. The runtime signs the exact subject/support and contract bindings. At recall, inherited certificates and object scope are checked before ranking; release enforces destination policy. An endorsement leaves sensitivity unchanged. In Appendix E.2, a liquidity-summary endorsement covers its original contract; later credit-risk reuse fails the inherited contract check even when the descendant's object scope permits it. Revoking that endorsement blocks descendant reuse; fresh derivation from valid public sources restores admissibility.

3. Agent, tools and endorsement. A tool-calling LLM loop is mediated by trusted middleware, a SQLite provenance store and a JSON policy engine. Session 1 ingests sources; session 2 synthesizes and writes state; session 3 recalls state and produces a 500-800-word report. The five tools are:

  • search_documents finds sources; read_document ingests immutable versions with ingress labels.
  • write_memory resolves dependencies, enforces write/promotion rules and commits state.
  • request_endorsement invokes evidence checks; the authorized runtime signs the certificate.
  • recall_memory filters admissible records before relevance/risk ranking and context assembly.

Source classification uses a 12,000-domain registry and an ordinal ingress rule capped at verified (Eq. 33). Endorsement assesses cross-source agreement, citation support and source-signature information. The runtime checks signature, issuer, subject/support bindings, contract, epoch and expiry (Eq. 16). The audit finds 63 semantic errors among 1,840 issued certificates (3.42%), measuring the actual verifier.

Core settings are GPT-4o at temperature zero, top-16 recalled memories within a 32-object active view, risk threshold/weight 0.2/0.5, residual-need threshold 0.2 and freshness limit 30 days. Appendix E.2 gives tool contracts and a worked three-session lifecycle; E.3 defines metric decisions, and E.4 gives ingress and implementation settings.

4. Baselines and controlled evidence. Table 1 includes four core comparators: Naive RAG, CaMeL-style, a Fides adaptation and A-MemGuard. Table 2 adds two persistence-matched configurations: Fides with persistent labels and a PRUDENTIA-style planner with persistent labels. The evaluated Fides adaptation applies action-time labels; its persistence-matched variant serializes them through memory.

Across 240 tasks and five runs, full governance improves utility from 0.72 to 0.74 over Naive RAG (paired task-cluster 95% CI for the gain: [0.005, 0.035]); UE falls from 0.1792 to 0.0125, STP from 0.31 to 0.03 and CSC from 0.24 to 0.02. Tests span three backbones and ten sessions (a fixed 60-task set).

The matched control retains persistent labels, object-level scope-aware recall, endorsement verifier and maximum per-task verification budget, removing inherited validation. Restoring it reduces STP/CSC from 0.10/0.07 to 0.03/0.02, with utility 0.73 to 0.74 and coverage 0.94 to 0.96. For revocation/epoch change/bound-version drift (20 tasks per condition, three runs), full governance blocks 54/54, 51/51 and 56/56 stale recalls, with recovery utility 0.72/0.71/0.73. STP human validation on 100 stratified task-runs gives 94.0% agreement, inter-rater κ=0.86\kappa=0.86 and automated precision/recall 0.91/0.89. We would appreciate reassessment based on this explicit workflow and matched comparison.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.