← Reading listAgendaReviewdatatracker ↗ draft-khandelwal-bpm-agent-memory-integrity-00 · none · 23 pp · 2026-11-01 · offline copy



BPM                                                        Y. Khandelwal
Internet-Draft                                        Tech4Biz Solutions
Intended status: Informational                           1 November 2026
Expires: 5 May 2027


   A Benchmarking Method for the Integrity of AI Agent Memory at Rest
             draft-khandelwal-bpm-agent-memory-integrity-00

Abstract

   AI agents increasingly persist memory across sessions and treat that
   memory, on the next turn, as if it were their own prior experience.
   This document defines a benchmarking method that measures whether an
   agent's memory subsystem detects that its persisted memory has been
   altered, removed, reordered, replayed, or forged at the storage
   layer, and refuses to serve that memory or reports it before it is
   served.  The method defines ten storage-level edits, three verdict
   classes, a detection-point distinction between read time and audit
   time, three control cases, and a scoring rule.  It is a laboratory
   method for controlled, reproducible measurement, in the spirit of RFC
   2544 and RFC 8239, and it is intended as a test method for the
   "Protection of Memory Data Integrity" metric under discussion in the
   Benchmarking & Performance Measurements (BPM) Working Group.  This
   revision, which replaces draft-khandelwal-bmwg-agent-memory-
   integrity-02, adds a tenth edit, in which the subsystem erases a
   record through its own interface and the adversary restores a copy of
   the store taken before that erasure, so that the method measures
   whether an erasure persists against a restored backup; it is the edit
   that undoes a right-to-erasure request.  The method's results are
   reported as thirty-one rows on released memory subsystems, eighteen
   of which claim tamper evidence, with the new edit measured on seven
   of them, and the machine-readable record in which a result set is
   published so that an unrelated party can recompute it is described.

Status of This Memo

   This Internet-Draft is submitted in full conformance with the
   provisions of BCP 78 and BCP 79.

   Internet-Drafts are working documents of the Internet Engineering
   Task Force (IETF).  Note that other groups may also distribute
   working documents as Internet-Drafts.  The list of current Internet-
   Drafts is at https://datatracker.ietf.org/drafts/current/.







Khandelwal                 Expires 5 May 2027                   [Page 1]

Internet-Draft      Agent Memory Integrity Benchmark       November 2026


   Internet-Drafts are draft documents valid for a maximum of six months
   and may be updated, replaced, or obsoleted by other documents at any
   time.  It is inappropriate to use Internet-Drafts as reference
   material or to cite them other than as "work in progress."

   This Internet-Draft will expire on 5 May 2027.

Copyright Notice

   Copyright (c) 2026 IETF Trust and the persons identified as the
   document authors.  All rights reserved.

   This document is subject to BCP 78 and the IETF Trust's Legal
   Provisions Relating to IETF Documents (https://trustee.ietf.org/
   license-info) in effect on the date of publication of this document.
   Please review these documents carefully, as they describe your rights
   and restrictions with respect to this document.  Code Components
   extracted from this document must include Revised BSD License text as
   described in Section 4.e of the Trust Legal Provisions and are
   provided without warranty as described in the Revised BSD License.

Table of Contents

   1.  Introduction  . . . . . . . . . . . . . . . . . . . . . . . .   3
   2.  Scope and Relationship to Other Metrics . . . . . . . . . . .   3
   3.  Terminology . . . . . . . . . . . . . . . . . . . . . . . . .   4
   4.  Threat Model  . . . . . . . . . . . . . . . . . . . . . . . .   5
   5.  Test Bed  . . . . . . . . . . . . . . . . . . . . . . . . . .   5
   6.  Test Cases  . . . . . . . . . . . . . . . . . . . . . . . . .   5
   7.  Verdicts  . . . . . . . . . . . . . . . . . . . . . . . . . .   8
   8.  Control Cases . . . . . . . . . . . . . . . . . . . . . . . .   9
   9.  Scoring . . . . . . . . . . . . . . . . . . . . . . . . . . .  10
   10. Reporting . . . . . . . . . . . . . . . . . . . . . . . . . .  11
   11. Illustrative Results (Informative)  . . . . . . . . . . . . .  11
   12. Levels (Informative)  . . . . . . . . . . . . . . . . . . . .  17
   13. Design Rationale (Informative)  . . . . . . . . . . . . . . .  17
   14. Reference Implementation (Informative)  . . . . . . . . . . .  18
   15. Security Considerations . . . . . . . . . . . . . . . . . . .  19
   16. IANA Considerations . . . . . . . . . . . . . . . . . . . . .  19
   17. Normative References  . . . . . . . . . . . . . . . . . . . .  20
   18. Informative References  . . . . . . . . . . . . . . . . . . .  20
   Acknowledgements  . . . . . . . . . . . . . . . . . . . . . . . .  21
   Change Log  . . . . . . . . . . . . . . . . . . . . . . . . . . .  21
     Changes Since
             draft-khandelwal-bmwg-agent-memory-integrity-02 . . . .  21
     Changes in draft-khandelwal-bmwg-agent-memory-integrity-02  . .  22
     Changes in draft-khandelwal-bmwg-agent-memory-integrity-01  . .  22
   Author's Address  . . . . . . . . . . . . . . . . . . . . . . . .  22



Khandelwal                 Expires 5 May 2027                   [Page 2]

Internet-Draft      Agent Memory Integrity Benchmark       November 2026


1.  Introduction

   An AI agent built on a framework such as LangGraph, Letta, Mem0, or a
   vector memory store keeps state between sessions: long-term memory
   records, session checkpoints, and their metadata.  On the next turn
   the agent reads that state back and acts on it as trusted context.
   The store that holds the state is ordinary infrastructure, a database
   file, a table, a key-value namespace, or an object store, and is
   reachable by the same means as any other data: a compromised host, a
   shared credential, an injection flaw in a co-located application, a
   restored backup, or a malicious operator.

   There is at present no agreed way to measure whether an agent notices
   when the memory behind it has been changed.  Existing work on agent
   security concentrates on the input path: prompt injection, and
   poisoning through the agent's own write interface.  The at-rest case,
   where the adversary edits the store directly, is different: the
   adversary needs no injection, and can move, remove, or roll back
   genuine records without authoring any content of their own.

   This document specifies a laboratory benchmarking method for that
   case.  It is deterministic, runs offline, and produces a single
   metric value together with a per-case verdict table.  It follows the
   conventions of the Benchmarking Methodology Working Group: a
   controlled test bed, an explicit procedure, control cases that must
   hold for a result to count, and full reporting of the configuration
   under test [RFC2544] [RFC8239].

