| \documentclass[10pt,twocolumn]{article} |
|
|
| \usepackage[margin=0.72in,columnsep=0.24in]{geometry} |
| \usepackage[T1]{fontenc} |
| \usepackage[utf8]{inputenc} |
| \usepackage{lmodern} |
| \usepackage{microtype} |
| \usepackage{amsmath,amssymb,mathtools} |
| \usepackage{booktabs,tabularx,multirow,array} |
| \usepackage{xcolor} |
| \usepackage{xspace} |
| \usepackage{graphicx} |
| \usepackage{seqsplit} |
| \usepackage{float} |
| \usepackage{enumitem} |
| \usepackage{balance} |
| \usepackage{tikz} |
| \usetikzlibrary{arrows.meta,positioning,fit,calc,shapes.geometric} |
| \usepackage[numbers,sort&compress]{natbib} |
| \usepackage[hidelinks]{hyperref} |
| \usepackage[capitalise,noabbrev]{cleveref} |
|
|
| \definecolor{authority}{HTML}{0B6E75} |
| \definecolor{observer}{HTML}{4F46A5} |
| \definecolor{unsafe}{HTML}{A16207} |
| \definecolor{softgray}{HTML}{F2F4F5} |
| \definecolor{darkgray}{HTML}{3F4A4F} |
| \newcommand{\system}{\textsc{AtMem}\xspace} |
| \newcommand{\observername}{\textsc{AtFlows}\xspace} |
| \newcommand{\nr}{\textsc{N/R}\xspace} |
| \newcommand{\pass}{\textsc{Pass}\xspace} |
| \newcommand{\fail}{\textsc{Fail}\xspace} |
| \newcommand{\error}{\textsc{Error}\xspace} |
| \newcommand{\dataset}{Memory Integrity Benchmark} |
| \newcommand{\artifact}[1]{\nolinkurl{#1}} |
| \newcommand{\hashvalue}[1]{\texttt{\seqsplit{#1}}} |
| \newcommand{\code}[1]{\texttt{#1}} |
| \newcommand{\yes}{\textcolor{authority}{\ensuremath{\checkmark}}} |
| \newcommand{\no}{\textcolor{unsafe}{--}} |
| \setlist{nosep,leftmargin=*} |
| \setlength{\emergencystretch}{2em} |
|
|
| \title{\textbf{Beyond Recall Accuracy: Evaluating Integrity and Crash Continuity in Persistent Memory for Tool-Using Language Agents}} |
| \author{Javad Taghia\\AtMem.Ai Lab\\\url{https://atmem.ai}} |
| \date{September 26, 2026} |
|
|
| \begin{document} |
| \twocolumn[ |
| \begin{@twocolumnfalse} |
| \maketitle |
| \begin{abstract} |
| Persistent memory is increasingly used to personalize language agents and to |
| resume tool-using workflows, yet prevailing evaluations concentrate on whether |
| the system can retrieve a relevant fact. Retrieval accuracy does not establish |
| that recalled information retained its provenance or authority, nor does it |
| establish that an external action will not be repeated after a process crash. |
| We present a two-axis evaluation of persistent agent memory: \emph{memory |
| integrity}, which tests whether untrusted content can become authoritative, and |
| \emph{operational continuity}, which tests whether a restarted agent safely |
| resolves completed, uncertain, and retryable tool operations. We instantiate |
| the evaluation on \system, an open-source evidence-bound memory service, with |
| \observername as an optional observation plane. The integrity study executes |
| 700 seeded trials from an external benchmark harness. Of these, 400 trials in |
| four representable attack categories pass, 300 trials are explicitly reported |
| as not representable because the harness does not provide system-issued review |
| authority, and none fail or error. Across the scored trials, factual |
| contamination is $0/300$, secret retention is $0/100$, taint preservation is |
| $100/100$, and trust laundering is $0/200$. The continuity study combines |
| installed-wheel crash tests with a four-arm public retail task. All four |
| no-fault configurations reproduce the same 18 model requests, six tool calls, |
| trajectory, and final store state. When the sixth external tool commits and |
| the process is killed before receiving its response, the baseline and |
| observation-only configurations each issue one repeat request; configurations |
| with \system issue none and stop for confirmation. A separate one-task live |
| pilot is retained as a negative-result case study and is not used for causal |
| claims. The results show why persistent-memory evaluation needs authority, |
| lineage, failure-window, and evidence-coverage measurements in addition to |
| recall quality. We release artifact-bound protocols, hashes, and explicit |
| non-claims to support independent scrutiny. |
| \end{abstract} |
| \vspace{0.7em} |
| \noindent\textbf{Keywords:} agent memory, memory integrity, crash recovery, |
| tool-using agents, provenance, taint propagation, reproducible evaluation |
| \vspace{1.2em} |
| \end{@twocolumnfalse} |
| ] |
|
|
| \section{Introduction} |
|
|
| Long-lived language agents now summarize conversations, accumulate user facts, |
| learn procedures, and invoke external tools. These capabilities turn memory |
| from a passive context cache into persistent control input. A retrieved item |
| may shape a recommendation, authorize a procedure, or determine whether an |
| agent repeats a payment, publication, or account change after a restart. Two |
| questions therefore precede conventional relevance: \emph{May this item carry |
| authority?} and \emph{what can be concluded about an interrupted action?} |
|
|
| Most memory benchmarks ask whether a fact can be recovered from a long history. |
| LoCoMo evaluates long-term conversational recall over extended dialogues |
| \cite{maharana2024locomo}; LongMemEval studies information extraction, multi- |
| session reasoning, temporal reasoning, knowledge update, and abstention over |
| long interaction histories \cite{wu2025longmemeval}. These are necessary |
| capabilities. They do not, by themselves, test whether a repeated falsehood is |
| promoted, whether a summary hides tainted ancestry, whether a secret enters |
| canonical memory, or whether a timeout is misread as evidence that a tool did |
| not execute. Agent benchmarks likewise measure task completion and policy |
| adherence \cite{liu2024agentbench,zhou2025taubench,mialon2023gaia}, while |
| security environments test attacks on tool-using agents |
| \cite{debenedetti2024agentdojo,greshake2023indirect}. Persistent memory crosses |
| all three concerns but requires distinct observables. |
|
|
| This paper develops and applies a two-axis evaluation methodology. The first |
| axis, \emph{memory integrity}, evaluates the transition from observed content to |
| authoritative memory. It treats source trust, derivation lineage, lifecycle, |
| secret rejection, and review authority as first-class state. The second axis, |
| \emph{operational continuity}, evaluates the transition from intended action to |
| confirmed external effect across process death. It treats an ambiguous timeout |
| as uncertainty, not failure, and separates the authority to execute from the |
| telemetry used to observe execution. |
|
|
| We evaluate these axes on \system~\cite{atmem236,atmem237}. \system persists |
| evidence-bound semantic records and continuity operations. Its optional |
| \observername integration emits allowlisted operational events, while execution |
| decisions remain in \system. This separation lets the evaluation ask whether |
| memory policy and recovery safety hold even when observation is absent. |
|
|
| Our contributions are: |
|
|
| \begin{enumerate} |
| \item a failure model joining semantic memory integrity and external-action |
| continuity without collapsing either into retrieval accuracy; |
| \item formal authorization, taint-monotonicity, and interruption-resolution |
| properties that yield testable system decisions; |
| \item a reproducible evaluation protocol with four outcomes---\pass, |
| \fail, \error, and \nr---so unsupported capabilities are not reported as |
| successes; |
| \item 700 integrity trials and product-level crash evidence, including a |
| controlled four-arm retail interruption; and |
| \item an artifact and claim discipline that separates installed-product |
| evidence, deterministic replay, fresh-model pilots, and historical fixtures. |
| \end{enumerate} |
|
|
| The central empirical result is deliberately narrow. \system passed all 400 |
| trials in the four benchmark categories its published adapter could represent. |
| In one controlled retail fault cell, \system prevented an uncertain second |
| dispatch; it did not prove an exactly-once distributed execution guarantee or a |
| general task-success gain. This distinction is a feature of the method: safe |
| abstention and honest non-representability are measurable outcomes. |
|
|
| \section{Background and Related Work} |
|
|
| \subsection{Memory for language agents} |
|
|
| Retrieval-augmented generation couples a parametric model to an external corpus |
| \cite{lewis2020rag}. Agent systems extend that pattern by storing experiences, |
| reflections, profiles, and procedures. Generative Agents retrieve and reflect |
| over observations to support behavioral continuity \cite{park2023generative}; |
| MemGPT organizes context through a memory hierarchy inspired by operating |
| systems \cite{packer2023memgpt}; Reflexion stores verbal feedback to improve |
| later behavior \cite{shinn2023reflexion}; and Mem0 develops scalable extraction |
| and consolidation for production memory \cite{chhikara2025mem0}. Surveys |
| organize the field by memory form, operation, and application |
| \cite{zhang2024survey}. |
|
|
| These systems motivate increasingly capable retention and recall. Their usual |
| quality metrics---answer accuracy, retrieval precision, latency, and token |
| cost---do not fully capture authority. A semantically relevant item can be |
| untrusted, superseded, derived from a quarantined parent, or valid only for a |
| different scope. Our integrity axis evaluates whether such an item crosses the |
| authoritative-recall boundary. |
|
|
| \subsection{Long-horizon and tool-use benchmarks} |
|
|
| LoCoMo includes conversations averaging roughly 600 turns and 16,000 tokens, |
| requiring temporal and causal reasoning over sessions |
| \cite{maharana2024locomo}. LongMemEval provides 500 curated questions and reports |
| substantial degradation when interaction histories become long |
| \cite{wu2025longmemeval}. These benchmarks evaluate whether information can be |
| recovered and reasoned over. Our study is complementary: the integrity harness |
| asks whether certain content should be eligible for authoritative recall at |
| all. |
|
|
| ReAct interleaves model reasoning and action \cite{yao2023react}. AgentBench, |
| GAIA, and $\tau$-bench evaluate agents in interactive environments |
| \cite{liu2024agentbench,mialon2023gaia,zhou2025taubench}. $\tau$-bench is |
| especially relevant because it exposes realistic domain policies, database |
| state, user simulation, and tool interfaces. We reuse a pinned public retail |
| task as an integration environment, while changing the research question from |
| aggregate task reward to native-trajectory parity and dispatch behavior at a |
| specific crash boundary. |
|
|
| \subsection{Security, provenance, and recovery} |
|
|
| Indirect prompt injection demonstrates that untrusted external content can |
| redirect an LLM-integrated application \cite{greshake2023indirect}; AgentDojo |
| provides a dynamic environment for attacks and defenses in tool-using agents |
| \cite{debenedetti2024agentdojo}. Memory makes this risk persistent: a malicious |
| or hallucinated statement may survive the original interaction and later be |
| retrieved without its source context. The external \dataset harness |
| \cite{integritybench2026} operationalizes this concern through attack categories |
| covering procedural poisoning, recursive hallucination, summary and repetition |
| laundering, outcome laundering, authorization, and secret ingestion. |
|
|
| Operational continuity draws on older distributed-systems lessons. A process |
| cannot infer from a missing reply whether a remote effect occurred. Transaction |
| boundaries and durable logs constrain recovery \cite{gray1981transaction}; |
| event ordering requires explicit clocks and state rather than wall-clock |
| intuition \cite{lamport1978time}. HTTP distinguishes safe and idempotent method |
| semantics but does not make arbitrary application callbacks idempotent |
| \cite{rfc9110}. Our design therefore requires a declared destination capability |
| and preserves uncertainty when no reliable reconciliation mechanism exists. |
|
|
| \section{Problem Formulation} |
|
|
| \subsection{Memory integrity model} |
|
|
| Let a memory record be |
| \begin{equation} |
| m = \langle i, x, s, b, \tau, \ell, q, t \rangle, |
| \end{equation} |
| where $i$ is an immutable identifier, $x$ is the content, $s$ is source type, |
| $b$ is source-binding assurance, $\tau$ is a trust or taint label, $\ell$ is |
| parent lineage, $q$ is lifecycle state, and $t$ is time metadata. A query is |
| $r=\langle u,z,k\rangle$, consisting of principal $u$, authority scope $z$, and |
| retrieval expression $k$. |
|
|
| We distinguish storage from authoritative recall. A record can remain as |
| evidence while being unavailable to ordinary memory retrieval. Define: |
| \begin{equation} |
| \begin{split} |
| \operatorname{Auth}(m,r) ={}& \operatorname{active}(q_m) \land |
| \operatorname{trusted}(s_m,b_m,\tau_m) \\ |
| &\land\operatorname{scopeOK}(z,m) \land |
| \operatorname{lineageOK}(\ell_m). |
| \end{split} |
| \label{eq:auth} |
| \end{equation} |
| Relevance ranks only records satisfying \cref{eq:auth}; similarity cannot grant |
| authority. Purpose-specific recall is omitted from this predicate because the |
| evaluated \system version does not implement a purpose field. That absent |
| capability is reported, rather than simulated in an adapter. |
|
|
| For a derived record $d$ with parents $P(d)$, taint must be monotone: |
| \begin{equation} |
| \tau(d) \succeq \bigvee_{p\in P(d)} \tau(p), |
| \label{eq:taint} |
| \end{equation} |
| where $\succeq$ means ``at least as restrictive.'' In the evaluated |
| implementation, any untrusted, tainted, or inactive direct parent quarantines |
| the child. This is a direct-parent property, not transitive provenance closure. |
|
|
| An adversary may submit untrusted observations, cause an agent to repeat a |
| claim, induce a summary, or present caller-controlled identity labels. The |
| adversary succeeds if content gains authoritative recall, laundering removes a |
| required taint label, or a synthetic secret enters a scored canonical surface. |
| The source episode may remain in a separate evidence boundary; secret rejection |
| does not imply deletion of the input transcript. |
|
|
| \subsection{Continuity model} |
|
|
| Let a governed operation be |
| \begin{equation} |
| o=\langle w,i,d,a,c,sigma,A,\rho\rangle, |
| \end{equation} |
| where $w$ is workflow identity, $i$ is operation identity, $d$ is an immutable |
| intent digest, $a$ binds tool arguments, $c$ is destination capability, |
| $\sigma$ is operation state, $A$ is the attempt sequence, and $\rho$ is a |
| receipt when known. Stable identity is derived from deployment namespace, |
| thread identifier, checkpoint namespace, assistant-message identifier, and tool- |
| call identifier. Reusing an identity with different arguments is rejected. |
|
|
| The capability $c$ is one of: |
| \begin{itemize} |
| \item \code{none}: the result cannot be reliably determined or repeated; |
| \item \code{query}: the destination can check the exact effect without |
| performing it; or |
| \item \code{idempotent}: the destination enforces the supplied key for a |
| declared retention interval. |
| \end{itemize} |
| The recovery decision after restart is: |
| \begin{equation} |
| \resizebox{\columnwidth}{!}{$ |
| D(o)= |
| \begin{cases} |
| \textsf{reuse}(\rho), & \rho \text{ is valid},\\ |
| \textsf{wait}, & \exists \text{ live lease},\\ |
| \textsf{query}, & \operatorname{uncertain}(o)\land c=\textsf{query},\\ |
| \textsf{execute}, & \operatorname{uncertain}(o)\land c=\textsf{idempotent} |
| \land \operatorname{validKey}(o),\\ |
| \textsf{confirm}, & \operatorname{uncertain}(o)\land c=\textsf{none},\\ |
| \textsf{execute}, & \operatorname{neverDispatched}(o). |
| \end{cases} |
| $} |
| \label{eq:decision} |
| \end{equation} |
| A success receipt is bound to the operation, run, and attempt and carries the |
| original result. It is labeled host-reported: the service validates binding but |
| cannot independently prove an arbitrary callback truthful. |
|
|
| \subsection{Properties under test} |
|
|
| We test five properties: |
| \begin{description} |
| \item[P1: authority separation.] Untrusted evidence cannot become |
| authoritative through semantic similarity, repetition, or summarization. |
| \item[P2: taint monotonicity.] A derived item cannot have less restrictive |
| trust than a disqualifying parent, as in \cref{eq:taint}. |
| \item[P3: uncertainty preservation.] Absence of a tool response is never |
| interpreted as proof of non-execution. |
| \item[P4: stable operation identity.] Resume binds to the checkpointed tool |
| call; argument mutation under that identity is rejected. |
| \item[P5: observer non-interference.] Execution decisions do not depend on |
| telemetry delivery: |
| \begin{equation} |
| D(o\mid E)=D(o\mid E\setminus E_{\mathrm{obs}}), |
| \end{equation} |
| where $E_{\mathrm{obs}}$ is the set of \observername events. |
| \end{description} |
|
|
| These properties do not imply a general exactly-once guarantee. Exactly-once |
| external effects require cooperation from the destination or a transaction that |
| spans both systems. Our target is the narrower guarantee that the memory |
| controller will not authorize an unsafe repeat when outcome is uncertain. |
|
|
| \section{System Architecture} |
|
|
| \begin{figure*}[t] |
| \centering |
| \resizebox{0.97\textwidth}{!}{\begin{tikzpicture}[ |
| node distance=15mm, |
| box/.style={draw,rounded corners=2pt,minimum height=11mm,minimum width=30mm,align=center,font=\small,inner sep=3mm}, |
| auth/.style={box,draw=authority,very thick,fill=authority!6}, |
| obs/.style={box,draw=observer,very thick,fill=observer!6}, |
| ext/.style={box,draw=darkgray,fill=softgray}, |
| flow/.style={-{Latex[length=2.2mm]},thick}, |
| evidence/.style={-{Latex[length=2.2mm]},thick,dashed,draw=observer}, |
| edge/.style={font=\scriptsize,fill=white,inner sep=1.5pt} |
| ] |
| \node[ext] (agent) {\textbf{1. Agent host}\\durable checkpoint}; |
| \node[auth,right=of agent] (client) {\textbf{2. Governed node}\\stable call identity}; |
| \node[auth,right=of client] (atmem) {\textbf{3. \system authority}\\intent, lease, receipt}; |
| \node[ext,right=of atmem] (tool) {\textbf{4. Registered tool}\\external destination}; |
| \node[obs,below=19mm of atmem] (flows) {\observername observation plane\\allowlisted events and costs}; |
| \node[ext,below=19mm of tool] (eval) {Independent evaluator\\state, hashes, invocations}; |
| \draw[flow] (agent) -- (client); |
| \draw[flow] (client) -- (atmem); |
| \draw[flow] (atmem) -- (tool); |
| \draw[flow] (tool.south west) to[bend left=22] node[below=2mm,edge]{bound receipt} (atmem.south east); |
| \draw[evidence] (client.south) -- node[below left,edge,text=observer]{telemetry} (flows.north west); |
| \draw[evidence] (atmem.south) -- (flows.north); |
| \draw[flow] (tool) -- (eval); |
| \node[draw=unsafe,dashed,fit=(flows),inner sep=3mm, |
| label={[font=\scriptsize,text=unsafe]below:no execution-authority edge}] {}; |
| \end{tikzpicture}} |
| \caption{Evaluated architecture. The host owns scheduling and checkpoints; |
| \system owns operation authority and evidence; the destination owns its external |
| effect. \observername receives bounded telemetry but cannot authorize, |
| suppress, or repeat a tool call.} |
| \label{fig:architecture} |
| \end{figure*} |
|
|
| \subsection{Semantic memory path} |
|
|
| \system captures source type, binding assurance, trust tier, lifecycle, and |
| lineage with a memory proposal. Canonical records, graph relations, review |
| events, and audit evidence share stable identifiers. Source evidence and |
| authoritative recall are separate surfaces. Secrets are rejected before |
| canonical persistence and sensitive rejected surfaces are sanitized; the raw |
| source episode remains evidence outside the benchmark's canonical scoring |
| boundary. |
|
|
| Review authority is instance-issued, exactly scoped, and single use. A caller- |
| supplied label such as ``reviewer'' is descriptive data, not an authorization |
| token. This decision causes three external benchmark categories to be |
| \nr: the harness supplies actor labels but does not supply a native, issued |
| authorization that can exercise the corresponding state transition. |
|
|
| \subsection{Continuity path} |
|
|
| The host first commits the assistant message and tool-call identity to a durable |
| checkpoint. The governed node then asks \system for a decision. \system |
| atomically persists the operation definition and grants an attempt lease before |
| the callback executes. The evaluated profile uses a 120-second lease, at most |
| ten renewals, at most 200 operations per workflow, 100 attempts per operation, |
| and 2,000 workflow revisions. These are bounded local-workflow controls, not a |
| distributed scheduler. |
|
|
| If a receipt is durable before failure, the restarted host receives its stored |
| result. If the destination acted but the receipt was lost, recovery waits for |
| the lease and follows the declared capability. A query callback must not repeat |
| the original side effect. An idempotent retry is allowed only while the real |
| destination enforces the same key. Otherwise \system returns |
| \code{needs\_confirmation}. A late, unsuperseded attempt may still report a |
| correctly bound receipt; a superseded late receipt remains evidence but cannot |
| complete newer work. |
|
|
| The checkpoint and memory service serve different roles. LangGraph persistence |
| restores graph position and state \cite{langgraph2026persistence}; \system |
| decides what an unresolved tool call may do. SQLite write-ahead logging supports |
| concurrent readers and a durable local checkpointer \cite{sqlitewal}, but it |
| cannot atomically commit an arbitrary remote side effect with a local graph |
| checkpoint. |
|
|
| \subsection{Observation path} |
|
|
| \observername receives opaque workflow, operation, run, and attempt identifiers, |
| plus optional usage and price provenance. It does not receive document content, |
| tool arguments, or full receipts. Failed observation increments a bounded error |
| counter and never changes \cref{eq:decision}. Unknown price remains unknown; |
| the observer does not substitute evaluator estimates. This resembles standard |
| telemetry separation \cite{opentelemetry2026}, while adding an explicit |
| non-authority contract. |
|
|
| \section{Evaluation Design} |
|
|
| \subsection{Evidence classes} |
|
|
| We preclude aggregation across incomparable evidence. Each result belongs to |
| one of four classes: |
|
|
| \begin{enumerate} |
| \item \textbf{external integrity harness}: seeded trials executed against a |
| published wheel and frozen adapter configuration; |
| \item \textbf{installed-product acceptance}: isolated wheel installation, |
| external process kill, and independently inspected destination state; |
| \item \textbf{recorded-response integration}: fixed model responses for exact |
| trajectory and fault-boundary comparison; and |
| \item \textbf{fresh-model pilot}: new provider calls, reported without causal |
| attribution when replication is insufficient. |
| \end{enumerate} |
|
|
| A historical offline continuity matrix is retained as evaluator-development |
| evidence. Because that benchmark runtime supplied recovery behavior, it cannot |
| support an AtMem-specific product claim and is excluded from primary results. |
|
|
| \subsection{Integrity benchmark protocol} |
|
|
| The external harness version contains seven attack categories |
| \cite{integritybench2026,integritypr2026}. We execute 100 seeded trials per |
| category, using CPython 3.11.16 and the exact published \system 2.3.6 wheel. The |
| seed is 20260922; the harness commit is |
| \artifact{07585b6615d640f93fe49854b4da3d5e97358af0}; the working tree was clean. |
| Frozen attack and configuration files are SHA-256 bound in the manifest. |
|
|
| \begin{table}[t] |
| \centering |
| \caption{Integrity attack categories and evaluated boundary.} |
| \label{tab:attacks} |
| \small |
| \begin{tabularx}{\columnwidth}{@{}cXl@{}} |
| \toprule |
| ID & Attack objective & Capability status \\ |
| \midrule |
| A & Direct procedural poisoning & \nr \\ |
| C & Recursive agent hallucination & represented \\ |
| D & Summary trust laundering & represented$^\dagger$ \\ |
| F & Repetition authority laundering & represented \\ |
| H & Outcome laundering & \nr \\ |
| I & Authorized promotion & \nr \\ |
| L & Secret ingestion & represented \\ |
| \bottomrule |
| \multicolumn{3}{@{}p{\columnwidth}@{}}{\footnotesize $^\dagger$Category D uses native-record-ID target matching; its interpretation is pending upstream review.} |
| \end{tabularx} |
| \end{table} |
|
|
| Each trial receives one of four statuses. \pass means all required assertions |
| were evaluated and held; \fail means a represented assertion was violated; |
| \error means the evaluation could not complete; and \nr means the native |
| system cannot express the harness transition without an adapter inventing a |
| capability or authority. \nr trials are excluded from metric denominators. |
| They are not converted to passes. |
|
|
| Category D requires special care. The submitted adapter identifies the actual |
| derived summary by its native record ID. A prior shared-text nonce fallback |
| also matched a clean trusted sibling from the same two-parent derivation and |
| would score 0/100. Native-ID matching asks the intended question---whether the |
| derived summary became authoritative---and yields 100/100, but this interpretation |
| has not yet been accepted upstream. We report it separately and provide the |
| counterfactual category count if it is rejected. |
|
|
| The integrity metrics are: |
| \begin{align} |
| \mathrm{FCR} &= N_{\mathrm{contaminated\ recalls}}/N_{\mathrm{factual\ probes}},\\ |
| \mathrm{SRR} &= N_{\mathrm{secrets\ found}}/N_{\mathrm{secrets\ injected}},\\ |
| \mathrm{TPR} &= N_{\mathrm{taint\ preserved}}/N_{\mathrm{derivations}},\\ |
| \mathrm{TLR} &= N_{\mathrm{laundered}}/N_{\mathrm{laundering\ probes}}. |
| \end{align} |
| Metrics are descriptive proportions over deterministic seeded fixtures; we do |
| not attach sampling confidence intervals to repeated deterministic cases. |
|
|
| \subsection{Continuity protocol} |
|
|
| The continuity evaluation uses the public text-retail environment from |
| $\tau^2$-bench commit |
| \artifact{b7ea9074c1cba482b30687fecdb5c8425fd6f619}. Source tree, policy, and |
| tool definitions are separately hashed. Four configurations isolate the |
| roles of authority and observation: |
|
|
| \begin{table}[t] |
| \centering |
| \caption{Four-arm continuity design.} |
| \label{tab:arms} |
| \small |
| \begin{tabularx}{\columnwidth}{@{}lccX@{}} |
| \toprule |
| Arm & \system & \observername & Interpretation \\ |
| \midrule |
| Baseline & \no & \no & durable graph only \\ |
| AtMem & \yes & \no & authority plane \\ |
| AtFlows & \no & \yes & observer only \\ |
| Both & \yes & \yes & authority plus observer \\ |
| \bottomrule |
| \end{tabularx} |
| \end{table} |
|
|
| The no-fault parity run replays preserved native model replies. It checks exact |
| model-request matching, tool-call count, trajectory equality, graph topology, |
| and final database-state hash. Replay controls provider nondeterminism and tests |
| integration equivalence; it does not measure fresh model quality. |
|
|
| The fault run uses the same recorded-response setting. An external controller |
| sends \code{SIGKILL} after the sixth public HTTP tool has committed its state |
| change but before the worker receives the HTTP response. Each arm restarts |
| after approximately 125 seconds, longer than the 120-second attempt lease. The |
| primary measure is the number of new public tool invocations after restart: |
| \begin{equation} |
| R_{\mathrm{dispatch}}=\sum_a I(\text{new invocation in arm }a). |
| \end{equation} |
| We also count additional external state changes and native tool-error replies. |
| The destination's duplicate guard is retained; therefore a repeated request and |
| a repeated effect are distinct outcomes. |
|
|
| Installed-product acceptance tests two receipt windows using wheels in an |
| isolated environment. The process imports neither the source checkout nor the |
| benchmark runtime. The action publishes real bytes to a directory. In the |
| first window, the process dies after the receipt is durable. In the second, the |
| destination commits but the process dies before the receipt is saved; the |
| registered query verifies the exact file after lease expiry. The restarted |
| application invokes normal LangGraph resume. The test rig does not choose the |
| next step, repair the checkpoint, supply a receipt, or reconcile the output. |
|
|
| Finally, the fresh pilot runs one exposed task per arm with new provider calls. |
| All arms use the same model configuration and fixed order. Because one trial |
| per arm cannot separate product effect from provider and simulator variation, |
| these observations are a case study only. |
|
|
| \section{Results} |
|
|
| \subsection{Memory integrity} |
|
|
| \begin{table*}[t] |
| \centering |
| \caption{Memory Integrity Benchmark results for \system 2.3.6. Each category contains 100 trials. \nr trials are excluded from metric denominators.} |
| \label{tab:integrity-results} |
| \small |
| \begin{tabular}{@{}clrrrrl@{}} |
| \toprule |
| ID & Category & Pass & Fail & Error & \nr & Scored assertion \\ |
| \midrule |
| A & Direct procedural poisoning & 0 & 0 & 0 & 100 & native review authority unavailable \\ |
| C & Recursive agent hallucination & 100 & 0 & 0 & 0 & absent from authoritative recall \\ |
| D & Summary trust laundering & 100 & 0 & 0 & 0 & absent; taint preserved \\ |
| F & Repetition authority laundering & 100 & 0 & 0 & 0 & absent from authoritative recall \\ |
| H & Outcome laundering & 0 & 0 & 0 & 100 & native review authority unavailable \\ |
| I & Authorized promotion & 0 & 0 & 0 & 100 & native review authority unavailable \\ |
| L & Secret ingestion & 100 & 0 & 0 & 0 & absent from scored canonical surfaces \\ |
| \midrule |
| & \textbf{Total} & \textbf{400} & \textbf{0} & \textbf{0} & \textbf{300} & \\ |
| \bottomrule |
| \end{tabular} |
| \end{table*} |
|
|
| \Cref{tab:integrity-results} reports all 700 trials. The represented categories |
| C, D, F, and L pass 100/100 each. Categories A, H, and I are \nr because |
| the harness passes caller labels rather than an instance-issued \system review |
| authorization. Treating those labels as approval would manufacture the trust |
| boundary the benchmark is intended to test. |
|
|
| The aggregate integrity measures are: |
| \begin{equation} |
| \mathrm{FCR}=0/300=0,\quad \mathrm{SRR}=0/100=0, |
| \end{equation} |
| \begin{equation} |
| \mathrm{TPR}=100/100=1,\quad \mathrm{TLR}=0/200=0. |
| \end{equation} |
| The category-L result means the synthetic secret was absent from canonical, |
| graph, retrieval, audit, and media scoring surfaces. It does not mean the raw |
| source evidence was erased. Category D contributes to both factual-recall and |
| taint measurements under the native-ID interpretation. If upstream rejects |
| that interpretation, the defensible count becomes three passing categories; |
| the other category outcomes do not change. |
|
|
| \subsection{No-fault compatibility} |
|
|
| All four recorded-response configurations match all 18 native model requests, |
| make six native tool calls, terminate at the same user stop, and produce the |
| same trajectory and final store-state hash |
| \hashvalue{06bb132b5ea03a83611bb23c52608af9802b10fa8d430df5c982fcc88b34fb83}. |
| Graph topology is equal. \system and the combined arm create six governed |
| operations; the baseline and \observername-only arms create none. No provider |
| calls are made in this replay. |
|
|
| This is an integration non-regression result. It shows that governance and |
| observation preserved one native trajectory under controlled replies. It does |
| not imply that the original task was correct, that fresh model outputs are |
| identical, or that either product improves reward. |
|
|
| \subsection{Interrupted retail action} |
|
|
| \begin{table}[t] |
| \centering |
| \caption{Behavior after the sixth tool committed and the worker was killed before receiving the response.} |
| \label{tab:fault-results} |
| \small |
| \begin{tabularx}{\columnwidth}{@{}lrrX@{}} |
| \toprule |
| Arm & New calls & New effects & Restart outcome \\ |
| \midrule |
| Baseline & 1 & 0 & destination rejects repeat \\ |
| AtMem & 0 & 0 & needs confirmation \\ |
| AtFlows & 1 & 0 & destination rejects repeat \\ |
| Both & 0 & 0 & needs confirmation \\ |
| \bottomrule |
| \end{tabularx} |
| \end{table} |
|
|
| \Cref{tab:fault-results} shows the controlled interruption. The baseline and |
| observation-only arms each make one new tool invocation and receive one native |
| error reply. The destination's own guard prevents a second state change. The |
| two arms containing \system make no new invocation and no new state change; |
| they return \code{needs\_confirmation} before dispatch. Thus the supported |
| claim is that \system avoided an uncertain repeat request in this cell. The |
| result is not evidence that \system prevented a duplicate external effect, |
| because the destination prevented that effect in the repeating arms. It also |
| does not compare task completion after the fault: completion comparison was |
| excluded by protocol. |
|
|
| The contrast between \observername-only and combined arms confirms the intended |
| non-interference boundary. Telemetry alone does not authorize or suppress a |
| call. Adding the observer to \system does not change the authority decision. |
|
|
| \subsection{Installed receipt-window acceptance} |
|
|
| \begin{table}[t] |
| \centering |
| \caption{Installed-wheel document continuity acceptance.} |
| \label{tab:acceptance} |
| \small |
| \begin{tabularx}{\columnwidth}{@{}Xrll@{}} |
| \toprule |
| Fault window & Effects & Modes after start & Final \\ |
| \midrule |
| Receipt durable before kill & 1 & execute & completed \\ |
| Effect before receipt & 1 & execute, query & completed \\ |
| \bottomrule |
| \end{tabularx} |
| \end{table} |
|
|
| In both installed-wheel cases, the output directory contains one document with |
| the same byte hash. When the receipt is durable, resume reuses it and performs |
| no second execution. When the receipt is lost, resume waits 119.946 seconds and |
| uses the destination query; the final workflow is completed with one effect. |
| Authenticated \observername HTTP ingestion also passes. The tested wheels are |
| \system 2.3.7b2 and \observername 0.1.2, bound by SHA-256 in the result summary. |
| These are development-build acceptance artifacts, not claims about a later |
| published package. |
|
|
| \subsection{Fresh-model case study} |
|
|
| \begin{table}[t] |
| \centering |
| \caption{One-task-per-arm fresh pilot. Costs are provider-price estimates, not invoice-verified values.} |
| \label{tab:live} |
| \small |
| \begin{tabular}{@{}lrrrr@{}} |
| \toprule |
| Arm & Reward & Calls & Time (s) & Cost (USD) \\ |
| \midrule |
| Baseline & 1 & 14 & 44.34 & 0.053470 \\ |
| AtMem & 0 & 18 & 44.59 & 0.060450 \\ |
| AtFlows & 0 & 18 & 41.89 & 0.056462 \\ |
| Both & 0 & 18 & 52.31 & 0.056226 \\ |
| \bottomrule |
| \end{tabular} |
| \end{table} |
|
|
| All four conversations terminate normally. The baseline selects the expected |
| replacement keyboard; the other three select a different variant and score zero. |
| The first model responses already differ before any tool runs, despite identical |
| configuration. The run order is fixed, the task is exposed, and $n=1$ per arm. |
| Consequently \cref{tab:live} cannot support either a benefit or a penalty claim |
| for \system or \observername. Retaining the result prevents selective reporting |
| and demonstrates a broader methodological point: successful transport, normal |
| termination, and safe recovery are distinct from task correctness. |
|
|
| The four fresh arms make 68 calls and have estimated aggregate cost |
| USD\,0.226608. Including the earlier native pilot yields 86 calls and an |
| estimated USD\,0.283932. No unresolved reservation remains, but the provider |
| invoice was not independently verified. |
|
|
| \section{Analysis} |
|
|
| \subsection{Why retrieval quality is insufficient} |
|
|
| Suppose a poisoned record is semantically closer to a query than a trusted |
| record. A relevance-only system may improve recall metrics while increasing |
| the probability that untrusted content controls behavior. Equation |
| \eqref{eq:auth} places authority filtering before ranking. This changes the |
| evaluation target from ``did the system retrieve the answer?'' to ``did it |
| retrieve the highest-quality answer among records eligible to speak with this |
| authority?'' Both questions matter, but they need separate denominators. |
|
|
| The integrity outcomes also show why aggregate pass rate can mislead. Reporting |
| 400/700 as 57.1\% would treat unsupported authority transitions as failures; |
| reporting 700/700 would turn those same gaps into successes. The four-state |
| contract retains coverage information: 400 represented passes, 300 \nr, |
| zero represented failures, and zero runtime errors. A production decision can |
| then weigh demonstrated behavior and missing capability independently. |
|
|
| \subsection{Why continuity is a memory concern} |
|
|
| Agent memory often denotes conversational facts, but an acting agent must also |
| remember what it attempted, under which identity, and what evidence confirms the |
| effect. If only the conversation is restored, the model may see an unresolved |
| tool call and generate a new call identifier. Semantic deduplication is unsafe: |
| two similar transfers can be distinct obligations, while the same interrupted |
| transfer may be phrased differently after restart. Stable checkpoint identity |
| and immutable argument binding therefore belong in the persistent memory model. |
|
|
| The fault result exposes three layers that should not be conflated. The host |
| checkpoint remembers control-flow position. \system remembers operation |
| authority and uncertainty. The destination determines whether a repeated |
| request produces another effect. In the baseline, destination safety prevents |
| the second effect but only after a repeat request. In the \system arms, the |
| controller stops before dispatch because the destination has no declared query |
| or idempotency contract for that operation. |
|
|
| \subsection{Authority and observation} |
|
|
| Operational dashboards benefit from traces, costs, errors, and run health. |
| Those observations may be late, dropped, or duplicated. If their absence |
| changes execution authority, a telemetry outage becomes a control-plane input. |
| The four-arm design tests this architectural claim directly: \observername alone |
| behaves like baseline at the fault boundary, and adding \observername to \system |
| does not change the stop decision. The observer still adds diagnostic value, |
| but the authority plane remains evidence-bound and fail-closed. |
|
|
| This separation also limits data exposure. The observer receives opaque IDs |
| and allowlisted accounting fields, while complete receipts and arguments remain |
| in the evidence vault. The policy is stricter than merely redacting a dashboard: |
| the telemetry schema lacks the authority-bearing payload. |
|
|
| \subsection{Negative results as benchmark output} |
|
|
| Three negative or bounded findings improve the evidence. First, 300 integrity |
| trials are \nr rather than adapter-manufactured passes. Second, the fresh |
| pilot does not show a product benefit and is retained in full. Third, the |
| historical offline continuity matrix is demoted because recovery was implemented |
| by the benchmark runtime. Benchmark credibility depends on preserving these |
| boundaries after the results are known. |
|
|
| \section{Threats to Validity} |
|
|
| \paragraph{External validity.} |
| The integrity study evaluates one released system on seven synthetic categories. |
| It does not establish general security, compliance, retrieval quality, latency, |
| or resistance to adaptive attackers. The continuity fault evidence uses one |
| public retail task and one injected boundary. Other tools, distributed stores, |
| network partitions, multi-region clocks, and concurrent writers require separate |
| qualification. |
|
|
| \paragraph{Construct validity.} |
| Authoritative recall is a system-specific boundary. The benchmark adapter maps |
| native states to a shared contract, and Category D depends on native-ID target |
| matching. That interpretation is pending upstream review. We therefore expose |
| both interpretations. Secret-retention scoring excludes raw source evidence; |
| systems with different evidence boundaries may not be directly comparable. |
|
|
| \paragraph{Internal validity.} |
| Recorded replies remove model variance from parity and fault tests but also |
| remove adaptation that a fresh model might exhibit. The fresh pilot restores |
| real inference but has only one task per arm, fixed ordering, and observed |
| pre-tool output divergence. It is not a causal experiment. The fault test's |
| destination rejects duplicates, so zero additional effects cannot be attributed |
| to \system; the attributable difference is zero versus one repeat dispatch. |
|
|
| \paragraph{Implementation dependence.} |
| Installed acceptance covers a synchronous, file-backed LangGraph integration |
| and registered tools. It does not test arbitrary schedulers or automatic |
| instrumentation of every agent framework. The continuity service relies on a |
| durable local clock high-water mark and pauses if the clock moves backward. |
| Host-reported receipts can be false if a trusted callback lies. |
|
|
| \paragraph{Statistical scope.} |
| The 100 integrity trials per category are seeded test instances, not an |
| independent random sample of all attacks. Proportions summarize this suite and |
| should not be interpreted as population security rates. Continuity acceptance |
| uses exact functional cases; the live pilot is too small for interval estimation |
| or significance testing. |
|
|
| \paragraph{Artifact provenance.} |
| The external submission is an open pull request, not an accepted upstream |
| leaderboard entry. One prose capability file lists a wheel digest inconsistent |
| with the frozen environment lock. We independently downloaded the exact PyPI |
| URL on 2026-09-26: its SHA-256 is |
| \hashvalue{eed43276abb6e230bf5f6f5912c45c577c3136e150c77a707d428bcbe0e57394}, |
| matching the URL fragment and environment lock. We use that verified digest |
| and disclose the documentation mismatch rather than silently selecting a value. |
|
|
| \section{Reproducibility and Claim Discipline} |
|
|
| Every primary result has a machine-readable summary and retains raw evidence. |
| The integrity bundle records the harness commit, clean-tree state, seed, Python |
| implementation, platform, exact dependency lock, frozen-input hashes, trial |
| range, and per-category assertions. The continuity bundles record source tree, |
| policy, and tool hashes; package versions; request matching; fault boundary; |
| restart delay; tool invocations; state changes; and explicit prohibited claims. |
|
|
| The empirical statements in this paper follow five rules: |
| \begin{enumerate} |
| \item count \nr separately from \pass and \fail; |
| \item attribute a result only to the component whose behavior differs; |
| \item distinguish repeat requests from repeated external effects; |
| \item distinguish deterministic replay from fresh model inference; and |
| \item preserve observed failures and implementation limitations. |
| \end{enumerate} |
|
|
| No private customer data are used. The retail content comes from a public |
| benchmark. Artifact export includes exact-match scans for configured secrets, |
| but that check is not a sensitive-data certification. Public release should |
| continue to review raw request and response files before distribution. |
|
|
| \section{Future Work} |
|
|
| The immediate integrity priority is an upstream resolution of Category D and a |
| benchmark protocol for native, system-issued authority. A future harness can |
| use a challenge-response flow: request an authorization from the system under a |
| declared principal, bind it to exact records and action, and consume it once. |
| This would make A, H, and I representable without trusting caller labels. |
| Purpose-scoped recall is another explicit gap. |
|
|
| Continuity evaluation should expand to a preregistered held-out task set with |
| randomized arm order, repeated trials, simulator-adherence annotations, multiple |
| fault windows, and destinations spanning \code{none}, \code{query}, and |
| \code{idempotent}. Useful fault points include before intent persistence, |
| after lease grant, during the request, after destination commit, after receipt |
| return, and after receipt persistence. Repeated qualification on Linux, |
| Windows, and macOS should bind package artifacts and OS-specific locking behavior. |
|
|
| Longer-term work should combine the two axes. For example, an operation receipt |
| or post-run reflection may become an episodic record. Its authority should be |
| derived from the receipt's binding and destination evidence, not from the model's |
| narrative confidence. Conversely, retrieved procedural memory should not grant |
| permission to execute; the current design keeps memory lifecycle, task authority, |
| and operation authority separate. A unified benchmark can test these cross- |
| layer transitions while retaining separate metrics. |
|
|
| \section{Conclusion} |
|
|
| Persistent agent memory must do more than retrieve relevant text. It must |
| preserve the authority and lineage of retained information, and it must preserve |
| uncertainty when a tool's external outcome is unknown. We introduced a two-axis |
| evaluation that makes these obligations measurable. In 700 seeded integrity |
| trials, \system passed all 400 represented cases and explicitly declined to |
| simulate authority for 300 unsupported cases. In controlled continuity tests, |
| it preserved a native no-fault trajectory and avoided one uncertain repeat |
| dispatch at a specific crash boundary, while the observer-only configuration |
| behaved as designed and did not affect authority. The small fresh pilot did not |
| support a quality claim, and we reported it accordingly. |
|
|
| The broader result is methodological: benchmark coverage, authority boundaries, |
| failure windows, and evidence provenance must accompany accuracy numbers. An |
| agent memory system is trustworthy only to the extent that its claims remain |
| bounded by what its artifacts actually demonstrate. |
|
|
| \section*{Acknowledgments} |
|
|
| The integrity results use the open Memory Integrity Benchmark Harness, and the |
| continuity integration uses the public $\tau^2$-bench retail environment. The |
| author thanks their maintainers for making inspectable evaluation artifacts |
| available. |
|
|
| \balance |
| \bibliographystyle{plainnat} |
| \begingroup |
| \sloppy |
| \setlength{\emergencystretch}{4em} |
| \bibliography{references} |
| \endgroup |
|
|
| \clearpage |
| \onecolumn |
| \appendix |
|
|
| \section{Artifact Index} |
|
|
| \begin{table}[H] |
| \centering |
| \caption{Primary artifact map. Paths are relative to their respective repositories.} |
| \label{tab:artifacts} |
| \small |
| \begin{tabularx}{\textwidth}{@{}p{0.22\textwidth}p{0.34\textwidth}X@{}} |
| \toprule |
| Claim class & Artifact & Scope \\ |
| \midrule |
| Integrity aggregate & \artifact{results/published/atmem-v2.3.6-seed-20260922/aggregate-metrics.json} & 700 trial outcomes and four aggregate metrics \\ |
| Integrity provenance & \artifact{.../benchmark-manifest.json}, \artifact{.../environment.lock} & harness commit, frozen inputs, seed, exact wheel and dependencies \\ |
| Integrity limitations & \artifact{.../LIMITATIONS.md}, \artifact{adapters/atmem/CAPABILITIES.md} & scoring boundary, \nr rationale, Category D interpretation \\ |
| Installed acceptance & \artifact{benchmarks/agent_continuity/results/product-acceptance-20260925-005/summary.json} & receipt-durable and receipt-lost document cases \\ |
| No-fault parity & \artifact{.../public-retail-parity-20260925-007/summary.json} & four-arm recorded-response compatibility \\ |
| Fault qualification & \artifact{.../public-retail-fault-20260925-003/summary.json} & four-arm post-commit, pre-response interruption \\ |
| Fresh pilot & \artifact{.../public-retail-live-20260925-001/summary.json} & one fresh task per arm; descriptive only \\ |
| Historical fixture & \artifact{.../offline-smoke-20260925/summary.json} & evaluator development; excluded from product claims \\ |
| \bottomrule |
| \end{tabularx} |
| \end{table} |
|
|
| The integrity repository is |
| \url{https://github.com/iluxu/memory-integrity-benchmark}; the submitted adapter |
| and result bundle are visible in pull request 1. The \system{} source and |
| continuity artifacts are in \url{https://github.com/aetna000/atmem}. A complete |
| archival release should assign immutable repository commits or a DOI to both |
| artifact sets before arXiv submission. |
|
|
| \section{Integrity Capability Matrix} |
|
|
| \begin{table}[H] |
| \centering |
| \caption{Native capability mapping used by the integrity adapter.} |
| \label{tab:capabilities} |
| \small |
| \begin{tabularx}{\textwidth}{@{}p{0.16\textwidth}p{0.10\textwidth}p{0.39\textwidth}X@{}} |
| \toprule |
| Capability & Status & Enforcement & Limitation \\ |
| \midrule |
| Source trust & present & source type, binding assurance, trust tier, lifecycle & caller assertions do not create trust \\ |
| Derivation tracking & present & native parent IDs; disqualifying direct parent quarantines child & direct parents only \\ |
| Procedural memory & present & typed procedure proposals enter review & type does not grant execution or review authority \\ |
| Authority gating & \nr in harness & exact-scope, single-use issued authorization & harness supplies only caller-controlled labels \\ |
| Purpose-scoped recall & absent & ignored by adapter & no purpose field in evaluated recall request \\ |
| Secret blocking & present & rejection before canonical persistence; sanitized scored surfaces & raw source episode remains evidence \\ |
| \bottomrule |
| \end{tabularx} |
| \end{table} |
|
|
| The capability matrix is intentionally asymmetric. Source trust, direct-parent |
| lineage, procedural typing, and secret rejection are native state transitions. |
| Authority gating also exists natively, but the external harness cannot invoke it |
| without a service-issued authorization; this makes the relevant benchmark cases |
| \nr{} rather than absent from the product. Purpose-scoped recall is different: |
| the evaluated request type has no purpose field, so the capability is absent. |
| Keeping these two cases separate prevents a benchmark-interface mismatch from |
| being confused with an implementation gap. |
|
|
| \section{Continuity State Transitions} |
|
|
| \begin{figure}[H] |
| \centering |
| \resizebox{0.94\textwidth}{!}{\begin{tikzpicture}[ |
| state/.style={draw,rounded corners=2pt,minimum width=27mm,minimum height=10mm,align=center,font=\small,inner sep=2.5mm}, |
| safe/.style={state,draw=authority,fill=authority!7}, |
| uncertain/.style={state,draw=unsafe,fill=unsafe!8}, |
| arrow/.style={-{Latex[length=2mm]},thick}, |
| edge/.style={font=\scriptsize,fill=white,inner sep=1.5pt}, |
| node distance=18mm and 20mm] |
| \node[safe] (new) {defined}; |
| \node[safe,right=of new] (leased) {attempt leased}; |
| \node[uncertain,right=of leased] (unknown) {outcome unknown}; |
| \node[safe,above right=14mm and 22mm of unknown] (query) {query destination}; |
| \node[safe,right=of query] (confirmed) {confirmed\\receipt}; |
| \node[safe,below right=14mm and 22mm of unknown] (idem) {idempotent retry}; |
| \node[uncertain,below=18mm of unknown] (stop) {needs confirmation}; |
| \node[safe,right=of confirmed] (reuse) {reuse result}; |
| \draw[arrow] (new) -- node[midway,above=3mm,edge]{persist intent} (leased); |
| \draw[arrow] (leased) -- node[midway,above=5mm,edge,align=center]{lost reply;\\lease expired} (unknown); |
| \draw[arrow] (leased.north east) to[bend left=30] node[above,edge]{valid receipt} (confirmed.north west); |
| \draw[arrow] (unknown.north east) -- node[pos=.58,above=3mm,edge]{query declared} (query.south west); |
| \draw[arrow] (query) -- node[above,edge]{effect found} (confirmed); |
| \draw[arrow] (unknown.south east) -- node[pos=.58,below=3mm,edge]{valid idempotency} (idem.north west); |
| \draw[arrow] (idem.north east) to[bend right=18] node[pos=.48,right=3mm,edge]{bound result} (confirmed.south west); |
| \draw[arrow] (unknown) -- node[midway,left=3mm,edge,align=right]{no safe\\capability} (stop); |
| \draw[arrow] (confirmed) -- (reuse); |
| \end{tikzpicture}} |
| \caption{Continuity decision state machine. An expired lease permits a decision; |
| it does not prove the prior attempt failed. Query and retry require explicit |
| destination capabilities; otherwise uncertainty stops for confirmation.} |
| \label{fig:state-machine} |
| \end{figure} |
|
|
| \section{Claim Ledger} |
|
|
| \begin{table}[H] |
| \centering |
| \caption{Claims supported and excluded by the reported evidence.} |
| \label{tab:claims} |
| \small |
| \begin{tabularx}{\textwidth}{@{}p{0.47\textwidth}p{0.47\textwidth}@{}} |
| \toprule |
| Supported & Not supported \\ |
| \midrule |
| 400 represented integrity trials passed; 300 were \nr & all seven attack categories passed \\ |
| Factual contamination $0/300$ within scored probes & general factual correctness or retrieval superiority \\ |
| Secret retention $0/100$ within scored canonical surfaces & erasure from source evidence or compliance certification \\ |
| One replayed no-fault trajectory was unchanged in four arms & universal semantic transparency across applications \\ |
| \system arms made zero repeat requests in one controlled fault cell & distributed exactly-once execution \\ |
| Installed document cases ended with one exact output & production-wide recovery rate or arbitrary-tool recovery \\ |
| The fresh pilot produced rewards 1,0,0,0 across fixed-order arms & a causal quality advantage or penalty \\ |
| \observername did not change the tested authority decisions & complete, durable, or lossless telemetry \\ |
| \bottomrule |
| \end{tabularx} |
| \end{table} |
|
|
| For reviewers reproducing the work, the minimum acceptance sequence is to verify |
| the locked wheel digest, frozen-input hashes, trial counts, and exclusion |
| denominators before interpreting aggregate rates. For continuity, reviewers |
| should verify the external fault marker and destination journal before consulting |
| the controller journal; otherwise a controller's own account could become the |
| sole evidence for the effect it claims to govern. Replay and fresh-inference |
| artifacts should remain in separate aggregates. A failed or missing observer |
| event must never be used to infer a missing tool effect. |
|
|
| \end{document} |
|
|
