Relicquary is a local-first cognitive operating system for AI agents — typed memory and a knowledge graph, plus the orchestration an agent works out of: recall what matters, decide what's next, synthesize, hand off, keep the session moving. SQLite and Markdown on your own disk, a receipt for every step. No hosted service. No telemetry. Fully auditable.
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 — no hosted service, no telemetry. Relicquary remembers and runs the loop an agent thinks out of — recall, decide, synthesize, hand off. The model is yours: keep it fully local on your own machine, or connect your own provider account.
A SQLite database plus human-readable Markdown relics, sitting in a folder on your disk. Open them, grep them, version them. The operator owns the store.
~/.relicquary/mystoreRelicquary runs the loop: recall, decide what's next, synthesize, hand off, keep a session moving. That loop has driven live agent sessions end to end.
recall → decide → actEvery 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 tiersThe entire store is a SQLite database plus human-readable Markdown files on your own machine, with no hosted service and no telemetry. Run the models locally, or bring your own provider — either way, your store and audit trail stay yours.
Agents connect over the Model Context Protocol and read & write memory like a first-class tool. You drive the same store from a clean CLI.
Every mutation lands as a receipt and a file you can open in any editor. No telemetry, no opaque service — memory you can actually inspect.
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.
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.
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.
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.
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.
Native macOS and iPhone apps are coming to the Apple App Store — a one-time purchase, no subscription. On-device recall on your desk and your phone, with private cross-device sync and no account required.
Join the waitlist — email hello@relicquary.com and we'll tell you the moment it's live.
Local. Auditable. Yours. The core runs today — stand up a store, remember something, recall it. The Mac and iPhone apps are coming to the App Store as a one-time purchase, no subscription.
Developer early access available now — same address, subject “Relicquary early access.”
On its own, Relicquary is the memory and the working loop your agents run on. Given hands and a deterministic floor to act safely, that same core becomes AIM — RQ MCP LLC's governance architecture for verifiable autonomy. Relicquary is where it starts; AIM is what it's built into.