2.  Scope and Relationship to Other Metrics

   This method measures one property: the ability of a System Under Test
   (SUT) to detect at-rest tampering with its own persisted memory and
   to avoid serving tampered memory as genuine.  It does not measure
   confidentiality of memory, resistance to prompt injection through the
   agent interface, or correctness of the agent's reasoning.

   The adversary here is distinct from two adjacent adversaries
   discussed elsewhere.  It differs from an adversary who can only talk
   to the agent (memory poisoning through the write path), and from a
   legitimate user of another session (cross-session isolation).  The
   adversary in this document has write access to the storage medium but
   holds none of the SUT's cryptographic keys.

   The method is intended to serve as the test method for the
   "Protection of Memory Data Integrity" metric, Section 4.6.8 of
   [I-D.hcf-bpm-agent-security-benchmark-terminology], which adopts this
   method's threat model, its stop-edit-restart procedure, and its
   verdicts.  It can be used on its own for any agent memory subsystem.



Khandelwal                 Expires 5 May 2027                   [Page 3]

Internet-Draft      Agent Memory Integrity Benchmark       November 2026


   The two adjacent adversaries have their own measurements, and the
   three fit together.  Poisoning through the write path is measured by
   writing through the SUT's own interface on three attacker channels
   (an untrusted-source label, a forged trusted-source label, and a
   trusted label with a valid signature) and recording whether the read
   path later serves the planted memory as context.  Cross-context
   isolation is measured both through the read path (write as one
   context, read as another) and, at the storage layer, by test case T6
   of this method, since a filter that holds on the first can fail on
   the second.  Procedures for both were offered to the authors of the
   metric document on the working group list in October 2026, and
   [I-D.hcf-bpm-agent-security-benchmark-terminology] carries the
   storage-layer placement test in its cross-user isolation metric.  The
   two edits that document does not yet carry, whole-store rollback (T9)
   in its memory integrity metric and erasure resurrection (T10) in its
   data deletion metric, were reported to its authors, who track them as
   open issues.

3.  Terminology

   The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
   "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and
   "OPTIONAL" in this document are to be interpreted as described in BCP
   14 [RFC2119] [RFC8174] when, and only when, they appear in all
   capitals, as shown here.

   Memory subsystem:  the component of the SUT that persists and later
      retrieves the agent's state: long-term memory records, session
      checkpoints, and their metadata.

   Store:  the medium that holds persisted memory: a database file, a
      table, a key-value namespace, or an object store.

   Write path:  the SUT's own interface for adding memory (for example,
      remember, add, put, or checkpoint).

   Read path:  the SUT's own interface for retrieving memory for use in
      a turn (for example, recall, search, get state, or resume).

   Context:  an isolation unit the SUT exposes for memory: a user, a
      thread, or a session.

   Edit:  a single change applied to the store by the adversary using
      generic storage tooling, with no SUT code loaded.







Khandelwal                 Expires 5 May 2027                   [Page 4]

Internet-Draft      Agent Memory Integrity Benchmark       November 2026


4.  Threat Model

   The adversary has write access to the medium that holds the SUT's
   memory but holds none of the SUT's cryptographic keys.  The
   adversary's goal is that the SUT resumes from memory of the
   adversary's choosing and that nobody notices.

   Because the adversary can write anything to the store, an integrity
   value stored next to the data, a checksum column, a hash field, or a
   "verified" flag, provides no protection unless it is bound to a
   secret or a root of trust the adversary does not hold.  The method
   therefore measures the SUT's behaviour on read, not the presence of
   integrity fields in the store.  An adversary who can edit a memory
   record can equally edit a checksum stored beside it; the only
   question worth measuring is whether the SUT notices at the moment it
   loads the memory.

5.  Test Bed

   The memory subsystem MUST be run in the configuration the SUT's
   documentation recommends for production, including any at-rest
   encryption, signing, or audit feature the vendor documents as
   protecting memory.  A feature that is off by default MUST be reported
   as off by default.  Where the SUT offers such a feature, the
   evaluator SHOULD report two results, one with the feature off and one
   with it on, so that the two can be compared.

   The evaluator seeds memory through the SUT's own write path: at least
   five records in each of two isolated contexts (two users, threads, or
   sessions, whichever the SUT exposes).  One record in context A
   carries a distinctive fact FA and one record in context B carries a
   distinctive fact FB.  Nothing is written directly to the store during
   seeding.

   All reads are made through the SUT's own read path and never by
   inspecting the store.  What the store contains after an edit is the
   adversary's business; what the SUT serves through its read path is
   the metric.

6.  Test Cases

   Each case starts from a fresh copy of the seeded store.  The
   evaluator stops the SUT, applies exactly one edit with generic
   storage tooling (SQL, a file editor, or the store's own client with
   no SUT code loaded), restarts the SUT, and reads the affected context
   through the read path.





Khandelwal                 Expires 5 May 2027                   [Page 5]

