# Zaxy: Event-Sourced Memory Fabric for Cited, Temporal, Multi-Agent AI Systems

- Author: Zaxy project
- Status: Research draft
- Version context: Zaxy 1.1.2

## Abstract

Long-running AI agents do not merely need more context. They need memory that is
replayable, temporal, cited, purpose-aware, and safe to share across agents.
Zaxy was developed to test that thesis in a production-oriented memory system.
The resulting architecture treats memory as an event-sourced temporal knowledge
graph fabric: immutable Eventloom JSONL logs provide the source of truth,
extractors project typed events into graph and source-recall views, retrieval
combines exact, lexical, vector, verbatim, traversal, and active working-set
lanes, and Memory Checkout returns a bounded, cited prompt contract rather than
a raw context dump.

This paper summarizes the theory, mathematics, implementation lessons,
benchmarks, failure modes, and research directions that emerged while building
Zaxy through the 1.1.2 release. The strongest internal same-harness result is
the publish 20260607 full 500-question LongMemEval-compatible checkout run: mean score
0.956, Answer@5 0.910, citation coverage 1.000, Recall@1/5/10 of
0.960/1.000/1.000, p95 latency 1,966.65 ms, and p99 latency 2,495.07 ms over 5,372
Eventloom events, 948 sessions, and a frozen workload hash
`90fb2307195d7e16b963a2b8a30f03b375bd42a45d41aeaa55423029dd84e3fc`.
The important interpretation is not simply that retrieval is strong. It is that
within Zaxy's event-sourced adaptation of this workload, retrieval and citation
reached a plateau: 45 `synthesis_miss` cases remained and no retrieval-miss
class was observed. That shifted the research agenda from "find more context"
to "compose, rank, verify, and cite the right answer from already-retrieved
evidence." External legal-agent evidence from the Harvey LAB memory-ablation
suite provides a separate downstream validation signal: Zaxy completed 10/10
pinned tasks with mean criterion pass rate 0.788, +0.184 over the
regular/no-memory article row, +0.081 over article-best task rows, and 9/10 task
wins versus the article-best rows.

Other benchmark lanes sharpened the thesis. StateRecoveryBench showed that raw
associative propagation can recover latent state but fails at authority, stale
row rejection, and distractor resistance unless resolved through explicit
provenance metadata. CoordinationBench showed that flat transcripts, markdown
notes, and BM25 worker logs can retrieve text but cannot represent accepted
parent state, conflict review, duplicate consolidation, purpose feedback, or
replayable citation chains. PurposeBench showed that memory quality depends on
the intended action: coding, release, security, research, support, legal, and
coordinate work require different evidence policies even when they query the
same underlying event log.

The central lesson is that agent memory is not only a vector database problem, a
prompt-length problem, or a summary-management problem. It is primarily a
state-management problem under temporal, evidential, and organizational
constraints.

## 1. Motivation

The default approach to agent memory is still a mixture of markdown notes,
conversation summaries, vector indexes, and larger context windows. Each is
useful, but each collapses a different part of the memory problem.

Markdown is easy for humans to edit, but weak as a system-of-record. Updates
overwrite prior state unless history is manually preserved. Relationships are
implicit. The model can read the note, but cannot replay how the note was
formed or verify the sequence of accepted decisions that led to the current
state.

Vector memory retrieves text that is close to a query. This is an important
capability, but similarity is not provenance. A vector hit does not by itself
tell the agent whether a fact is current, stale, accepted, rejected,
superseded, worker-local, parent-approved, cited, or safe to act on.

Long context windows reduce pressure, but do not solve context selection.
Research on long-context models shows that relevant information can be
underused when buried inside long prompts. In Zaxy's language, a larger prompt
is not the same thing as a better checkout. The question is not "how much can
we stuff into the model?" but "what state should the model be allowed to rely
on, and why?"

The Zaxy project began from a stronger claim:

> Agent memory should be treated like a replayable, cited, temporal state
> system. Retrieval is a view over that state, not the state itself.

That claim led to four design principles:

1. The source of truth must be immutable and replayable.
2. Projection layers must be derived, discardable, and rebuildable.
3. Model-facing memory must carry citations, warnings, and answerability
   diagnostics.
4. Shared multi-agent memory must distinguish worker-local findings from
   accepted parent state.

## 2. Related Work

Zaxy sits at the intersection of event sourcing, temporal databases, graph RAG,
retrieval-augmented generation, memory-augmented agents, and associative memory.

### Event Sourcing and Temporal State

Event sourcing stores changes to application state as a sequence of events and
allows state to be rebuilt by replaying those events. This pattern directly
influenced Zaxy's Eventloom-first design: the graph is not the memory; it is a
projection of the memory. Microsoft and Martin Fowler both describe event
sourcing as a design that makes the event log the durable source of state and
enables rebuilding derived views.

Temporal and bi-temporal database ideas influence the way Zaxy models
validity. A fact can be asserted at one transaction time while describing a
valid interval in the world. Zaxy's graph projection therefore preserves
`valid_from` and `valid_to` windows rather than overwriting facts in place.
This lets memory answer both "what is true now?" and "what did we believe then?"

### Retrieval-Augmented Generation and Graph RAG

Classic RAG combines parametric model knowledge with non-parametric retrieved
documents. Zaxy adopts the non-parametric-memory premise but adds stricter
state and provenance requirements. GraphRAG showed that graph-structured
representations can answer questions that are poorly served by flat retrieval,
especially when relationships and summaries over groups matter. Zaxy uses a
similar insight, but applies it to agent events, decisions, files, symbols,
missions, handoffs, and temporal facts rather than only document corpora.

