Home

title: Artesian — Memory Control Plane description: An open, portable, governed memory control plane for AI agents. OCF is the open format. hide: - navigation - toc

An open, portable, governed memory control plane for AI agents.

OCF is the open format. Nothing is lost.

Get started GitHub

Install¶

HomebrewFrom sourceMCP drop-in

brew install aquifer-labs/tap/artesian

cargo install --git https://github.com/aquifer-labs/artesian artesian-cli
artesian init --backend sqlite-vec   # zero infrastructure

Add to claude_desktop_config.json or your MCP settings:

{
  "artesian-memory": {
    "command": "artesian-mcp",
    "args": ["--config", "artesian.toml"]
  }
}

artesian init writes the config. Works with Claude Code, Codex, opencode, and any MCP client.

Three differentiators¶

OCF governed committed-state

Every memory write passes through a qualify-gate — drift, novelty, and relevance checks before it enters the Committed Context State (CCS). Evictions and compactions are recorded in the OCF qualify trail; forgetting is as auditable as remembering.

Governance & qualify trail
Multi-writer + cross-agent handoff

Transactional multi-writer with per-scope isolation and optimistic CAS — no silent corruption under concurrent writes. A portable working-context kit lets any agent (Claude Code, Codex, Gemini, opencode) pick up exactly where another left off.

Concurrency model
Tiny binary · zero cloud · local embeddings

A single static Rust binary (~29 MB, stripped). E5-small embeddings run entirely in-process — no GPU, no network, no token cost to embed. Backends: sqlite-vec (zero infra), Qdrant, pgvector, or plain files.

Why Rust

How it works¶

recall candidates (from durable memory)
        │
        ▼  qualify-gate: drift / novelty / relevance
┌───────────────────────────────────────┐
│   Committed Context State (bounded)   │  ← what the agent sees
│   ┌───────────────────────────────┐   │
│   │ decision:  chose Rust+tokio   │   │
│   │ plan:      shard the embedder │   │
│   │ blocker:   GPU quota at limit │   │
│   └───────────────────────────────┘   │
└───────────────────────────────────────┘
        │ evict / compress under saturation
        ▼
durable memory (sqlite-vec / Qdrant / pgvector / files)
        ↑ anchor + targeted recall on any compaction

Artesian implements the ACC model (Bousetouane, arXiv:2601.11653): a control loop that separates the recall channel (read from any retrieval store) from the commit channel (what enters the bounded, schema-governed CCS). The qualify-gate sits between them.

Full architecture · Why Artesian?

Governance — nothing is lost¶

:material-shield-check: Qualify trail

Every commit, eviction, drift decision, and dream-on-compact run writes a signed entry to the OCF qualify trail (qualify.jsonl). The agent's memory history is a complete audit log — you can replay or verify any past state.

Read the governance page →

:material-open-source-initiative: Open format: OCF

The Open Committed-state Format (OCF) is the portable, schema-governed exchange format underlying Artesian's kit export, session handoff, and qualify trail. It is defined as an open spec so any tool can read, write, and verify Artesian memory.

OCF spec on GitHub →

Comparison¶

	Artesian	mem0	LangMem	plain markdown
What it is	ACC control plane + memory	Managed memory API	LangGraph memory layer	Files + prompting
Self-hosted, zero infra	✓ sqlite-vec or files	Cloud-first	Requires LangGraph	✓
No per-write LLM call	✓	✗	✗	✓
ACC qualify-gate	✓ drift/novelty/relevance	✗	✗	✗
Compaction survival	✓ anchor + recall	✗	✗	✗
Multi-writer, isolated	✓ optimistic CAS	partial	partial	✗
Agentic eval harness	✓ ships in repo	✗	✗	✗
Open format (OCF)	✓	✗	✗	✗

Composable by design¶

Artesian is built like LEGO — use only the pieces you need:

Layer	Crate	When to use
Memory + qualify-gate	`aquifer` + `headgate`	You want ACC control over any vector store
Task tracking	`headrace`	DAG-based task board, no orchestration needed
Agent teams	`flume`	Multi-agent with shared memory and handoff
Eval harness	`gauge`	Measure recall quality and memory-guides-action
MCP server	`artesian-mcp`	Drop-in for Claude Code, Codex, opencode
Full stack	`artesian-cli`	`artesian init`, `loop`, `kit`, `tokens`, `task`

Full composability guide

Benchmarks¶

Memory / history	Full-context replay	Artesian	Saving	Retrieved
~13k tokens (180 docs)	12,902	876 tokens	93%	100%
~119k tokens (1,600 docs)	118,566	974 tokens	99.2%	100%
~478k tokens (6,400 docs)	477,740	992 tokens	99.8%	100%
~1M tokens (14,000 docs)	1,046,431	1,046 tokens	99.9%	100%

Reproduce: just bench-check — fails if committed results differ.

Benchmark	Score	Method
LoCoMo	0.475	vector + BGE reranking
LongMemEval (oracle)	0.70	vector retrieval

Full benchmark methodology

Apache-2.0 · Aquifer Labs · OCF spec