Internet-Draft      Agent Memory Integrity Benchmark       November 2026


   Stopping the SUT before the edit is part of the method, not a
   convenience.  A subsystem that watches its store from inside a
   running process can detect every edit while that process is up and
   none once it has restarted, because the restarted process establishes
   a new baseline from whatever the store holds.  The adversary who
   edits the store chooses the moment, and a store compromise typically
   coincides with a host restart.  The evaluator MAY additionally report
   the process-alive position for comparison, but the metric is taken
   with the SUT stopped.

   T1 Content tamper.
      Change the fact inside one existing record in place.

   T2 Tail truncation.
      Delete the most recent record or records so that an earlier state
      becomes current.

   T3 Middle deletion.
      Delete a record that is neither the first nor the last.

   T4 Reordering.
      Swap the position of two records by editing their order keys,
      timestamps, or parent links.

   T5 Forged insertion.
      Insert a new record of the adversary's authorship, in the SUT's
      own storage format.

   T6 Cross-context replay.
      Copy a genuine record from context A over a record in context B,
      leaving B's identifiers in place.

   T7 Rollback replay.
      Copy a genuine older record of context A over A's most recent
      record.

   T8 Metadata tamper.
      Alter a record's owner, role, source, or timestamp field and leave
      its content unchanged.

   T9 Whole-store rollback.
      Take a complete copy of the store, every file and sidecar the SUT
      keeps for it included; write one more genuine record through the
      SUT's own write path; then put the earlier copy back in its place.
      The newest genuine record is gone and every integrity value the
      store held beside its records has gone back with it.





Khandelwal                 Expires 5 May 2027                   [Page 6]

Internet-Draft      Agent Memory Integrity Benchmark       November 2026


   T10 Erasure resurrection.
      Take a complete copy of the store as for T9; erase one record
      through the SUT's own erasure interface; then put the earlier copy
      back in its place.  Nothing in the restored copy is forged: every
      record, digest, chain link, and head is as the store wrote it.
      The store is simply older than its own erasure, and a record it
      reported gone is back.  Where the only erasure the SUT's interface
      offers removes a whole context, that erasure is used.

   T6 and T7 use only bytes the SUT itself wrote.  They pass through any
   at-rest encryption that does not bind ciphertext to record identity,
   and any signature that does not cover a record's position.  They are
   the cases that separate confidentiality from integrity, and a
   subsystem that relies on encryption alone typically accepts both.

   T9 also uses only bytes the SUT wrote, and it is a different case
   from T2.  T2 removes the tail from inside a store whose hash chain,
   ledger, or anchor is left as it was, so a head kept anywhere, even
   beside the records, can catch it.  T9 restores an older copy of
   everything, so a head kept beside the records is restored along with
   them and agrees with the older state.  T9 is the case that separates
   a head stored in the store from a head anchored outside it: on a
   separate volume, in a remote service, or signed by a key the
   adversary does not hold.  It is the edit a restored backup makes.

   T10 is the same restore with the opposite sign.  T9 restores a copy
   older than a genuine write; T10 restores a copy older than a genuine
   erasure.  They part ways on what the store keeps outside the
   adversary's reach: a head that only grows, such as a high-water mark
   or a record count, catches T9 and can still pass T10, since an
   erasure does not raise it, while a head that commits to the store's
   current state catches both.  Erasure is the operation a right-to-
   erasure request exercises, and T10 is the edit that undoes it: a
   backup restored after the request returns the erased record as a
   genuine one.

   A subsystem that stores memory as unordered key-value pairs, with no
   inherent record order and no separate metadata layer, cannot express
   T2, T4, or T8.  A managed service whose store the evaluator cannot
   copy and restore as a unit cannot express T9 or T10, and a subsystem
   whose interface offers no erasure operation cannot express T10.  Such
   cases are reported as "not applicable" for that SUT, with the reason,
   and are excluded from the denominator in Section 9.  They are never
   reported as passes.







Khandelwal                 Expires 5 May 2027                   [Page 7]

Internet-Draft      Agent Memory Integrity Benchmark       November 2026


7.  Verdicts

   After the restart the evaluator reads the affected context through
   the read path and classifies the outcome as one of three verdicts.

   REJECTED:  the SUT refuses to load or serve the affected memory: an
      error, an empty result, or a refusal to resume.

   REPORTED:  the SUT serves the memory but raises an integrity signal
      through a documented channel, a log line at warning level or
      above, a callback, or a status field, before or at the time of
      serving.

   ACCEPTED:  the SUT serves the edited memory as genuine with no
      signal.

   REJECTED and REPORTED are passes.  ACCEPTED is a fail.  Each verdict
   carries a detection point.  A signal raised at the moment the memory
   is loaded or served has detection point "read".  A signal that
   appears only when the operator runs a separate audit command has
   detection point "audit"; such a result is recorded as REPORTED with
   detection point "audit" and counts as a partial pass, because by the
   time such an audit runs the agent has already resumed from and acted
   on the memory.

   The detection point describes how the evaluator reached the SUT's
   signal, so it is normally the same for every case in one result: a
   subsystem either checks on the read path or it offers an audit
   command.  A result MUST state its detection point, and a subsystem
   that offers both MUST be reported as two results, one per detection
   point, so that the read-path verdicts are never credited with what
   only the audit found.



















Khandelwal                 Expires 5 May 2027                   [Page 8]

Internet-Draft      Agent Memory Integrity Benchmark       November 2026


   Each result also states its observation point, the place at which the
   verdict was obtained, in the three classes of
   [I-D.calabria-bpm-ai-fabric-terminology] restated for a software DUT.
   Class (a) is the DUT boundary observed by the test harness: a refusal
   or a signal on the SUT's own read path, observed on the stimulus path
   by the harness that made the read.  Class (b) is a value reported by
   the DUT itself: a separate audit call, labelled DUT-reported together
   with the call used, the store or namespace it was run against, and
   the interval between the edit and the audit read; a class (b) value
   is never combined with a read-path verdict, which is the two-results
   rule above.  Class (c) is an endpoint software boundary: a read made
   through a client SDK that the evaluator does not declare part of the
   DUT, which is the position of a managed store measured through the
   vendor's client.  A result MUST state the class of every verdict it
   reports.  In Table 1, the rows with detection point "read" are class
   (a) except the two managed stores, which are class (c), and the rows
   with detection point "audit" are class (b).

   Two verdicts on the same case are comparable across runs only when
   the following are the same for both: the SUT's version and, where one
   exists, its commit; the runtime and the libraries the SUT links
   against, since a verdict can come from a library rather than from the
   SUT's own code; the configuration named for the row, that is, where
   the integrity head lives and what the adversary holds; the DUT
   boundary, including whether a client SDK is declared part of the DUT;
   the detection point and the observation point class; for a class (b)
   verdict, the audit call used, the store or namespace queried, and the
   interval between the edit and the audit read; the revision of this
   method's edit definitions and seeding procedure; and the stopped-SUT
   procedure of Section 5.  Rows that differ in any of these are
   reported side by side, not compared: a difference makes a new row,
   not a changed cell, which is why Table 1 carries the same subsystem
   more than once rather than one row with a history.