### Long-Term Agent Memory Benchmarks

LongMemEval evaluates five long-term memory abilities for chat assistants:
information extraction, multi-session reasoning, temporal reasoning, knowledge
updates, and abstention. It also frames memory design as indexing, retrieval,
and reading. Zaxy's results support that decomposition but add a fourth stage:
checkout synthesis. Once answer-bearing evidence is retrieved and cited,
the remaining problem is constructing an answerable, auditable context packet.

The LongMemEval-compatible Zaxy reports in this paper should be read as adapted
retrieval/checkout evidence, not as official LongMemEval end-to-end assistant
scores. Zaxy maps the cleaned benchmark sessions into Eventloom document and
memory events, projects them through its graph/source-recall stack, and evaluates
whether checkout retrieves and cites answer-bearing session identities and
answer surfaces. That protocol is useful for testing Zaxy's memory fabric, but
it differs from the original chat-history assistant-interaction setup and is
therefore not directly comparable to published LongMemEval leaderboard or
end-to-end answer-accuracy numbers.

MemGPT frames agent context as a virtual memory problem: keep main context
small and page in external memory deliberately. Zaxy agrees with the virtual
context framing but replaces opaque paging with a cited Memory Checkout
contract. A-MEM and related agentic memory systems emphasize dynamically
organized memory. Zaxy's version of dynamic organization is event-backed:
reinforcement, feedback, purpose profiles, and projection artifacts are new
events or derived views, not silent mutation of the source of truth.

### External Legal-Agent Memory Ablations

Zaxy's Harvey LAB evidence is a separate external-validation lane. Harvey LAB is
a legal-agent work-product benchmark built around task deliverables and judged
rubric criteria, not a long-term chat-memory retrieval benchmark. The current
Zaxy report imports externally generated Harvey normalized-result artifacts,
audits memory-search/read calls and judge score files, and compares Zaxy's rows
against the article-published regular/no-memory and task-best rows. This makes
the Harvey result a stronger external downstream signal than an internal
synthetic benchmark, while still requiring careful interpretation: the metric is
criterion pass rate, article-relative rows are published disclosures, and
non-Zaxy systems were not all rerun by Zaxy in the same process.

### Ranking, Diversity, and Late Interaction

Zaxy uses BM25 as a strong lexical baseline and as part of hybrid retrieval.
BM25 remains difficult to beat for short, exact, named-entity queries.
Maximum Marginal Relevance (MMR) motivates Zaxy's diversity pass: near-duplicate
hits should not crowd out adjacent evidence. ColBERT-style late interaction
motivates the future reranker lane: single-vector similarity loses token-level
alignment, especially for "which item" and source recall questions.

### Associative Memory and Neuroscience-Inspired Directions

Modern Hopfield Networks connect energy-based associative memory and attention.
The neuron-astrocyte associative memory work of Kozachkov, Slotine, and Krotov
suggests that higher-order process layers can improve associative capacity and
partial-cue completion. Zaxy explored this direction experimentally, but
StateRecoveryBench showed the crucial product lesson: raw association recovers
latent state while often pulling in stale or authority-shaped distractors.
The useful direction is not "add a neural memory layer because it is elegant."
It is "use broad association to propose candidates, then resolve them through
explicit authority and provenance."

## 3. Formal Model

This section gives the mathematical shape of Zaxy's memory fabric. The notation
is intentionally implementation-adjacent: each term corresponds to a concrete
system component.

### 3.1 Event Log

Let a session-scoped Eventloom log be an ordered sequence

\[
\mathcal{E}_s = \langle e_1, e_2, \ldots, e_n \rangle .
\]

where each event is

\[
e_i = \bigl(i, t_i, \tau_i, a_i, p_i, h_i, h_{i-1}\bigr)
\]

with sequence number \(i\), timestamp \(t_i\), type \(\tau_i\), actor \(a_i\),
payload \(p_i\), hash \(h_i\), and previous hash \(h_{i-1}\). Hash-chain
integrity is:

\[
h_i = \operatorname{Hash}\!\left(i, t_i, \tau_i, a_i, p_i, h_{i-1}\right)
\]

for a canonical serialization and collision-resistant cryptographic hash
\(\operatorname{Hash}\). A valid log
satisfies:

\[
\forall i \in \{2,\ldots,n\},\qquad
\operatorname{prev}(e_i) = h(e_{i-1}).
\]

In addition, each \(h(e_i)\) must recompute from the sealed event fields and
\(\operatorname{prev}(e_i)\). This gives Zaxy a concrete audit invariant:
missing, reordered, or edited rows are detectable without trusting the graph
projection.

### 3.2 Extraction

Extraction maps events into entities and edges:

\[
\mathcal{X}(e_i) = \bigl(\mathcal{V}_i, \mathcal{R}_i\bigr)
\]

where \(\mathcal{V}_i\) is a set of extracted entities and
\(\mathcal{R}_i\) a set of extracted
relationships. For typed events, Zaxy uses deterministic extractors:

\[
\mathcal{X}(e_i) = \mathcal{X}_{\tau_i}(p_i).
\]

The extractor registry is deliberately schema-disciplined. Adding a new public
event type requires deciding its payload contract and writing extractor tests.
LLM extraction can be useful for unstructured events, but Zaxy's default
posture is deterministic because reproducibility and replay matter more than
maximal recall at ingestion time.

### 3.3 Temporal Projection

The graph projection is a derived view:

\[
\mathcal{G}_t = \mathcal{P}\!\left(\mathcal{E}_{\leq t}\right)
\]

where \(\mathcal{P}\) is a projection function over replayed events. Each
projected fact
has an event provenance pointer:

