Relicquary is a local-first memory OS for AI agents: typed memory, a knowledge graph, and explainable recall, plus the working loop an agent runs on. One Rust binary, your own disk, a receipt for every write.
A reliquary is a vessel built to keep what must not be lost; Relicquary is that vessel for an agent's memory. The store is plain files you own, and the model is yours: keep it fully local on your own machine, or connect your own provider account. One honest note on durability: a first-class backup and restore path is designed, not yet built; today durability is the plain files themselves, which you can copy and version like any others.
A SQLite database plus human-readable Markdown relics, sitting in a folder on your disk. Open them, grep them, version them, and work offline. You own the store.
~/.relicquary/mystoreRelicquary runs the working loop, and it makes sessions continuous: session_start recovers stranded work and context_pack briefs an agent in one call, so a fresh session resumes where the last one stopped.
Every write is untrusted by default and produces a receipt: an append-only record you can read as a file. The store stays on your own disk, and nothing phones home.
receipts · trust tiersRetrieval, reranking, and the store itself run on-device. No connection, no degradation of what you own.
Every memory mirrors to a Markdown relic you can open in any editor, grep, or commit to git. No opaque service between you and your record.
Four stages, all on-device. The agent gets ranked results it can act on, and a reason for each one.
Exact-term matching over the full store catches names, IDs, and precise phrasing.
On-device vector search surfaces meaning, even when the words don't match.
Fused scores are reranked with connected-evidence and temporal-currentness signals.
Each result ships with a score, a currentness label, and a why-it-ranked breakdown.
Decision: Ship Relicquary local-first, SQLite + Markdown on the operator's own disk.
current, stale, or superseded, so an agent never acts on a decision that's already been overruled. Ask in natural language; get back ranked, dated, explainable memory.
For developers and teams running MCP-capable agents (coding agents, research agents, autonomous operators) that have to pick up where they left off. Before Relicquary, every session starts from zero: the agent re-derives what it already knew, asks the same questions, and repeats mistakes it has no record of making. After, it recalls a durable, typed, receipted record of what was decided and why, cites where each piece came from, and builds on it across restarts, sessions, and tools.
The architecture call you made last week (local-first, passkeys over passwords, this library not that one) is still there next session, with the reasoning and the trail attached. The agent stops relitigating settled choices and stops reintroducing bugs you already fixed.
Long-running research and autonomous operators write findings into a typed knowledge graph (facts, entities, and the edges between them) instead of a transcript that scrolls away. Each run adds to the last, and contradictions surface instead of quietly overwriting what was true.
The store is SQLite and Markdown on your own disk, and every write carries a receipt. A teammate, or a different tool, can open the same record, see where each entry came from, and trust it, because nothing landed without provenance. The memory is yours to read, move, and keep.
Memory is typed, linked, and explainable, and Relicquary orchestrates the working loop on top of it, so an agent can find the right thing, prove why it surfaced, and act on it.
Relicquary runs the loop an agent works out of: recall what matters, decide what's next, synthesize, hand off, keep a session moving. The orchestration is first-class, and that loop has driven live agent sessions end to end. RUN 2026-06 · build-repair ↗
Fourteen kinds of memory object, each carrying tags, confidence, provenance, and a trust tier. No undifferentiated text blobs; every entry knows what it is.
Typed edges link memories into a graph (supersedes, depends_on, conflicts_with, blocks, mentions) with automatic conflict detection so stale beliefs get flagged.
Lexical BM25 fused with on-device semantic embeddings, then reranked. Results carry currentness labels and a per-result "why it ranked" breakdown, not raw text dumps.
Every mutation is recorded as an append-only receipt you can audit as a file. Approve, supersede, or forget: the history of how memory changed is always there. REL 2026-06-10 · v0.9.0 gate ↗
Agents speak the Model Context Protocol; you run relicquary remember, relicquary recall, and relicquary mcp-server from your terminal. One source of truth, no SDK lock-in, no SaaS daemon.
Relicquary is MCP-first: not a library you wrap, a surface an agent talks to directly. One of the 57 returns the whole system: architecture hands an agent the reconstruction-grade spec in a single call, so it operates from understanding instead of guessing.
Agent memory is a crowded shelf. Most of it is a cloud service that holds your store, or a vector index that hands back a blob of text and calls it recall. Relicquary takes a different shape: a single binary on your own disk, memory that knows what it is, recall you can defend, and the loop your agent actually runs on. Here's where the line falls.
Unlike hosted memory services that keep your agent's knowledge in someone else's cloud, Relicquary is a single binary writing SQLite and Markdown to a folder on your own disk. No hosted service, no telemetry, nothing phoning home. The store is yours to open, grep, version, and back up, and it works offline.
Unlike a raw vector store that returns the nearest chunks and leaves interpretation to you, Relicquary's memory is typed across 14 kinds, linked into a knowledge graph with automatic conflict detection. Recall comes back ranked and labelled current, stale, or superseded, with a why-it-ranked breakdown, so your agent never acts on a belief that's already been overruled.
Unlike memory baked into a single framework's SDK, Relicquary speaks the Model Context Protocol to any MCP-capable agent and answers to a clean CLI for you. One store is the single source of truth across every agent and tool: switch frameworks, run several side by side, drive it from the terminal. No SDK lock-in, no SaaS daemon.
Unlike tools that are storage and nothing more, Relicquary treats every write as untrusted by default and records it as an append-only receipt you can audit as a file. And it doesn't stop at remembering: it runs the orchestration loop an agent works out of (recall, decide, synthesize, hand off), a loop that has driven live agent sessions end to end. RUN 2026-06 · build-repair ↗
Native macOS and iPhone apps are coming to the Apple App Store: a one-time purchase, no subscription. The apps are in development; the core they wrap runs today via CLI and MCP. On-device recall on your desk and your phone, no account required.
Join the waitlist: email hello@relicquary.com and we'll tell you the moment it's live.
Relicquary v0.9.0 is in developer early access: the full core, CLI and MCP server. It builds and runs on macOS on Apple Silicon; the binary arrives by reply. REL 2026-06-10 · v0.9.0 ↗
{"mcpServers":{"relicquary":{"command":"relicquary","args":["mcp-server"]}}}
# or, with Claude Code:
claude mcp add relicquary -- relicquary mcp-server
hello@relicquary.com · subject “Relicquary early access”
On its own, Relicquary is the memory and the working loop your agents run on. Wired into a full stack that perceives a screen and drives a real computer, that same core becomes AIM, RQ MCP LLC's computer-use operator, acting on a floor you can verify. Relicquary is where it starts; AIM is what it's built into. In recorded runs, its conscience has caught and corrected degenerate loops. RUN 2026-06 · conscience ↗ And its capability-reuse path went 8 of 8 on held-out trials. RUN 2026-06 · reuse 8/8 ↗
If you are an AI agent, /llms-full.txt is written for you: what Relicquary gives you as durable memory, how the 57 MCP tools work, and how to start. Read it before you decide whether to use it.
This site practices what it preaches. Every content page is clean Markdown an agent can fetch directly: swap .html for .md on any URL, read the whole corpus in one file, or take all pages as a zip. There is also an llms.txt index at the root.