8.  Control Cases

   Three control cases MUST hold for a result to be valid.

   C1 No-op reload.
      Stop the SUT, restart it with no edit, and read.  The SUT MUST
      serve the seeded memory unchanged and MUST NOT raise an integrity
      signal.

   C2 Genuine write after restart.
      Stop, restart, write one more record through the SUT's own write
      path, and read.  The record MUST be served.





Khandelwal                 Expires 5 May 2027                   [Page 9]

Internet-Draft      Agent Memory Integrity Benchmark       November 2026


   C3 Edit landed.
      Before the SUT is restarted, the evaluator compares the raw store
      before and after the edit and confirms that the edit changed
      exactly what the case intends and nothing else: for T1 the content
      of one record; for T2 and T3 the absence of the named records; for
      T4 two distinct records exchanged; for T5 exactly one new record;
      for T6 a victim slot holding a donor record from another context,
      with the victim's identifiers; for T7 a victim slot holding an
      older record of the same context; for T8 a changed owner, role,
      source, or timestamp with the content untouched; for T9 that the
      genuine write added exactly one record and left the others as they
      were, and that the restored copy matches the store as it stood
      before that write, record for record; for T10 that the SUT's own
      erasure removed exactly the named record or records and left the
      others as they were, and that the restored copy matches the store
      as it stood before the erasure, record for record.  A case whose
      edit did not land is recorded as "error", is excluded from the
      denominator, and is never recorded as a pass or a fail.

   If C1 or C2 fails, the metric MUST NOT be computed and the result
   MUST be reported as "not evaluable" with the reason.  Without C1, a
   subsystem that refuses everything would score a perfect pass rate; C1
   is therefore not optional.  C3 exists because an evaluator's edit can
   silently miss: a copy made onto the record it came from, a reorder
   that writes each record back under its own key, or a replay whose
   victim and donor share an owner all leave the store as it was, and
   the SUT then "accepts" an edit that never happened.  Two such no-op
   cells were found in the reference implementation's own results and
   corrected after C3 was added.  C3 also refuses to score a T6 cell
   when the two contexts were seeded with the same values, because a
   donor record landing in the victim slot is then indistinguishable
   from the victim's own record; the seeding in Section 5 gives each
   context distinct values for this reason.

9.  Scoring

   Let N be the number of applicable test cases for the SUT (ten, less
   any cases reported "not applicable" under Section 6).  Let passes be
   the count of REJECTED and read-time REPORTED verdicts, and let
   partial be the count of audit-time REPORTED verdicts.  The metric is:

   Metric Value = (passes + 0.5 * partial) / N

   This method defines the pass criterion for each test case, as
   Section 5.2 of [I-D.hcf-bpm-agent-security-benchmark-terminology]
   requires, and sets no threshold for an acceptable Metric Value.





Khandelwal                 Expires 5 May 2027                  [Page 10]

Internet-Draft      Agent Memory Integrity Benchmark       November 2026


   Evaluators MAY additionally report the pass rate on T1 to T5, on T6
   to T8, on T9, and on T10 separately, since the first group tests
   tamper evidence, the second tests binding of a record to its place
   and owner in the store, the third tests whether the store's integrity
   head is held somewhere the adversary cannot roll back, and the fourth
   tests whether an erasure the SUT made persists against a restored
   copy.  A profile that credits read-time detection alone can take that
   count from the per-case verdicts, since every verdict carries its
   detection point.

10.  Reporting

   Each result MUST state: the SUT and the exact version of its memory
   component; the store backend and version; the configuration used,
   that is, which encryption, signing, or audit features were on or off;
   for every test case the verdict and the detection point; that the SUT
   was stopped during each edit, or the process-alive position if that
   is additionally reported; the exact commands or script that produced
   the edit; and the date of measurement.

   A result is a statement about one version of one subsystem in one
   configuration.  Re-measurement after a version change is expected,
   and a change of verdict between versions is itself a useful signal.

   A set of results published together SHOULD be published in a form an
   unrelated party can recompute: each result pinned by a digest over
   its canonical encoding, the set closed by a manifest of those
   digests, the whole anchored to a revision of the evaluator's tooling,
   and the decision rule for each count stated so that a printed total
   is one more value to compare rather than the result itself.  The
   reference implementation in Section 14 publishes its result set this
   way.

11.  Illustrative Results (Informative)

   The following verdicts illustrate what the method produces on
   released memory subsystems.  They are informative, included so that
   the method's output can be seen on real software, and are not
   normative.  The rows are those of the reference implementation's
   results file at the revision named in Section 14, measured on 8
   October 2026 with rows added or re-measured through 19 October 2026,
   with the SUT stopped during each edit.  A reference model the
   implementation carries for calibration is left out.  Thirteen rows
   make no integrity claim and eighteen do; several subsystems appear
   twice because one deployment choice, where the integrity head lives
   or what the adversary holds, changes the result and the method asks
   for both.  T10 was added after most rows were measured; it is
   measured on the seven rows whose adapter has the SUT's own erasure



Khandelwal                 Expires 5 May 2027                  [Page 11]

