\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}