Atomic CRUD Memory Protocols

• Atomic CRUD memory is a framework that guarantees immediate, linearizable Create, Read, Update, and Delete operations while robustly handling crash, Byzantine, and transient failures.
• It leverages distributed erasure-coded protocols, hardware transactional memory, and minimally ordered durable data structures to optimize storage cost, latency, and scalability.
• Agentic CRUD memory frameworks integrate learned policies with dynamic vector databases to autonomously manage memory operations, enhancing autonomous system performance.

Atomic CRUD memory refers to systems, algorithms, or hardware that provide atomic Create, Read, Update, and Delete operations—CRUD—not only for data persistency, but with strong consistency (typically linearizability/atomicity), robustness to failures (crash, Byzantine, or transient hardware failures), and well-characterized performance, in both distributed and local memory/storage environments. Modern work formalizes CRUD at the lowest level—atomic protocols and composable primitives—enabling scalable distributed memory emulation, high-throughput persistent transactions, and agentic reasoning modules with autonomous memory behaviors. Solutions range from distributed erasure-coded protocols to hardware-accelerated local persistent memories and agentic vector memory frameworks.

1. Formal Definitions: Atomic CRUD Operations and Consistency

At the core, atomic CRUD memory exposes an interface that guarantees each Create, Read, Update, and Delete operation appears instantaneous (atomic) and consistent with a global sequence—linearizability. In distributed contexts, each operation must satisfy:

• Atomicity (Linearizability): For any complete history $H$ of invocations and responses, there exists a total order $\prec$ on operations such that: (i) if op₁ completes before op₂ starts, then op₁ $\prec$ op₂; (ii) all writes (Create, Update, Delete) are totally ordered; (iii) each Read returns the value of the most recent Create/Update preceding it, or a distinguished "deleted" marker if the latest operation is a Delete (Nicolaou et al., 2018, Zorgui et al., 2018, Nicolaou et al., 19 Jan 2026).
• Failure Atomicity: After any crash (including power loss or system failure), the memory returns to a consistent state reflecting a prefix of completed transactions—either all or none of a transaction's CRUD changes are reflected (Genç et al., 2020, Ye et al., 2022, Haria et al., 2019).
• Semantic Mapping: Typically, Create is the first write of a non-$\perp$ value; Update is a subsequent write with a new value; Delete is a special write of a tombstone (distinguished marker), and Read retrieves current state, returning the tombstone for logically deleted objects (Zorgui et al., 2018, Cadambe et al., 2014, Nicolaou et al., 2018).

2. Distributed Atomic CRUD Protocols: Algorithms and Storage-Efficiency

Distributed atomic CRUD memory is fundamentally realized via protocols emulating atomic shared registers or objects over unreliable components. Key results include:

• Erasure-Coded CRUD Algorithms (e.g., CAS, CASGC, TREAS, MWABD, DeRAM):
  • Use systematic $(N,k)$ MDS codes to fragment each value into $N$ coded shards; any $k$ suffice to reconstruct, tolerating up to $f$ failures (where $k \leq N-2f$).
  • CRUD operations are mapped directly to versioned write/read protocols with tags for total ordering, and tombstone (e.g., $\perp$ or $\Delta$) for logical deletion.
  • Storage and communication-optimality is achieved by code-rate $N/k$ and garbage collection to bound per-server state, with minimal rounds (two-phase protocols for typical MWMR settings).
  • Atomicity is preserved via quorum systems: write or finalize to quorums of size $q = \lceil (N+k)/2\rceil$ ensures any two quorums overlap in at least $k$ servers, so no two operations can diverge (Cadambe et al., 2014, Zorgui et al., 2018, Nicolaou et al., 2018, Nicolaou et al., 19 Jan 2026).
  • Liveness relies on bounded concurrency ($\delta$ for concurrent writes/read), with storage and communication overheads bounded as summarized in the table:

Algorithm	Storage cost per object	Comm. cost per R/W	CRUD latency (rounds)
CAS (MWMR)	Unbounded	$N/(N-2f)\cdot V$	2
CASGC ($\delta$)	$(\delta+1)N/k$	$N/k\cdot V$	2
TREAS	$(\delta+1)n/k$	$n/k\cdot V$	2
DeRAM (RLNC)	$n/k$	$O(n)$	2