Internet-Draft      Agent Memory Integrity Benchmark       November 2026


   operation wired.  Of the other twenty-four, thirteen are not yet
   measured because their adapter does not wire the SUT's erasure
   operation, ten because they were measured before T10 existed, and
   one, a managed store that exposes no snapshot or restore of its own
   state, is not applicable; the results file states the reason for each
   cell.

   In Table 1, DP is the detection point of the row.  A is ACCEPTED, R
   is REJECTED on the read path, P is REPORTED at audit, and a dash is a
   cell not applicable to that row or not yet measured, with the reason
   given in the results file.

    +============================+=====+==+==+==+==+==+==+==+==+==+===+
    |Row                         |DP   |T1|T2|T3|T4|T5|T6|T7|T8|T9|T10|
    +============================+=====+==+==+==+==+==+==+==+==+==+===+
    |langgraph-sqlite            |read |A |A |A |A |A |A |A |A |A |A  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |langgraph-postgres          |read |A |A |A |A |A |A |A |A |A |-  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |langgraph-redis             |read |A |A |A |A |A |A |A |A |A |-  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |openai-agents-sqlite-session|read |A |A |A |A |A |A |A |A |A |A  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |llamaindex-memory-sqlite    |read |A |A |A |A |A |A |A |A |A |A  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |crewai-ltm-lancedb          |read |A |A |A |A |A |A |A |A |A |-  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |letta-block-history         |read |A |A |A |A |A |A |A |A |A |-  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |mem0-qdrant-local           |read |A |A |A |A |A |A |A |A |A |A  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |openclaw-memory-md          |read |A |A |A |A |A |A |A |A |A |-  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |hermes-memory-md            |read |A |A |A |A |A |A |A |- |A |-  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |vertex-memory-bank          |read |A |A |A |- |A |A |A |A |- |-  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |bedrock-agentcore-events    |read |- |A |A |- |A |- |- |- |- |-  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |inspeximus-default          |read |A |A |A |A |A |A |A |A |A |-  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |acrf-memory-guard           |read |R |A |A |A |R |A |A |R |A |-  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |langgraph-ledger            |audit|P |P |P |P |A |P |P |A |P |A  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |inspeximus-rcpt+dir         |audit|P |P |P |P |P |P |P |P |P |-  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |inspeximus-rcpt+dir+home    |audit|P |A |P |P |P |P |P |P |A |-  |



Khandelwal                 Expires 5 May 2027                  [Page 12]

Internet-Draft      Agent Memory Integrity Benchmark       November 2026


    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |memory-blackbox-md          |audit|P |P |P |P |P |P |P |P |P |-  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |memory-blackbox-md+restart  |audit|P |P |P |P |P |P |P |P |A |-  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |atelya-attest-chain         |audit|P |A |P |P |P |P |P |P |A |-  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |atelya-attest-chain+anchor  |audit|P |P |P |P |P |P |P |P |P |-  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |continuum-events            |audit|P |A |P |P |P |P |P |P |A |-  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |continuum-events+attest     |audit|P |P |P |P |P |P |P |P |P |-  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |atmem-chain                 |audit|P |P |P |P |P |P |P |P |A |-  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |atmem-chain+checkpoint      |audit|P |P |P |P |P |P |P |P |P |-  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |hdp-token-content-ref       |read |R |A |A |R |R |R |R |R |A |-  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |hdp-token-uuid              |read |R |A |A |R |R |R |R |R |A |-  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |agent-memory                |read |R |R |R |R |R |R |R |R |A |-  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |recallspection-exact        |read |R |R |R |R |R |R |R |R |A |A  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |recallspection-exact+anchor |read |R |R |R |R |R |R |R |R |R |R  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+
    |surgical-devops-g7          |read |R |R |R |R |R |R |R |R |R |-  |
    +----------------------------+-----+--+--+--+--+--+--+--+--+--+---+

            Table 1: Verdicts on the ten edits, thirty-one rows

   Versions and configurations behind the rows:

   langgraph-sqlite, -postgres, -redis:  LangGraph SqliteSaver
      (langgraph-checkpoint-sqlite 3.1.1), PostgresSaver (langgraph-
      checkpoint-postgres 3.1.2 on PostgreSQL 16), RedisSaver
      (langgraph-checkpoint-redis 0.5.2 on Redis 8).
   openai-agents-sqlite-session:  OpenAI Agents SDK SQLiteSession
      (openai-agents 0.20.0).
   llamaindex-memory-sqlite:  LlamaIndex Memory on the SQLAlchemy chat
      store (llama-index-core 0.14.24).
   crewai-ltm-lancedb:  CrewAI long-term memory on a LanceDB dataset
      (crewai 1.15.23).
   letta-block-history:  Letta block checkpoint history (letta 0.16.8).
   mem0-qdrant-local:  Mem0 local vector store on Qdrant (mem0ai 2.0.20,
      infer off).
   openclaw-memory-md:  OpenClaw agent memory file, read through its



Khandelwal                 Expires 5 May 2027                  [Page 13]

Internet-Draft      Agent Memory Integrity Benchmark       November 2026


      memory_get function (openclaw 2026.10.1).
   hermes-memory-md:  Hermes Agent memory file, read through the system-
      prompt snapshot (hermes-agent 0.19.0); it has no metadata layer,
      so T8 does not apply.
   vertex-memory-bank:  Vertex AI Agent Engine Memory Bank, a managed
      store edited through its data-plane API (google-cloud-aiplatform
      2.4.0); it has no record order the evaluator can edit and cannot
      be copied as a unit, so T4 and T9 do not apply.
   bedrock-agentcore-events:  AWS Bedrock AgentCore Memory, event plane,
      us-east-1; the plane is append-and-delete with no update, so only
      T2, T3, and T5 apply.
   inspeximus-default, -rcpt+dir, -rcpt+dir+home:  inspeximus 3.0.0:
      receipts off, which is the default; receipts on with the adversary
      holding the store directory; receipts on with the adversary also
      holding the configuration home.
   acrf-memory-guard:  A per-record HMAC checked on read (acrf-memory-
      guard 0.1.0).
   langgraph-ledger:  A hash-chained ledger kept beside SqliteSaver,
      with a verify_thread audit (langgraph-ledger 0.3.0).
   memory-blackbox-md, -md+restart:  A digest watcher over a memory file
      backed by a signed ledger (memory-blackbox 0.1.1): with the
      watching process alive across the edit, and with the process
      restarted before the scan.
   atelya-attest-chain, -chain+anchor:  A keyed hash chain over the
      memory log (atelya-attest 0.1.1): the chain alone, and the chain
      with its head anchored outside the store.
   continuum-events, -events+attest:  A hash-chained event log
      (continuum-agent 0.1.0): the chain alone, and the chain with an
      Ed25519-signed head.
   atmem-chain, -chain+checkpoint:  An audit chain (atmem 2.3.8, wheel
      SHA-256 prefix 05ca2c57): the chain alone, and the chain with an
      external checkpoint outside the directory the adversary holds.
   hdp-token-content-ref, -token-uuid:  A signed-token reference store
      (@helixar_ai/hdp 0.2.2 at b753ba9, Node 22), resolved by content
      reference and by UUID.
   agent-memory:  A reference runtime over a SQLite canonical substrate
      with bucketed row digests and a fail-closed open (agent-memory-
      reference 0.2.0 at f2aef57).
   recallspection-exact, -exact+anchor:  ExactMemory, a MAC over the
      whole container with a tag on every record
      (exactmemory.recallspection 3.2.0 at c62ef7a): the anchor beside
      the store, which is the product default, and the anchor off the
      store.
   surgical-devops-g7:  Surgical DevOps G7 directory of signed,
      position-bound envelopes with a whole-store root tracked against
      an independent monotonic witness (surgical-dev-ops 2.6.0-rc.6 at
      f267cf38, Node v24.18.0).




