· via Hacker News – Front Page (hnrss.org)
CheeseDB is an agent memory database where recalling a source deletes what it taught
CheeseDB, a new open-source database written in Go, tracks which source taught an AI agent each memory, so recalling a bad source removes every conclusion built on it — provenance as a storage-engine rule.
A Show HN post on Hacker News introduced CheeseDB, an open-source database engine purpose-built for AI agent memory in which every stored fact records the sources it was learned from, and revoking a bad source automatically removes every conclusion the agent drew from it. According to the project's README, published under the govinargo-labs GitHub organisation, the engine is written in Go using only the standard library, runs embedded with no server or external dependencies, and can be driven from Go code, a command-line tool, or MCP clients such as Claude Code and Cursor.
The problem it targets
Agent memory is assembled from inputs that cannot be fully trusted: user messages, web pages, documents and tool results. The README lays out three failure modes — a tool returns bad data, a page plants false facts through prompt injection or memory poisoning, or a user asks for their data to be deleted. In a plain memory store, deleting the offending source is not enough, because the beliefs derived from it survive and the agent keeps acting on them; a generic store simply cannot tell which memory came from where. The project's demo, as described, shows an LLM still giving the same wrong answer after a bad source was removed from an ordinary memory list.
Provenance enforced by the engine
In CheeseDB, a memory cannot be stored without the sources, or other memories, it was learned from. One recall call removes a source plus everything transitively built on it, however deep the chain goes. Two severities are offered: Fair, where a memory survives if an independent source still backs it, and Strict, which wipes everything the source ever touched. An Erase option rewrites the on-disk files so the recalled text's bytes are gone before the call returns, and a companion command searches raw bytes to demonstrate the erasure.
The README's worked example makes the semantics concrete: a user message and a doctor's note jointly support an allergy memory, a restaurant's web page claims a sauce is peanut-free, and a derived "safe to eat" conclusion depends on both. Recalling the web page in Fair mode deletes the peanut-free claim and the safety conclusion, but the allergy memory survives because the doctor's note still backs it.
Every record is chained to the previous one by hash, so tampering or corruption is detected on each open, even after erasure. Agents are isolated by design: each is reachable only through its own token, and no API method accepts another agent's name, limiting what a prompt-injected tool can reach. An optional embedding model adds semantic search, question answering and natural-language "forget"; without one, the rest of the engine still functions.
The benchmark claims
The developers published their own comparison against SQLite 3.53, PostgreSQL 17 and Neo4j Community 2026.10, using 1 million memories per agent, the median of three runs on an Apple M1 Max, and equal durability settings where every write is flushed to physical disk before acknowledgement. Their headline number is a recall removing 10,000 memories: 5.2 ms for CheeseDB versus 68 ms for Neo4j, 236 ms for SQLite and 1.94 s for PostgreSQL. Durable writes came out roughly even across engines, which the authors attribute to disk flush time dominating. The README itself flags the caveats: the team wrote the Neo4j model and queries and says an expert might do better, and PostgreSQL and Neo4j ran over localhost TCP, adding a round trip per statement.
What it does not do yet
The project labels itself a preview: no independent security review has been done, the API and on-disk format may change before v1.0, and it is not recommended for production data. There are no SQL-style filters or keyword search — lookups work by id or by meaning. Startup replays the log, taking roughly 0.7 seconds at one million memories, with snapshots planned. Memory must fit in RAM, at about 205 bytes per memory plus roughly 0.8 KB for each searchable one. It requires Go 1.26.5 or newer, is developed on macOS, runs the same tests on Linux in CI, and does not support Windows.
Why it matters
As agents accumulate long-lived memory, provenance becomes a correctness, security and compliance problem at the same time. Poisoned memories persist after the source is cleaned up, and privacy obligations can extend to derived data, not just raw records. CheeseDB's core bet is that these guarantees belong inside the storage engine rather than in application code, much as transactions once moved into databases. The implementation is unreviewed preview software with self-run benchmarks, so the engineering should be treated cautiously — but revocable, provenance-tracked memory as a native primitive is a genuinely fresh angle on AI data management, and a sign of where agent infrastructure is heading.
- #open-source
- #golang
- #databases
- #ai-agents
- #data-provenance