Why Quaid

Memory that thinks like you, and you can prove it.

Darn, this thinks like me.

We are, to some extent, the sum of our memories and experiences. They guide our behavior without conscious recall.

Karpathy calls this compiled knowledge. The person who has built a startup knows which questions to ask before writing code. The investor who has seen a hundred decks knows the pattern of a deal that does not close. They do not reason from first principles each time. They operate from an accumulated self that has been shaped by everything they have encountered.

Quaid builds that for AI agents. Not “here is a document you might find relevant” but an agent that operates from a persistent accumulated self. One that leads with downside risk because it knows you always want that first. One that does not need to be briefed on history because it was there. One that, over time, earns the reaction: darn, this thinks like me.

Memory that compounds Every session adds to what the agent knows. Every decision it witnesses shapes how it reasons next time. Intelligence that accumulates rather than resets.

Trustworthy personalization

There is a risk in systems that personalize aggressively: if the agent rewrites your knowledge through your existing biases, it may reinforce wrong beliefs. The book gets filtered through your current lens instead of challenging it. The memory system becomes a mirror that only shows you what you already think.

Quaid’s ADD-only architecture exists specifically to prevent this. Memories accumulate. Nothing is overwritten. A head-pointer resolves queries to current truth, but the full history is always accessible. You can ask what you believed before, trace how a view evolved, and verify that the agent’s understanding of you reflects reality rather than a convenient simplification.

Memories accumulate. Nothing is rewritten. You can always see the chain.

The information sovereign

The current landscape of knowledge management is fractured by dependency. We rent our memory from services that can change policy, disappear, or decide that semantic features now require yet another key and another bill.

Quaid flips that arrangement. It is an architectural approach to software - built with the same philosophy as a physical library: heavy, stable, inspectable, and entirely yours.

Intelligence should not require a handshake with the cloud.

What makes Quaid different

Three positions, taken together, that no other memory tool holds:

• Append-only by design. Memories accumulate. Nothing is rewritten. A head pointer resolves queries to current truth, but the full history is always accessible. You can ask what you believed before, trace how a view evolved, and audit the chain at any time. This is the trust property: an agent that personalises aggressively without quietly mirroring your biases.
• Truth is human-readable. Markdown defines what’s true. SQLite stores it deterministically. Embeddings only index it - and the index is rebuildable. Every layer is inspectable, every page readable in a text editor, every claim falsifiable. If you can’t read it, you can’t trust it.
• One binary, no cloud. Compute and storage on your machine. The embedding model ships in the binary on the airgapped channel; on the online channel it’s cached after a one-time download. No container, no Python runtime, no service mesh, no API keys. Hybrid retrieval - FTS5 plus a local BGE vector index - runs on the same CPU that holds your notes.

The MCP server predates any GUI. The same surface humans use through the CLI is exposed to Claude Code, Cursor, and any other MCP-compatible client over stdio. The agent reads what you read.

Quaid separates truth from retrieval, and lets you keep both.

Built for an agent-first world

The same single-file memory answers full-text searches, semantic queries, graph exploration, contradiction checks, and MCP tool calls without handing custody of your data to anyone else.

It also stays current. The v0.9.6 release added a live file watcher that follows your Obsidian vault as you edit - reconcile-backed, with a 1.5 s debounce and write-safety interlocks - so the memory an agent reads is always the same memory you just updated. (Unix/macOS/Linux only.)

Ready to own the stack end to end?

Start with the install tutorial, build your first memory in ten minutes, and wire it into the tools and agents you already use.

Install Quaid View on GitHub