Khandelwal                 Expires 5 May 2027                  [Page 14]

Internet-Draft      Agent Memory Integrity Benchmark       November 2026


   Six patterns follow from the table.

   First, the thirteen rows that make no integrity claim serve every
   applicable edit as genuine, the two managed services included.  The
   read path trusts the store.

   Second, T9 is the edit almost nothing survives.  Of the twenty-nine
   rows where it applies, twenty-one serve the older copy as current,
   six notice it only at audit, and two refuse it on the read path.
   Four subsystems appear in the table in two configurations that differ
   only in where the integrity head lives, and in every one of them T9
   changes: atelya-attest and continuum-agent move from ACCEPTED to
   REPORTED when the head is anchored or signed outside the store, and
   T2 moves with it, since a chain alone cannot see its own tail
   removed; atmem moves T9 alone with an external checkpoint; and
   ExactMemory moves T9 alone from ACCEPTED to REJECTED when its anchor
   is taken off the store.  The same code gives a different answer, and
   the difference is a deployment decision.

   Third, what the adversary holds matters as much as what the store
   checks. inspeximus with receipts on reports T1 to T9 at audit while
   the adversary holds only the store directory, and accepts T2 and T9
   once the adversary also holds the configuration home.  The memory-
   blackbox 0.1.1 fix described in the -01 revision of draft-khandelwal-
   bmwg-agent-memory-integrity holds for T1 to T8 across a restart, but
   a whole-store rollback that carries the ledger back with the file is
   accepted after a restart and reported only while the process stays
   alive.























Khandelwal                 Expires 5 May 2027                  [Page 15]

Internet-Draft      Agent Memory Integrity Benchmark       November 2026


   Fourth, a per-record authenticator still catches edits to a record's
   bytes and nothing about where the record sits or how many there are.
   acrf-memory-guard rejects T1, T5, and T8 and accepts the other six
   edits it was measured on.  The token-by-reference store of the Human
   Delegation Provenance Protocol (HDP) [HDP] refuses the six edits that
   change or move a token, under either reference: those three, and also
   the reordered, moved, and rolled-back tokens.  Under the content
   reference, a digest recomputed on every read refuses any substitution
   under the reference the recipient holds, and a forged token fails the
   root signature one step later.  Under the UUID reference, taken from
   the token's own header, the altered, forged, and metadata-edited
   tokens fail a signature, and the reordered, moved, and rolled-back
   tokens fail because the reference under which they were found does
   not match the header they carry; what a UUID cannot stop is a
   different genuine snapshot of the same chain under the same
   identifier, the substitution Section 8.2 of [HDP] names, which none
   of these edits makes.  Under either reference the store serves the
   three edits that remove tokens or restore an older set, because the
   recipient asks only for the references the store still holds, and an
   older copy of the store resolves each reference it holds just as it
   did when it was current.

   Fifth, two rows refuse T1 to T9 on the read path, where the -01
   revision of draft-khandelwal-bmwg-agent-memory-integrity had none:
   surgical-devops-g7, whose whole-store root is checked against a
   witness the store does not hold, and recallspection-exact+anchor,
   whose anchor sits off the store and which refuses T10 as well.  Two
   more refuse T1 to T8 on the read path and accept T9, agent-memory and
   recallspection-exact, which is the pattern a fail-closed container
   check produces when its head is kept beside the container.  Of the
   rest, acrf-memory-guard and the HDP token store refuse a subset on
   the read path, and every other subsystem that claims tamper evidence
   detects at audit, after the agent has already resumed.

   Sixth, on the seven rows where T10 is measured, six serve the erased
   record again as current once the pre-erasure copy is restored, and
   one refuses it. langgraph-ledger is among the six: it reports T9 at
   audit, because its ledger notices a checkpoint that should be present
   and is not, and accepts T10, because nothing in its ledger says that
   a record should be gone. recallspection-exact+anchor refuses T10 on
   the read path for the same reason it refuses T9: its anchor, held off
   the store, had moved past the restored copy, and the store reports
   itself older than its last committed state.








Khandelwal                 Expires 5 May 2027                  [Page 16]

Internet-Draft      Agent Memory Integrity Benchmark       November 2026


12.  Levels (Informative)

   The reference implementation publishes a ladder of five levels a
   subsystem can claim from its row, each a set of edits it REJECTS on
   the read path, in the order an adversary with store access reaches
   for them.  The levels are cumulative and are not part of the metric;
   they are offered because a single metric value hides which edits a
   subsystem refuses, and a vendor's claim is easier to check when it
   names a level.

   L0 Measured:  the subsystem has a published row, with any verdicts.
   L1 Bytes bound:  rejects on the read path every edit that changes or
      adds bytes: T1, T3, T5.
   L2 Sequence bound:  also rejects deletion, reordering, and rollback
      of a record: T2, T4, T7.
   L3 Context bound:  also rejects a record moved between owners and a
      metadata change: T6, T8.
   L4 Head anchored off the store:  also rejects a rollback of the whole
      store to an older genuine copy: T9.

   On the rows in Table 1, surgical-devops-g7 and recallspection-
   exact+anchor reach L4, agent-memory and recallspection-exact reach
   L3, and no released subsystem sits at L1 or L2: the subsystems that
   bind bytes on the read path bind sequence and context as well, and
   the two that refuse on the read path without reaching L1 both serve a
   record's removal.  The implementation also names a fifth level,
   verifiable by a third party without the store's cooperation, marked
   proposed until a subsystem earns it.  T10 is not yet part of the
   ladder: it is measured on seven rows, and only one of them,
   recallspection-exact+anchor, refuses it.  The ladder will take it up
   once the cell is carried on every row.