\[
\pi(f) = \bigl(s, i, h_i\bigr)
\]

and a validity interval:

\[
\operatorname{valid}(f) = [v_{\mathrm{from}}, v_{\mathrm{to}})
\]

Current-state retrieval is:

\[
\mathcal{F}_{\mathrm{now}}(q) =
\left\{f \in \mathcal{G} \mid
v_{\mathrm{from}}(f) \leq t_{\mathrm{now}} < v_{\mathrm{to}}(f)
\right\}.
\]

As-of retrieval is:

\[
\mathcal{F}_{\theta}(q) =
\left\{f \in \mathcal{G} \mid
v_{\mathrm{from}}(f) \leq \theta < v_{\mathrm{to}}(f)
\right\}.
\]

This separates two notions that flat memory often confuses: what was stored in
the log and what was valid in the world at query time.

### 3.4 Hybrid Retrieval

For query \(q\), Zaxy computes candidates from multiple lanes:

- exact entity lookup \(\mathcal{C}_E(q)\)
- keyword/BM25 search \(\mathcal{C}_K(q)\)
- vector similarity \(\mathcal{C}_V(q)\)
- graph traversal \(\mathcal{C}_T(q)\)
- verbatim Eventloom source recall \(\mathcal{C}_S(q)\)
- active working-set projection \(\mathcal{C}_W(q)\)

The candidate pool is:

\[
\mathcal{C}(q) =
\mathcal{C}_E(q) \cup
\mathcal{C}_K(q) \cup
\mathcal{C}_V(q) \cup
\mathcal{C}_T(q) \cup
\mathcal{C}_S(q) \cup
\mathcal{C}_W(q).
\]

Each candidate \(c\) receives lane-specific scores \(s_l(c, q)\) and a fused
score:

\[
S(c, q) =
\sum_{\ell \in \mathcal{L}} w_\ell\,\hat{s}_\ell(c, q)
+ \Delta_{\mathrm{time}}(c, q)
+ \Delta_{\mathrm{purpose}}(c, q)
+ \Delta_{\mathrm{retention}}(c, q).
\]

where \(w_\ell\) are lane weights, \(\hat{s}_\ell\) denotes a normalized
lane score, and the deltas represent temporal proximity,
purpose-conditioned policy, and retention/reinforcement effects.
When lane scores are incommensurable or only ordinally meaningful, Zaxy uses
rank-based fusion such as reciprocal-rank fusion:

\[
S_{\mathrm{RRF}}(c, q) =
\sum_{\ell \in \mathcal{L}_c}
\frac{1}{k + \operatorname{rank}_{\ell}(c, q)} ,
\]

where \(\mathcal{L}_c\) is the set of lanes that returned \(c\) and \(k\) is a
stability constant. This is the practical form that made lexical BM25 and graph
retrieval cooperate in early identity-recall runs.

Zaxy then applies diversity-aware selection. A simplified MMR objective for
selecting the next candidate is:

\[
c^\star =
\arg\max_{c \in \mathcal{C}(q) \setminus \mathcal{A}}
\left[
\lambda S(c, q)
- (1-\lambda)\max_{a \in \mathcal{A}}\operatorname{sim}(c, a)
\right],
\]

where \(\mathcal{A}\) is the already selected set. This prevents repeated
near-identical
rows from filling the context budget while leaving room for adjacent evidence.

### 3.5 Memory Checkout

Memory Checkout is the model-facing projection:

\[
\mathcal{M}(q, p, B) =
\operatorname{Pack}_B\!\left(
  \operatorname{Filter}_{p}\!\left(
    \operatorname{Rank}\!\left(\mathcal{C}(q)\right)
  \right)
\right)
\]

where \(p\) is a purpose profile and \(B\) is a prompt budget. The checkout
packet contains:

- current facts
- citations
- evidence rows
- warnings
- answerability status
- required actions
- active working set
- synthesis candidates and diagnostics when available

Checkout quality can be modeled as:

\[
Q(\mathcal{M}) =
\alpha A(\mathcal{M})
+ \beta\,\operatorname{Cit}(\mathcal{M})
+ \gamma\,\operatorname{Rec}(\mathcal{M})
- \delta\,\operatorname{Warn}(\mathcal{M})
\]

where \(A\) is answerability, \(Cit\) citation coverage, \(Rec\) evidence
recall, and \(Warn\) warning severity. Zaxy uses explicit diagnostics rather
than hiding low-confidence states: missing citations, superseded-only context,
warnings, and degraded projection paths are surfaced to the model.

### 3.6 Authority Filtering

For multi-agent coordination, not all retrieved evidence is equal. Let a row
\(r\) have authority metadata:

\[
\operatorname{auth}(r) =
\bigl(\operatorname{scope}(r), \operatorname{status}(r),
\operatorname{promoted}(r), \operatorname{stale}(r),
\operatorname{superseded\_by}(r)\bigr).
\]

For coordinate-purpose checkout, a row is allowed into accepted parent state
only if:

\[
\operatorname{allow}(r) =
\left(\operatorname{scope}(r) \in
\{\mathrm{parent}, \mathrm{accepted}\}\right)
\land
\left(\operatorname{status}(r) \notin
\{\mathrm{rejected}, \mathrm{deferred}, \mathrm{unsupported}\}\right)
\land
\neg \operatorname{stale}(r)
\land
\operatorname{superseded\_by}(r) = \varnothing .
\]

This is why raw associative retrieval is insufficient. A broad memory mechanism
can propose the right neighborhood, but accepted state requires policy over
authority, freshness, and provenance.

## 4. Architecture

Zaxy's architecture has four primary layers.

