Git for LLM memory

Temporal memory for AI agents.

Zaxy turns agent work into durable memory: an Eventloom log for audit, hash-linked provenance for replay, a Neo4j temporal graph for reasoning, Memory Checkout for compact context, and MCP tools for model-facing retrieval, capture, and feedback.

Install locally Read the docs Pathlight integration
agent-memory-run
01Eventloom logappend-only JSONL + hash chain
02Hybrid extractiontyped rules + fallback extractors
03Neo4j temporal graphNEXT_EVENT / PREVIOUS_EVENT provenance
04Memory Checkoutactive working set + cited context
05MCP responsecapabilities, checkout, capture, feedback
Zaxy temporal knowledge graph showing connected agent memory entities and relationships
696 tests >=91.89% coverage ruff clean mypy clean release gate ready

Why Zaxy

Vector memory is useful, but it is not a source of truth.

Markdown files and chunk RAG flatten history. They can retrieve similar text, but they do not preserve causal chains, fact lifetimes, invalidations, or the evidence that led an agent to a decision. Zaxy keeps the raw event stream, seals it with hashes, and projects it into a graph built for multi-hop, temporal, and provenance-aware reasoning.

Relational

Entities and edges preserve actor, task, dependency, and provenance relationships.

Temporal

Facts are versioned, so retrieval can ask what was true now or at a previous point.

Replayable

The Eventloom log remains the immutable record behind every graph projection and checkout.

Architecture

One memory fabric, five layers.

Eventloomappend, verify, replay
Extractentities, edges, embeddings
Neo4jtemporal graph + provenance path
Checkoutbounded cited context
MCPagent-native tools

Pathlight traces memory operations without becoming the storage layer. Neo4j answers graph questions. Eventloom remains the audit trail. The graph projects sealed Eventloom paths through NEXT_EVENT and PREVIOUS_EVENT edges. MCP gives agent frameworks a stable interface over stdio or SSE.

MCP tools

Memory operations agents can call directly.

memory_capabilities

Tell the model what Zaxy can do, what capture paths are healthy, and when to checkout memory.

memory_checkout

Return the current cited prompt state, active working set, provenance, Checkout diagnostics, and warnings.

memory_append

Append typed events, extract graph facts, and trace the operation.

memory_query

Fuse exact lookup, keyword search, vector similarity, and traversal.

memory_replay

Rebuild session history from Eventloom, optionally from a sequence number.

memory_invalidate

Close graph fact validity windows without deleting historical evidence.

Model-facing checkout contract

Models consume answerability, required_action, current_citation_count, and feedback payloads directly. A checkout without current citations or with warnings tells the model to refresh memory or ask the user instead of guessing from stale context. The canonical fixture lives at docs/examples/memory-checkout-contract.json. 

{
  "quality": {
    "answerability": "answer_from_memory",
    "confidence": 0.75,
    "required_action": null
  },
  "diagnostics": {
    "current_citation_count": 1,
    "warning_count": 0
  },
  "guidance": {
    "feedback": {
      "tool": "memory_feedback",
      "payloads": [{"feedback": "used"}]
    }
  }
}

Retrieval

Hybrid search for agent context.

Zaxy routes queries through exact entity lookup, Neo4j full-text search, vector similarity, graph traversal, and verbatim Eventloom retrieval. Memory Checkout turns those lanes into compact cited context so agents receive connected facts instead of raw transcript piles. Checkout diagnostics show source lane mix, citation coverage, excluded superseded context, and feedback guidance. Temporal filters let callers retrieve only facts valid at a point in time.

Deterministic capture

Useful by default, explicit when packet capture costs money.

local-codex

The Codex preset renders the official MCP install command, writes local session JSONL capture config, and supports a managed zaxy capture start watcher.

Observer hooks

Stable hook sinks record lifecycle, command, file-edit, tool-call, and transcript observations when the client supports them.

Packet analyzer

Provider packet capture remains opt-in for diagnostics and high-fidelity audit because it can consume API quota.

Production posture

Built for auditable local-first deployments.

Secret files

Docker/Kubernetes-style *_FILE config keeps production secrets out of plaintext env files.

Remote MCP auth

SSE requests require bearer auth and are scoped by per-client session headers.

TLS-ready Neo4j

Production compose and certificate scripts support encrypted Bolt connections.

Representative context benchmark

Zaxy wins on a 650-query suite across memory, docs, transcripts, and mixed context.

This is not a universal benchmark against every markdown or vector RAG implementation. It is a paired OpenAI embedding evaluation over a generated suite with current facts, historical facts, graph traversal, cited documents, session transcripts, and mixed cross-lane context.

1.000

Mean Zaxy score with OpenAI text-embedding-3-small on the suite-v1 workload: 850 events and 650 paired queries.

+0.480

Mean score delta versus markdown+vector and vector baselines; paired randomization p-value was 0.0001.

404 tokens

Approximate returned context for Zaxy, versus 960 tokens for vector and markdown+vector on the same workload.

Read the full benchmark report ยท Read the academic review

Install

Run Zaxy locally, then expose memory through MCP.

pip install zaxy-memory
./scripts/setup.sh
docker compose up -d
zaxy status
pip install -e ".[dev]"
zaxy serve
zaxy serve --transport sse --port 8080
scripts/release-check.sh --root .

Documentation

Full operator and integrator documentation.

Getting started Architecture Configuration MCP interface MCP install targets Eventloom contract Agent events Hook protocol Codebase mapping Graph schema Retrieval Embeddings Security Operations Deployment Testing Benchmark review Consolidation Python API