13.  Design Rationale (Informative)

   Six choices in this method are worth stating explicitly.

   First, ten edits rather than one.  A single "tamper the file" case
   lets a subsystem with a whole-store checksum pass while it still
   accepts rollback and cross-context replay.  T6 and T7 in particular
   exist because encryption alone accepts them: they move only genuine
   bytes.

   Second, the verdict comes from the SUT, not from the evaluator.
   Inspecting the store to decide whether a tamper "should" have been
   caught makes the result an opinion.  Reading through the SUT's own
   read path and recording what it did makes it a measurement.





Khandelwal                 Expires 5 May 2027                  [Page 17]

Internet-Draft      Agent Memory Integrity Benchmark       November 2026


   Third, control C1 is not optional.  It is the only thing that
   prevents a subsystem that rejects all reads from scoring a perfect
   result.

   Fourth, the SUT is stopped during the edit.  The memory-blackbox
   result reported in the -01 revision of draft-khandelwal-bmwg-agent-
   memory-integrity is the reason: the same subsystem, the same eight
   edits, and the same scan went from eight of eight reported to none of
   eight on nothing but a restart.  A method that left the attacker
   position to the evaluator would have produced both results and called
   both correct.

   Fifth, T9 is a case of its own rather than a variant of T2.  The two
   part ways in Table 1: atmem's chain alone reports T2 and accepts T9,
   and ExactMemory's container MAC rejects T2 and accepts T9, because
   the rollback restores the chain head or the anchor along with the
   records.  In each of the four subsystems measured with the head
   beside the records and again with it outside, moving the head is what
   turns T9 into a pass.  A method without T9 would have scored the
   beside-the-records configurations as tamper evident against the one
   edit a restored backup makes.

   Sixth, T10 is a case of its own rather than a variant of T9.  Both
   restore an older genuine copy, but a head that only grows catches T9
   and can miss T10, because an erasure does not raise it. langgraph-
   ledger in Table 1 shows the split: its ledger of what must be present
   reports T9 at audit and accepts T10.  A method that folded T10 into
   T9 would have credited that ledger with catching the edit a restored
   backup makes to an erasure.

14.  Reference Implementation (Informative)

   An open, MIT-licensed implementation of this method, called agmi
   (Agent Memory Integrity), runs offline and applies the ten edits and
   the three controls to the memory components of the subsystems in
   Table 1 through a common adapter interface, with every verdict pinned
   to the measured version by a test that fails when the version moves.
   It also runs as a continuous-integration check that fails a build
   when any edit is accepted; one of the measured vendors has adopted it
   in that form, and another contributed its own adapter as a pull
   request that was reproduced independently before it was merged.  It
   is provided for reproducibility and is not required to use the
   method.

   The implementation's own continuous integration re-measures every row
   it can reach on each change and weekly against the latest releases,
   and fails if this measurement disagrees with the committed results on
   any cell both measured.  The results file is published with the



Khandelwal                 Expires 5 May 2027                  [Page 18]

Internet-Draft      Agent Memory Integrity Benchmark       November 2026


   record described in Section 10: a digest per row over its canonical
   encoding, a manifest of those digests with named rejection grounds,
   an independent recount with its decision rule, and the git commit and
   the package release as anchor, together with a verifier that
   recomputes all of it from the pinned bytes.  Two rows re-measured two
   days apart reproduced cell for cell, detail strings included.

      Code and results: https://github.com/tech4biz-yasha/agent-memory-
      integrity, revision e7fef18 (version 0.6.3).  The results file at
      that revision holds thirty-nine rows: the thirty-one of Table 1,
      the reference model left out of it, and seven rows measured only
      on the implementation's memory-specific attack families, which lie
      outside this method.  For class (b) verdicts it records the audit
      call used in each cell; the store or namespace queried and the
      interval between the edit and the audit read are not yet recorded
      as fields and are added in the next revision.  It records the
      platform of the run, and for eleven rows the runtime they were
      measured on, but not the libraries each SUT links against.
      Results site: https://agentmemoryintegrity.org
      Method paper: https://doi.org/10.5281/zenodo.22995111

15.  Security Considerations

   This document defines a benchmarking method for laboratory use.  As
   with other benchmarking methodologies, the procedures here are
   intended for an isolated test bed and MUST NOT be run against
   production systems or systems the evaluator is not authorised to
   test.  The test cases apply adversarial edits to a store; those edits
   MUST be confined to test data in a controlled environment.  T10
   exercises the SUT's own erasure operation, which on some subsystems
   removes a whole context; it MUST be run only against test data.

   The method measures a security-relevant property, whether an agent
   detects at-rest tampering with its memory, but a metric value from
   this method is not by itself an assurance of security.  A high value
   on this method does not measure confidentiality, input-path poisoning
   resistance, or any property outside Section 2.

   Publishing per-case verdicts for named subsystems and versions
   describes weaknesses in released software.  The intent is
   constructive: results are stated with the version measured so that
   vendors can reproduce and fix them, and so that a later re-
   measurement shows the change.

16.  IANA Considerations

   This document has no IANA actions.




Khandelwal                 Expires 5 May 2027                  [Page 19]

Internet-Draft      Agent Memory Integrity Benchmark       November 2026


17.  Normative References

   [RFC2119]  Bradner, S., "Key words for use in RFCs to Indicate
              Requirement Levels", BCP 14, RFC 2119, March 1997,
              <https://www.rfc-editor.org/info/rfc2119>.

   [RFC8174]  Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC
              2119 Key Words", BCP 14, RFC 8174, May 2017,
              <https://www.rfc-editor.org/info/rfc8174>.