### 4.1 Eventloom Source of Truth

Eventloom is the bottom layer. In Zaxy 1.1.2, the adapter targets Eventloom v1
JSONL envelopes from `@eventloom/runtime@1.0.0`: `id`, `type`, `actorId`,
`threadId`, `parentEventId`, `causedBy`, `timestamp`, `payload`, and nested
`integrity.hash` / `integrity.previousHash` fields. Zaxy normalizes these to
its internal `Event` API while preserving legacy top-level Zaxy log replay.

This matters because source compatibility should not force a core semantic
rewrite. Eventloom remains the durable substrate; the graph, checkout, and MCP
interfaces keep stable contracts.

### 4.2 Extraction and Projection

The extraction layer converts typed event payloads into structured entities and
edges. The projection layer stores temporal graph views used for retrieval,
dashboard inspection, graph traversal, inferred-edge diagnostics, source
citations, and codebase mapping. Embedded Kuzu is the default local graph
backend; Neo4j remains a quality and interoperability control backend; pgGraph
and LatticeDB are experimental backend candidates.

The engineering rule is:

> Projections may fail, lag, or be rebuilt. Eventloom must remain useful.

That rule drove the operational design. `zaxy memory status` can inspect logs
without a graph service. `zaxy reproject` rebuilds graph state from immutable
events. `zaxy refresh-context` appends source lifecycle events rather than
patching graph rows directly.

### 4.3 Retrieval and Context Assembly

Retrieval is hybrid. Exact search handles named entities. BM25 handles literal
terms and short queries. Vector search handles phrasing changes. Traversal
adds connected facts. Verbatim Eventloom recall preserves exact source lines.
The active working set keeps the prompt focused on high-value current context.

Context assembly is not a cache. It is a prompt-ready projection over replay
and retrieval. `MemoryFabric.assemble_context` replays recent session events,
queries ranked graph memory, reserves a verbatim source-recall lane, projects a
bounded active working set, and formats the result with citations and warnings.

### 4.4 MCP Interface

MCP gives agents a standard way to discover and call memory tools. Zaxy exposes
append, query, verbatim retrieval, checkout, feedback, replay, invalidation,
coordination, and context lifecycle tools through stdio or SSE. The MCP
specification's JSON-RPC structure maps well to Zaxy's need for typed tools and
stable schemas.

The user-facing lesson from development was that memory is only real if the
agent reliably uses it. Zaxy 1.1.1 added activation persistence: model-visible
AGENTS.md instructions, resume reminders, deterministic capture, CLI checkout
fallbacks, and doctor checks for missing capture. This was not cosmetic. It
addressed a real failure mode observed during development: after resume,
compaction, or tool reload, agents could stop using Zaxy unless the memory
contract was visible and fail-closed.

### 4.5 Observability Without Control-Plane Coupling

Pathlight is observability, not storage. Zaxy 1.1.2 fixed a class of failures
where an unavailable Pathlight collector could block MCP startup. The corrected
contract is that tracing degrades to no-op when the collector is down. Memory
operations must not depend on optional observability infrastructure.

## 5. Applied Engineering Lessons

### 5.1 Event-Sourced Memory Made Bugs Recoverable

The most important engineering choice was making Eventloom the source of truth.
When projection bugs appeared, the fix was not to repair graph rows by hand. It
was to change extraction/projection code and replay. This kept mistakes
auditable and made backend experiments possible without changing the memory
semantics.

### 5.2 Lexical Retrieval Was a Breakthrough, Not a Baseline Detail

An early LongMemEval smoke run showed that vector-only and markdown-vector
paths could miss obvious identity matches. Adding reciprocal-rank fusion and
BM25 lexical candidates raised the 20-question smoke path so Zaxy matched BM25
at 0.800 identity recall@5 and 0.700 mean score. This was a reminder that
"semantic" retrieval is not automatically better for memory. Names, dates,
numbers, and exact phrases are often the highest-signal features.

### 5.3 Citations Became a Product Constraint

Once citations were required, many easy fixes were disallowed. A summary that
looks right but cannot point back to an Eventloom event is not trustworthy
memory. This forced source-aware graph projection, verbatim retrieval lanes,
file-line citations for documents, source nodes, `CITES_SOURCE` edges, and
checkout diagnostics that warn on uncited context.

### 5.4 The Retrieval Plateau Was Real

The publish 20260607 LongMemEval-compatible run hit Recall@5 1.000, Recall@10 1.000,
and citation coverage 1.000 within Zaxy's event-sourced checkout adaptation.
The remaining 47 misses were `synthesis_miss`, not retrieval misses. This
changed the roadmap. Adding more retrievers would mostly increase prompt load
unless synthesis improved. The next layer had to be a typed synthesis ledger:
answer type, evidence requirements, normalized values, units, support groups,
exclusions, answer candidates, and proof packets.

### 5.5 Authority Metadata Beat Raw Association

The neuron-astrocyte associative memory direction was intellectually attractive.
StateRecoveryBench made it falsifiable. Raw associative projection reached
state accuracy 1.000 but stale rejection 0.485 and distractor resistance 0.212.
Authority-resolved associative projection kept state accuracy 1.000 while
raising minimal evidence recall to 0.985, stale rejection to 1.000, distractor
resistance to 0.909, and abstention accuracy to 1.000. The lesson was sharp:
association finds neighborhoods; authority resolves state.

### 5.6 Coordination Needed a New Benchmark

LongMemEval was not enough for coordinated agent memory. It evaluates long-term
interactive recall, but not whether worker-local findings remain separate from
accepted parent mission state. Zaxy therefore introduced CoordinationBench and
StateRecoveryBench. This was a methodological breakthrough: once the product
thesis moved beyond single-agent recall, the benchmark had to move too.