• Configuration and Reconfiguration: Frameworks like ARES coordinate distributed reconfiguration (membership changes, e.g., server join/leave), installing new configurations with atomicity via coordinated consensus and state transfer. Garbage-collection and version-pipelining guarantee that deletion propagates, enabling safe reclamation (Nicolaou et al., 2018).
• High-Scalability/Byzantine-Tolerant DeRAM: Solutions like OPTIMUM-DERAM use clusters selected by consistent hashing and Random Linear Network Coding (RLNC), with blockchain-style registries and cryptographically-protected fragments. They support multi-object CRUD (placement/removal), tolerate Byzantine flexnodes up to $b<(n-k)/3$, and retain communication/storage optimality (Nicolaou et al., 19 Jan 2026).

3. Local and Persistent Memory: Atomic CRUD with Hardware Transactionality

Atomic CRUD memory at the persistent hardware level requires both memory consistency and crash/failure atomicity:

• HTM-Based Persistent Transactions (Crafty):
  • Crafty leverages commodity HTM (e.g., Intel TSX) and "nondestructive undo logging" to provide high-throughput, atomic CRUD operations on byte-addressable persistent memory (e.g., Intel 3D XPoint), while ensuring all in-place updates are preceded by persisted undo records.
  • The protocol's three phases (Log, Redo, Validate) carefully control persist ordering: no persistent write is made visible until its undo-log entry is durable (via clwb/SFENCE). On recovery, logs are replayed or rolled forward as needed, preserving atomicity (Genç et al., 2020).
  • This enables efficient failure-atomic CRUD sections without excessive flushes or global locks, yielding up to 1.5–2.5$\times$ throughput of prior HTM-persistent schemes under realistic workloads.
• Minimally Ordered Durable Data Structures (MOD):
  • MOD exposes composable out-of-place update APIs for single and multi-object CRUD. Each update creates a new version (shadow page, structurally shared), flushed with unordered clwb's, then a single sfence and atomic pointer swap ensures atomic visibility.
  • Old versions can be retained or garbage-collected; if a crash happens before commit, old versions are intact, post-commit only the fully flushed new root is visible.
  • Compared with STM/PMDK, MOD reduces flushes/fences by 40%–50%, with O(log n) node updates and modest space blowup via structural sharing (Haria et al., 2019).
• Hardware Logging with Transiently Persistent Cache (Hercules):
  • Hercules leverages eADR-enabled systems that ensure, on power loss, all dirty CPU cache lines are automatically flushed to persistent memory. It augments caches and the memory controller with transaction tags, a redirectable write queue, and a persistent log ring.
  • CRUD sections mark updates with per-transaction tags; cache lines evicted before commit are written to the log. Transaction commit is atomic: all lines are either visible in place, or, in a crash, recovered from the log (Ye et al., 2022).
  • This removes the need for software flushes, yielding up to 89.2% higher throughput than best-of-breed software schemes.

4. Agentic and Learnable Atomic CRUD Memory in AI Systems

Recent advances involve integrating atomic CRUD at higher levels, particularly in agentic or AI settings:

• Agentic CRUD Memory (AtomMem):
  • The AtomMem framework reframes memory management as a dynamic POMDP, where each step interleaves LLM task outputs with atomic CRUD memory actions (Create, Read, Update, Delete), operating on a vector database with per-entry embeddings.
  • Each atomic op is triggered by emitting a structured token in the LLM output; Update and Delete actions directly modify the external vector memory, while Read retrieves top-k entries (cosine similarity).
  • Policy is trained over interleaved reasoning and memory actions using supervised fine-tuning followed by reinforcement learning (Group Relative Policy Optimization), optimizing for end-to-end task reward (e.g., QA Exact-Match).
  • Experimental ablations confirm the necessity of Update for refinement, and the combined use of scratchpad and external memory for high accuracy; the emergent learned policies shift from heavy read usage to efficient create/update cycles during training (Huo et al., 13 Jan 2026).

5. Performance, Scalability, and Trade-Off Analyses

Atomic CRUD memory designs present quantifiable performance and resource trade-offs:

• Distributed Protocols:
  • Erasure coding (CAS, TREAS, DeRAM) drastically reduces per-object storage from $n$ replicas to $n/k$, at the expense of $O(k^3)$ decode per read and $O(n)$ message complexity per CRUD operation.
  • Storage-efficient schemes (CASGC, TREAS) bound per-server growth via concurrency ($\delta$), and practical systems (ARES/DeRAM) exploit modular reconfiguration for large-scale, heterogeneous environments with millions of objects.
  • Insecurity to crash and Byzantine faults is managed by quorum sizes and cryptographic authentication (Nicolaou et al., 19 Jan 2026, Nicolaou et al., 2018).
  • Empirical data confirms that coding-based approaches achieve flat or improved latency under higher concurrency, larger object counts, and dynamic membership, compared to classic ABD full-replication.