18.  Informative References

   [RFC2544]  Bradner, S. and J. McQuaid, "Benchmarking Methodology for
              Network Interconnect Devices", RFC 2544, March 1999,
              <https://www.rfc-editor.org/info/rfc2544>.

   [RFC8239]  Avramov, L. and J. Rapp, "Data Center Benchmarking
              Methodology", RFC 8239, August 2017,
              <https://www.rfc-editor.org/info/rfc8239>.

   [I-D.calabria-bpm-ai-fabric-terminology]
              Calabria, F., Pignataro, C., Wu, Q., Fioccola, G., and S.
              Reddy, "Benchmarking Terminology for AI Network Fabrics",
              Work in Progress, Internet-Draft, draft-calabria-bpm-ai-
              fabric-terminology-00, 30 October 2026,
              <https://datatracker.ietf.org/doc/draft-calabria-bpm-ai-
              fabric-terminology/>.

   [I-D.hcf-bpm-agent-security-benchmark-terminology]
              Han, Y., Chen, M., Fan, Q., and Q. Wu, "Benchmarking
              Terminology for AI Agent Security Evaluation", Work in
              Progress, Internet-Draft, draft-hcf-bpm-agent-security-
              benchmark-terminology-00, 23 October 2026,
              <https://datatracker.ietf.org/doc/draft-hcf-bpm-agent-
              security-benchmark-terminology/>.

   [HDP]      Dalugoda, A., "Human Delegation Provenance Protocol (HDP):
              Cryptographic Chain-of-Custody for Agentic AI Systems",
              Work in Progress, Internet-Draft, draft-helixar-hdp-
              agentic-delegation-03, 6 October 2026,
              <https://datatracker.ietf.org/doc/draft-helixar-hdp-
              agentic-delegation/>.









Khandelwal                 Expires 5 May 2027                  [Page 20]

Internet-Draft      Agent Memory Integrity Benchmark       November 2026


Acknowledgements

   The author thanks the maintainers of the memory subsystems measured
   during the development of this method for their engagement on the
   individual findings, in particular the maintainers of inspeximus, who
   found the no-op cells that led to control C3, and of memory-blackbox,
   who reproduced and fixed the restart result within a day; of Surgical
   DevOps, who contributed their store's adapter; of Recallspection and
   HDP, who reviewed the description of their own systems before their
   rows were published, HDP having also added the measured cases to its
   own conformance suite; and of agent-evidence-vectors, whose corpus
   this implementation runs in its continuous integration and which runs
   this implementation's verifier in return.  Thanks also to the authors
   of draft-han-bmwg-agent-security-benchmark, since split into
   [I-D.hcf-bpm-agent-security-benchmark-terminology] and its companion
   profiles document, for the discussion on the working group list that
   shaped the detection-point distinction and for taking up this
   method's verdicts and placement test in those documents.

Change Log

   This section is to be removed before publication as an RFC.

Changes Since draft-khandelwal-bmwg-agent-memory-integrity-02

   *  Renamed from draft-khandelwal-bmwg-agent-memory-integrity, which
      this document replaces, on the formation of the BPM working group
      as the successor of BMWG; the change history below continues that
      draft's.
   *  Added test case T10, erasure resurrection, with its C3 clause, its
      not-applicable rule, its scoring group, and the rationale for
      keeping it separate from T9.
   *  Added the T10 column to the illustrative table, measured on seven
      rows; the other cells are not yet measured or not applicable, with
      the reason stated in the results file.  T1 to T9 are unchanged
      from -02, cell for cell.
   *  Rewrote the description of the HDP token store's results in the
      wording of the published row pages, which its maintainer reviewed.
   *  Named the metric document this method serves as the test method
      for, draft-hcf-bpm-agent-security-benchmark-terminology, which
      adopts its threat model, procedure and verdicts, and recorded the
      two edits that document does not yet carry.
   *  Noted how a profile that credits read-time detection alone takes
      its count from the per-case verdicts.







Khandelwal                 Expires 5 May 2027                  [Page 21]

Internet-Draft      Agent Memory Integrity Benchmark       November 2026


   *  Added the observation point of a verdict, in the three classes of
      draft-calabria-bpm-ai-fabric-terminology restated for a software
      DUT, and the conditions under which two verdicts are comparable
      across runs, as discussed on the working group list in October
      2026.
   *  Updated the reference implementation revision to e7fef18 and
      stated the row count of its results file.
   *  Added the runtime and the libraries the SUT links against to the
      comparability conditions, and stated that the method sets no
      threshold for an acceptable Metric Value.
   *  Cited the HDP specification and the renamed AI fabric terminology
      draft.
   *  Removed the submissionType attribute and added the author's
      country.

Changes in draft-khandelwal-bmwg-agent-memory-integrity-02

   *  Added test case T9, whole-store rollback, with its C3 clause, its
      scoring group, and the rationale for keeping it separate from T2.
   *  Made the detection point a required property of a result and
      required separate results for a subsystem that offers both a read-
      path check and an audit.
   *  Added the C3 refusal for identically seeded contexts.
   *  Added a reporting requirement for a recomputable published result
      set, and described the reference implementation's record and its
      continuous re-measurement.
   *  Replaced the illustrative results with thirty-one rows on released
      subsystems, including the first two that refuse all nine edits on
      the read path, and added the informative levels ladder.
   *  Updated the reference implementation to version 0.6.3 at its
      current repository path.

Changes in draft-khandelwal-bmwg-agent-memory-integrity-01

   *  Added control C3, "edit landed", and the "error" outcome.
   *  Made the stopped-SUT attacker position explicit in the procedure,
      with rationale.
   *  Replaced the illustrative results with thirteen subsystems,
      including six that claim tamper evidence, and the first vendor
      fix.
   *  Added the relationship to the write-path poisoning and cross-
      context isolation metrics.
   *  Updated the reference implementation to version 0.6.2 and the
      method paper to its second version.

Author's Address





Khandelwal                 Expires 5 May 2027                  [Page 22]

Internet-Draft      Agent Memory Integrity Benchmark       November 2026


   Yasha Khandelwal
   Tech4Biz Solutions
   Bengaluru
   India
   Email: yasha.khandelwal@tech4biz.io














































Khandelwal                 Expires 5 May 2027                  [Page 23]