### 5.7 Purpose Is Part of Memory

The same fact should not always be ranked or trusted the same way. A security
review, release validation, coding task, legal response, and coordination
handoff need different evidence policies. Purpose profiles became the
retrieval-time ontology: they condition scoring, suppression, retention,
answerability, and diagnostics. PurposeBench's full-lane pass supports the
claim that memory quality is action-conditioned, not merely query-conditioned.

## 6. Empirical Results

Internal metrics in this section are same-harness Zaxy artifacts unless
explicitly marked as external evidence or article-relative disclosure. The
LongMemEval-compatible numbers evaluate Zaxy's event-sourced memory checkout
adaptation, not official LongMemEval end-to-end assistant accuracy.

### 6.1 LongMemEval-Compatible Publish Run

The current public Zaxy headline is the publish 20260607 full 500-question
LongMemEval-compatible checkout run.

Protocol boundary. The cleaned LongMemEval-compatible dataset is transformed
into Eventloom-backed memory events and queried through Zaxy's checkout
protocol. The report measures whether the memory fabric retrieves and cites
answer-bearing identities and answer surfaces. It does not replay the official
LongMemEval assistant-interaction protocol, and should not be compared directly
to published LongMemEval end-to-end answer accuracy. In this paper, "publish
20260607" is the frozen report label for the 2026-06-07 full 500-question
checkout run, not a separate benchmark version.

| Metric | Value |
| --- | ---: |
| Cases | 500 |
| Event count | 5,372 |
| Sessions | 948 |
| Subjects | 500 |
| Embedding provider | `hash:1536` |
| Projection backend | embedded Kuzu |
| Mean score | 0.956 |
| Answer@1 | 0.714 |
| Answer@5 | 0.910 |
| Answer@10 | 0.950 |
| Citation coverage | 1.000 |
| Recall@1 | 0.960 |
| Recall@5 | 1.000 |
| Recall@10 | 1.000 |
| Mean identity recall | 0.980 |
| Mean latency | 991.62 ms |
| p50 latency | 881.01 ms |
| p95 latency | 1,966.65 ms |
| p99 latency | 2,495.07 ms |
| Mean approximate tokens | 10,192.11 |
| Miss taxonomy | 45 `synthesis_miss` |

Category summaries show the remaining weak areas are not uniform. Multi-session
queries had mean score 0.9023 and Answer@5 0.8421; knowledge-update queries
had mean score 0.9359 and Answer@5 0.9231; temporal reasoning had mean score
0.9474 and Answer@5 0.9098. All categories retained citation coverage 1.000
and Recall@5 1.000.

Interpretation: within this adapted memory-checkout protocol, Zaxy's evidence
retrieval and citation machinery cleared the top-k recall requirement. The
bottleneck moved to answer synthesis: ordering, arithmetic, temporal interval
composition, direct answer promotion, and answer surface placement.

### 6.2 StateRecoveryBench

StateRecoveryBench evaluates partial-cue accepted-state recovery under stale
rows, authority-shaped distractors, incomplete bridge evidence, and no-safe
answer cases. The official 33-case report uses workload fingerprint
`916201f70da9d058aee80a31f8cf59d92dad59f5fd645f3dfbd3a1b23e7dddad`.

| Baseline | State accuracy | Minimal evidence recall | Stale rejection | Distractor resistance | Abstention accuracy | Citation coverage |
| --- | ---: | ---: | ---: | ---: | ---: | ---: |
| memory_fabric_checkout | 0.818 | 0.909 | 1.000 | 0.818 | 1.000 | 1.000 |
| associative_projection | 1.000 | 0.803 | 0.485 | 0.212 | 0.848 | 1.000 |
| authority_resolved_associative | 1.000 | 0.985 | 1.000 | 0.909 | 1.000 | 1.000 |
| direct_lexical | 0.697 | 0.606 | 0.394 | 0.121 | 0.848 | 1.000 |
| graph_traversal | 0.818 | 0.742 | 0.515 | 0.061 | 0.848 | 1.000 |
| hash_vector | 0.697 | 0.606 | 0.394 | 0.121 | 0.848 | 1.000 |

Interpretation: raw association is strong at latent state recall and poor at
authority. The production MemoryFabric checkout path is slower than diagnostic
baselines but meets the release guardrails with full citation coverage. The
research path is to combine broad associative proposal with explicit
authority-resolved checkout, not to replace the event-sourced substrate.

### 6.3 CoordinationBench

CoordinationBench evaluates multi-agent mission memory: accepted findings,
conflicts, duplicate consolidation, stale claim rejection, citations, parent
checkout answerability, purpose feedback, and replayability. In the
coordination-real-v1 report, flat and lexical baselines could retrieve evidence
but failed the coordination semantics.

| Baseline | Accepted precision | Accepted recall | Evidence coverage | Citation coverage | Replayable | Accepted-state synthesis |
| --- | ---: | ---: | ---: | ---: | --- | ---: |
| markdown_notes | 0.636 | 1.000 | 0.909 | 0.000 | false | 0.000 |
| flat_transcript | 0.273 | 0.600 | 0.909 | 0.000 | true | 0.000 |
| bm25_worker_logs | 0.667 | 0.200 | 1.000 | 0.000 | false | 0.000 |

Interpretation: text retrieval can find claims, but it does not know whether
the parent mission accepted them. Coordination requires a memory model with
worker-local state, review events, promotions, proof packets, and accepted
checkout boundaries.

### 6.4 PurposeBench

