Relicquary (v0.9.0) is the runnable core: durable, local-first, receipt-bound memory plus orchestration — the cognitive OS an agent thinks out of. AIM wraps that same core in a governance architecture aimed at verifiable autonomy, and only then gives it a body and a voice.
A cognitive OS, an operator, a touch driver, a control stack — held together by three commitments that show up in the code, not just the copy.
Your store lives on your disk — no hosted service, no telemetry. And the model is your choice: run it fully local, or connect your own provider account (you bring the OAuth). Either way, your data and audit trail stay yours.
your machine · your filesExactly one action per tick, through one audited chokepoint, behind a fail-safe fence. A deterministic conscience can halt a degenerate loop. Destructive, irreversible actions are retained by the human by design.
one chokepoint · one conscienceNo capability exists until a receipt backs it. If a proof didn't run, the system says so — never a green result a verifier didn't confirm. We publish honest NULLs. A result only counts when it survives a test it could have failed.
receipts over rhetoricRelicquary is the core, and it runs today. TouchLink is a virtual touchscreen driver you can use on its own — or fold into a stack, the way AIM does.
A local-first cognitive operating system in a single Rust binary. Durable typed memory and a knowledge graph — plus the orchestration an agent works out of: what to do next, synthesis, handoff, continuity across sessions — all under receipt-bound governance, as SQLite and Markdown on your own disk. It's the core the rest of the stack is built from. Build it, init a store, and serve it to any MCP-compatible agent today.
Explore RelicquaryDecision: Ship local-first — SQLite + Markdown on the operator's own disk.
AIM — Accurate, Immediate, Minimal; AGRO in motion. Relicquary writ large: the cognitive core given hands and a voice, aimed at autonomy you can audit.
Five mechanisms, none of them another model's opinion. They hold whether or not the brain behaves.
The floor is mechanism — so it holds even when the models agree.
Exactly one place where the agent acts on the world — governed and inspectable, not scattered tool calls. A standard agent is a loop wired to many tools, with many places intent becomes effect; AIM has one. That single gate is the structural break from while-loop-plus-tools.
The chokepoint sits behind a hard boundary that blocks catastrophic operations outright, independent of what the model decides. The safe state is the default; the agent is never trusted past the fence for those operations.
Not a second model grading the first — rule-based checks (we call them theodicytes) that can halt the agent on fixation, on no-op churn, or on an ungrounded assertion. The judgment is mechanism, and a halt is correct-and-continue, not a crash.
Every mutation emits an append-only receipt. Actions aren't just claimed in the agent's narration — each leaves a record you can audit independently, after the fact, without trusting how the agent described what it did.
Everything the agent writes to memory is untrusted by default and carries its provenance. Trust is earned through governance, never assumed because the model said so — the same discipline that makes Relicquary's memory auditable, applied to an operator that acts.
One core, embodied. Relicquary is the cognitive OS at the center; AIM wraps it in the floor above, then gives it organs. Each part is graded for where it actually stands.
The cognitive OS the whole stack thinks out of: durable typed memory, a knowledge graph, recall, and the orchestration of the working loop — under receipt-bound governance. Standalone →
Proposes one action, runs it bounded, verifies it against receipts, checkpoints, repeats. It plans; it never actuates directly.
The Rust substrate that runs a model as a persistent operator, and carries the one audited actuation chokepoint behind the fence.
The bounding doctrine made executable: the deterministic detectors that halt and correct a degenerate loop. The only part that can halt.
How the operator touches a real machine: a local command bus of explicit, named adapters that return verifiable results — plus TouchLink's focus-preserving touch surface.
A capable frontier model drives the loop from outside, plan-only. It has no weights we can touch — so it never improves itself; it authors capability into AIM. Swappable by design.
The brain is a model whose weights we don't touch — so it never trains on your use. Capability accumulates in the stack instead. Here is exactly where it can live, and how we hold the line on what counts.
Hit an obstacle whose signature it has seen, and AIM recalls the durable capability it already stored — a tool, a procedure, a receipted artifact — and re-applies it. The capability-reuse path passed all 8 of 8 held-out trials, on novel instances, not memorized ones.
The next phase is capability synthesis — authoring a genuinely new durable capability for a blocker it has never seen, gated behind a hard held-out test. Clearing a blocker is the entry ticket, not the verdict: a capability is real only once it passes a held-out execution on a novel instance. Model opinions don't count — only the test does.
Every capable agent eventually hits the same wall: it forgets. We're building the other way — a foundation that remembers on your terms, governed so every move can be checked. The core runs today; the destination is an autonomous system whose every action leaves a receipt.
A single Rust binary, CLI and MCP, with your memory living as SQLite and Markdown on your own disk. Typed memory, a linked knowledge graph, local search and reranking — nothing routes through a model provider. Writes are untrusted by default, every mutation leaves a receipt, and it already reuses capability it has stored — demonstrated by passing 8 of 8 held-out trials on a capability it had banked before, not memorized. The foundation everything else stands on.
The same local-first core is coming to Mac and iPhone through the Apple App Store — a one-time purchase, no subscription. Your memory stays on your devices and in your hands. The durable memory that has lived on the command line becomes something anyone running capable agents can buy once and own outright.
AIM wraps Relicquary in governance. A single actuation chokepoint, a fail-safe fence, and three non-terminal conscience checks mean a questionable move is held and corrected rather than silently executed — a floor that holds even when a model is confident it's right. This is how a memory system becomes an operator you can let act: bounded, auditable, answerable for every step.
DPACA puts two models in a four-eyes arrangement — one proposes, the other only approves or rejects — behind a deterministic, hash-bound publish step. Its purpose is reliability, not magic: to make it far harder for a single confident model to push a mistake through. Named here as direction, built toward acceptance gates — not something already shipping.
AGRO is the soil: cultivated ground, Always Growing Recursive Optimizer. The destination is an autonomous system that can be trusted to act because every move is auditable down to the receipt. The stack accumulates receipt-bound capability — capability it can carry and reuse, with provenance attached. The hard, open frontier is capability synthesis: a genuinely new capability for a problem the system has never seen. That is unbuilt research, and we say so plainly. It is the work ahead — and it is the whole point. AGRO in motion: Accurate, Immediate, Minimal.
So the credibility gradient is visible at a glance — what runs, what's prototype, what's research, what's only designed.
RQ MCP LLC builds Relicquary — the local-first cognitive OS — and AIM, the governance architecture that turns it into a verifiable operator. Every capability is receipt-bound, and a result only counts when it survives a test it could have failed. The core runs today; the Mac and iPhone apps are coming to the App Store as a one-time purchase, no subscription.
“Agents forget. Every autonomous system we ran reset to zero between sessions — repeating mistakes, losing the context it had earned, asking us to trust actions we couldn't check afterward. The conviction was simple: memory and accountability aren't features you bolt on later — they're the floor everything else stands on. So we built the floor first. The core runs today on your own machine: one binary, your disk, a receipt for every action. That's the standard I want to be held to.” — Jessy Brenenstahl, Founder, RQ MCP LLC