• Persistent Memory Systems:
  • Crafty and MOD demonstrate that minimizing flush/fence ordering via out-of-place, epoch-based CRUD (atomic pointer swaps or transactional commits) yields up to 50% gain in microbenchmark/application throughput against undo/redo log STM and PMDK (Haria et al., 2019, Genç et al., 2020).
  • Hardware offloading (Hercules) achieves orders-of-magnitude PMem-write reduction by leveraging transiently persistent CPU caches and log redirection at eviction/commit (Ye et al., 2022).
• Agentic CRUD Memory:
  • AtomMem-8B, trained with hybrid RL/SFT, achieves EM improvements of 2–5 points over MemAgent on the 800-doc HotpotQA benchmark; absent update, EM drops by up to 7 points. Memory workflows adapt over training epochs, with structured creation and refinement (Huo et al., 13 Jan 2026).

6. Modalities, Failure Models, and Open Problems

Atomic CRUD memory is instantiated in varying computational models, each with distinct assumptions and open challenges:

• Crash-Stop Model with Erasure Coding: Optimal tradeoffs in storage/comm/latency are established for SWMR/MWMR objects; bounded concurrency is critical for liveness under storage constraints. Open directions include coded storage with stronger adaptive concurrency, or efficient, safe garbage collection without liveness tradeoffs (Zorgui et al., 2018, Cadambe et al., 2014).
• Reconfigurable/Byzantine-Tolerant Systems: Dynamic join/leave and Byzantine behavior are handled via blockchain oracles and object re-sharding with RLNC. There are open problems in optimizing recoding cost and ensuring practical recovery times in extremely large clusters (Nicolaou et al., 19 Jan 2026).
• Persistent Memory Atomicity: Ensuring all possible partial states are unreachable post-crash in high-concurrency, compositional CRUD workloads is an ongoing design constraint; further advances in hardware transactional support and nonvolatile caches may reduce programmer burden (Genç et al., 2020, Ye et al., 2022).
• Agent-Centric CRUD: Enabling LLMs and agents to efficiently discover and exploit dynamic CRUD policies for memory management—balancing exploration (read) and distillation (update/delete)—remains an active area of research, especially for long-context, multi-turn, and task-generalizing scenarios (Huo et al., 13 Jan 2026).

7. Summary and Outlook

Atomic CRUD memory encompasses a family of rigorously formalized mechanisms enabling strongly consistent, failure-atomic Create/Read/Update/Delete operations in distributed, persistent, and agentic memory settings. Core contributions arise from distributed consensus and coding protocols (ABD, CAS, TREAS, DeRAM), hardware/software transactional memory (Crafty, MOD, Hercules), and adaptive agentic workflows (AtomMem). Each solution is parameterized by trade-offs—storage cost, communication rounds, concurrency tolerance, recoverability, and hardware support—with formal correctness guarantees under well-specified system and failure models. The ongoing evolution includes further optimizing resource usage, tolerating heterogeneous/adversarial failures, and integrating atomic CRUD into learnable and autonomous systems for real-world complex tasks.

Key references:

• "AtomMem: Learnable Dynamic Agentic Memory with Atomic Memory Operation" (Huo et al., 13 Jan 2026)
• "Crafty: Efficient, HTM-Compatible Persistent Transactions" (Genç et al., 2020)
• "Storage-Efficient Shared Memory Emulation" (Zorgui et al., 2018)
• "ARES: Adaptive, Reconfigurable, Erasure coded, atomic Storage" (Nicolaou et al., 2018)
• "MOD: Minimally Ordered Durable Datastructures for Persistent Memory" (Haria et al., 2019)
• "OPTIMUM-DERAM: Highly Consistent, Scalable, and Secure Multi-Object Memory using RLNC" (Nicolaou et al., 19 Jan 2026)
• "Oh-RAM! One and a Half Round Atomic Memory" (Hadjistasi et al., 2016)
• "A Coded Shared Atomic Memory Algorithm for Message Passing Architectures" (Cadambe et al., 2014)
• "Enabling Atomic Durability for Persistent Memory with Transiently Persistent CPU Cache" (Ye et al., 2022)