PurposeBench evaluates whether purpose profiles apply recall floors,
ontology-specific evidence terms, consequence retention, governed forgetting,
evidence-policy discipline, forbidden-overclaim rejection, and citation
coverage. The tracked purpose-v1 report shows 10 lanes passed and citation
coverage 1.000 in the public-derived holdout metadata. Competitor claims remain
blocked until same-harness adapters exist.

Interpretation: purpose is not metadata decoration. It changes what memory rows
are eligible as current facts, which evidence is required, and which risks must
be surfaced.

### 6.5 Harvey LAB External Legal-Agent Memory Ablation

The Harvey LAB memory-ablation result is the strongest external downstream
validation artifact currently in the repository. It is separate from
LongMemEval: Harvey LAB evaluates legal-agent work products with rubric-based
judging, and the public metric is mean criterion pass rate rather than binary
task all-pass success.

The run used the external Harvey checkout at commit
`29748828133dff83ad2263af353fb035504f8f77`, `gpt-5.5` as generator,
`gpt-5.4-mini` as judge, generator reasoning effort `low`, and temperature
0.000. Zaxy completed all 10 pinned article tasks through Harvey's harness and
judge. The report reloaded 10 Zaxy normalized-result artifacts, checked that
judge score artifacts matched normalized scores, checked memory-call metrics,
and verified that transcripts contained memory-tool evidence.

| System | Tasks | Mean criterion pass rate | Delta vs regular/no-memory | Delta vs article best | Wins vs article best |
| --- | ---: | ---: | ---: | ---: | ---: |
| Zaxy | 10 | 0.788 | +0.184 | +0.081 | 9 |

Runtime and memory-use evidence from the same report:

| Mean total seconds | Total tokens | Memory search calls | Memory read calls |
| ---: | ---: | ---: | ---: |
| 138.786 | 5,951,174 | 30 | 10 |

Task-level results show one loss and nine article-best wins:

| Task | Regular | Article best | Zaxy | Delta vs best |
| --- | ---: | --- | ---: | ---: |
| FTC noncompete | 0.807 | Graphiti 0.790 | 0.895 | +0.105 |
| Change-of-control | 0.667 | GBrain keyword 0.737 | 0.860 | +0.123 |
| Acquisition diligence | 0.469 | raw-rg 0.641 | 0.797 | +0.156 |
| Data-room red flags | 0.520 | LightRAG 0.600 | 0.660 | +0.060 |
| Privacy program | 0.532 | ActiveGraph 0.661 | 0.790 | +0.129 |
| Litigation timeline | 0.652 | GBrain keyword 0.758 | 0.894 | +0.136 |
| Relevance / privilege | 0.701 | GBrain keyword 0.791 | 0.687 | -0.104 |
| Attorney production review | 0.583 | GBrain Gemma / LightRAG 0.708 | 0.750 | +0.042 |
| Privilege log | 0.402 | GBrain keyword 0.598 | 0.634 | +0.036 |
| Subpoena comparison | 0.702 | raw-rg 0.790 | 0.912 | +0.122 |

Interpretation. Harvey LAB gives Zaxy an external, legal-domain, work-product
validation signal. It does not eliminate the need for same-process external
adapters across memory systems, because the article-best and framework rows are
published external disclosures rather than Zaxy-controlled reruns of every
competitor. It does, however, address the reviewer's concern that the paper had
only internal benchmarks: Zaxy has now run through a third-party task suite with
audited artifacts and article-relative baselines.

### 6.6 Release and Quality Gates

As of the 1.1.2 release, the local release gate passed with 2,403 tests, 1
skipped test, 11 deselected tests, and 92.18% coverage. The PR and post-merge
GitHub CI passed lint, integration, package, and Python 3.11/3.12/3.13 jobs.
The PyPI publish workflow succeeded and `zaxy-memory 1.1.2` became the latest
published package.

## 7. Pitfalls, Plateaus, and Breakthroughs

### Pitfall: Treating Memory as Search

Search returns candidates. Memory returns state. The difference appears when a
retrieved row is stale, contradicted, pending, rejected, worker-local, or
uncited. Zaxy repeatedly found that retrieval-only improvements could raise
recall while lowering trust.

### Pitfall: Benchmark-Specific Narrow Fixes

During LongMemEval development, the temptation was to add narrow patterns for
missed answer strings. The sustainable fixes were classes of issue:
query-bound arithmetic, latest-state promotion, structured scalar scoring,
direct boolean evidence, aggregate answer priority, and gated relative temporal
anchors. Each class had to preserve citation coverage and Recall@5.

### Pitfall: Projection as Source of Truth

Graph stores are operationally convenient, but if the graph becomes the source
of truth, bugs become history. Zaxy's replay discipline prevented that. The
graph can be rebuilt; Eventloom cannot be silently rewritten.

### Pitfall: Optional Infrastructure Blocking Core Memory

The 1.1.2 Pathlight fix is a small but important example. Observability should
not block memory operations. Optional layers must fail open or degrade visibly,
not become hidden dependencies of the control path.

### Plateau: Retrieval Saturation

The publish 20260607 plateau is the clearest empirical result. Once Recall@5 and
citation coverage reached 1.000, further broad retrieval would mostly increase
the cognitive load on the model. The work shifted to structured synthesis.

### Plateau: LongMemEval Did Not Measure Coordination

LongMemEval was valuable, but it could not tell whether a worker finding was
accepted by a parent coordinator. This led to CoordinationBench and
StateRecoveryBench. The broader lesson is that benchmarks must match the
architecture claim. If the claim is coordinated agent memory, single-agent
recall is necessary but not sufficient.

### Breakthrough: Memory Checkout

Memory Checkout turned memory from a backend query into a model-facing
contract. It tells the model what to trust, what to ignore, what is cited, what
is stale, what requires refresh, and what answer candidates exist. This is the
main abstraction that made the system usable by agents rather than only by
humans.

### Breakthrough: Authority-Resolved Association

The astrocyte-inspired branch did not justify adding a heavy neural layer to
core. It did produce a better insight: broad association is useful for proposal,
but accepted memory requires authority resolution. This is likely a general
principle for agent memory systems.

### Breakthrough: Activation Persistence

An agent memory product fails if the agent stops using it after resume. Zaxy's
activation work made memory use visible and checkable through bootstrap,
checkout, AGENTS.md instructions, capture status, doctor warnings, and CLI
fallbacks. This is an applied systems lesson more than an algorithmic one:
memory must be operationally attached to the agent lifecycle.

## 8. Design Principles Learned

1. Use immutable events as the memory substrate.
2. Treat graph, vector, lexical, and summary layers as projections.
3. Preserve citations at every boundary.
4. Separate recall from authority.
5. Separate retrieval from synthesis.
6. Make purpose part of retrieval policy.
7. Prefer typed deterministic extraction for known events.
8. Keep degraded modes visible.
9. Benchmark the claim you are actually making.
10. Do not add complexity merely because a research direction is elegant.

## 9. Future Research Directions

### 9.1 Structured Synthesis Working Memory

The highest-priority research direction is a typed synthesis ledger. The ledger
should represent answer type, evidence requirements, normalized values, units,
source groups, include/exclude reasons, candidate answer surfaces, and support
packets. Operations such as count, sum, difference, average, argmax, absence,
temporal interval, and graph path explanation should be pure functions over
ledger rows.

This directly targets the publish 20260607 miss taxonomy: 45 synthesis misses with no
retrieval-miss class.

### 9.2 Two-Phase Evidence Assembly

Current top-k retrieval and final prompt assembly are too tightly coupled.
Future checkout should overfetch candidates, then build a smaller evidence
packet according to the synthesis plan. Candidate recall and evidence assembly
quality should be measured separately.

### 9.3 Late Interaction and Local Reranking

ColBERT-style late interaction is promising for source recall and answer-item
selection. Zaxy should keep deterministic local defaults, but support optional
late-interaction rerankers through the existing reranker interface.

### 9.4 Authority-Resolved Associative Projection

The StateRecoveryBench result suggests a future hybrid:

1. associative propagation proposes latent state neighborhoods;
2. authority metadata filters stale, rejected, unsupported, and worker-local
   rows;
3. Memory Checkout returns cited accepted state and diagnostics.

This is a better research target than importing a full neuron-astrocyte model
into core prematurely.

### 9.5 Better Benchmarks for Agent Teams

CoordinationBench should expand beyond accepted-state recovery into real team
behaviors: duplicate work avoidance, conflict arbitration, stale handoff
recovery, reviewer latency, cross-agent proof transfer, and failure-driven
learning. LongMemEval-style recall remains useful, but team memory needs team
benchmarks. The current StateRecoveryBench, CoordinationBench, and PurposeBench
workloads are committed as reproducibility artifacts; the next step is external
critique, larger hidden splits, and adapter-ready runner definitions.

### 9.6 Memory Activation and Lifecycle Reliability

The agent lifecycle remains a product and research challenge. Future work
should make checkout/capture/feedback default across Codex, Claude Code,
Cursor, LangGraph, CrewAI, and other runtimes even after resume, compaction,
tool reload, or client update. Memory should not depend on the model remembering
to use memory.

### 9.7 Backend Portability Without Semantic Drift

Embedded Kuzu reduced sidecar friction while preserving graph-native semantics.
pgGraph, LatticeDB, Neo4j, and other backends remain useful, but each must pass
the same projection, temporal, citation, traversal, dashboard, rebuild, and
benchmark gates before becoming default.

### 9.8 External Same-Harness Validation

Zaxy now has Harvey LAB external work-product evidence, but the broader
scientific step remains same-process competitor adapters for systems such as
MemPalace, Mem0, Agent Memory, Graphiti/Zep, and A-MEM-style systems. The
Harvey article-relative rows should remain disclosures unless those systems are
rerun through a common adapter protocol with pinned commits, model settings,
judges, and artifact validation.

## 10. Limitations

Zaxy is heavier than markdown and heavier than a standalone vector database.
The architecture pays for provenance, replay, temporal validity, graph
traversal, and coordination semantics. For casual preference memory, this may
be unnecessary.

The current headline LongMemEval-compatible run uses deterministic local hash
embeddings and a cleaned workload transformed into Eventloom memory events. It
is a strong internal same-harness Zaxy result, not an official LongMemEval
assistant-interaction score and not a universal claim against every external
memory system. Competitor disclosures must remain separate until adapters run
under the same protocol.

The Harvey LAB result is external and downstream, but it is also
article-relative: Zaxy rows were generated through the Harvey harness, while
most non-Zaxy rows are published article disclosures or Harvey-native
comparison artifacts rather than Zaxy-controlled reruns of every framework.

The current synthesis layer is still evolving. Retrieval and citation are
strong, but answer composition remains the main benchmark miss class.

StateRecoveryBench, CoordinationBench, and PurposeBench are project-defined
benchmarks. Their definitions and artifacts are committed, which helps
reproducibility, but they still require external scrutiny, broader workloads,
and hidden or independently generated splits before they can serve as community
standards.

The associative-memory branch is experimental. It shows promise as a proposal
mechanism, but core Zaxy should not absorb heavier learned memory machinery
until a benchmark demonstrates a class of failures that event-sourced
authority/provenance cannot solve.

## 11. Conclusion

The development of Zaxy supports a specific theory of agent memory:

> Durable agent memory is not the largest possible prompt. It is a replayable,
> cited, temporal state fabric that can project the right working set for the
> current purpose.

The strongest evidence is not a single benchmark number, but the pattern across
benchmarks and failures. Within Zaxy's adapted checkout protocol,
LongMemEval-compatible retrieval reached Recall@5 1.000 with citation coverage
1.000, revealing synthesis as the next bottleneck. Harvey LAB added an external
legal-agent work-product signal while preserving the need for pinned,
same-process adapters before making framework-wide leaderboard claims.
StateRecoveryBench showed that association without authority is unsafe.
CoordinationBench showed that text retrieval without accepted-state semantics
cannot support agent teams. PurposeBench showed that memory quality depends on
the action being taken.

Zaxy's architecture therefore converged on Eventloom as the immutable source,
temporal graph projections as derived reasoning views, hybrid retrieval as a
candidate generator, Memory Checkout as the model-facing trust contract, and
purpose/authority policies as the guardrails that make shared agent memory
usable.

The next frontier is not merely better retrieval. It is synthesis working
memory: typed, cited, compact, auditable answer construction over already
retrieved evidence.

## References

Internal Zaxy artifacts:

- Zaxy architecture: `docs/architecture.md`.
- Zaxy retrieval design and benchmark interpretation: `docs/retrieval.md`.
- Zaxy benchmark hub and publish 20260607 report: `docs/benchmarks.md`.
- Publish 20260607 LongMemEval-compatible report:
  `reports/benchmarks/longmemeval-500-publish-20260607/live-benchmark.json`.
- StateRecoveryBench report:
  `reports/benchmarks/state-recovery-v1/state-recovery-benchmark.json`.
- CoordinationBench report:
  `reports/benchmarks/coordination-real-v1/coordination-benchmark.json`.
- PurposeBench report:
  `reports/benchmarks/purpose-v1/purpose-benchmark.json`.
- Harvey LAB external legal-agent report:
  `reports/benchmarks/harvey-lab-memory-ablation/harvey-lab-benchmark.json`.
- Harvey LAB publishable statistics:
  `reports/benchmarks/harvey-lab-memory-ablation/publishable-statistics.md`.
- Eventloom contract: `docs/eventloom.md`.
- Synthesis research note: `docs/archive/synthesis-context-research.md`.
- Experimental associative memory note: `docs/archive/experimental-associative-memory.md`.
- Competitive positioning: `docs/archive/competitive-positioning.md`.
- Release history and version context: `CHANGELOG.md`.

External references:

- Martin Fowler, "Event Sourcing", 2005:
  <https://www.martinfowler.com/eaaDev/EventSourcing.html>.
- Microsoft Azure Architecture Center, "Event Sourcing Pattern":
  <https://learn.microsoft.com/en-us/azure/architecture/patterns/event-sourcing>.
- Lewis et al., "Retrieval-Augmented Generation for Knowledge-Intensive NLP
  Tasks", 2020: <https://arxiv.org/abs/2005.11401>.
- Robertson and Zaragoza, "The Probabilistic Relevance Framework: BM25 and
  Beyond", 2009: <https://doi.org/10.1561/1500000019>.
- Carbonell and Goldstein, "The Use of MMR, Diversity-Based Reranking for
  Reordering Documents and Producing Summaries", SIGIR 1998:
  <https://doi.org/10.1145/290941.291025>. See also the TIPSTER workshop
  version in ACL Anthology: <https://aclanthology.org/X98-1025/>.
- Liu et al., "Lost in the Middle: How Language Models Use Long Contexts",
  2023: <https://arxiv.org/abs/2307.03172>.
- Edge et al., "From Local to Global: A Graph RAG Approach to Query-Focused
  Summarization", 2024: <https://arxiv.org/abs/2404.16130>.
- Asai et al., "Self-RAG: Learning to Retrieve, Generate, and Critique through
  Self-Reflection", 2023: <https://openreview.net/forum?id=hSyW5go0v8>.
- Khattab and Zaharia, "ColBERT: Efficient and Effective Passage Search via
  Contextualized Late Interaction over BERT", 2020:
  <https://arxiv.org/abs/2004.12832>.
- Gao et al., "Precise Zero-Shot Dense Retrieval without Relevance Labels",
  2022: <https://arxiv.org/abs/2212.10496>.
- Packer et al., "MemGPT: Towards LLMs as Operating Systems", 2023:
  <https://arxiv.org/abs/2310.08560>.
- Wu et al., "LongMemEval: Benchmarking Chat Assistants on Long-Term
  Interactive Memory", 2024: <https://arxiv.org/abs/2410.10813>.
- Xu et al., "A-MEM: Agentic Memory for LLM Agents", 2025:
  <https://arxiv.org/abs/2502.12110>.
- Ramsauer et al., "Hopfield Networks is All You Need", 2020:
  <https://arxiv.org/abs/2008.02217>.
- Kozachkov, Slotine, and Krotov, "Neuron-Astrocyte Associative Memory", 2024:
  <https://arxiv.org/abs/2311.08135>.
- Harvey LAB memory retrieval ablation repository:
  <https://github.com/rushilchugh01/harvey-labs-ablations-and-benchmarks>.
- Chugh, "What Agent Memory Actually Fixes in Legal Workflows", 2026:
  <https://rushilchugh.substack.com/p/what-agent-memory-actually-fixes>.
- Model Context Protocol specification, version 2025-03-26:
  <https://modelcontextprotocol.io/specification/2025-03-26/basic/index>.
