Verdad.
manifesto

A personal vault for the agent era.

Why your knowledge has to be the substrate, not the artifact.

May 2026 · Kyle Christopher Bunch & collaborators

For the last twenty years we built tools that captured what we know. The bet for the next ten is that the capture wasn't the point. The point is who can use it.

The way personal knowledge has worked, roughly forever, is: I make a thing. The thing lives in a place. The place is its purpose. My notes live in Notion because Notion is for notes. My recipes live in Notion (or Paprika) because that's where recipes live. My articles live in Pocket because that's where articles live. My contacts live in iOS because that's where contacts live. Each app is a silo, and the silo is the experience.

This worked when humans were the only readers. We knew which silo we'd written into; we knew where to look. The silo's interface was the search.

That model breaks the moment something other than me wants to read it.

The premise

The most consequential change in computing this decade isn't the model. It's the consumer. For the first time, software that I write isn't only being read by another human. It's being read by an agent — by Claude, by ChatGPT, by Gemini, by my own tools running in the background — and what those agents need is not what humans need.

Humans need a UI. Agents need a contract.

Humans need search ranked by relevance. Agents need lookup keyed by identity.

Humans need the data behind a beautiful interface. Agents need the data, and they need to know whose data it is, where it came from, when it was captured, and what's been done to it since.

The silos I've been writing into for twenty years were optimized for the first half of every one of those pairs. The second half — the part agents need — is missing, and it's not optional anymore.

What Verdad is

Verdad is the substrate I've been refusing to build for twenty years. It is one personal vault. It speaks MCP as its primary contract. Every entity it stores has a known schema, known provenance, and a typed reference to every other entity it's related to. Recipes know they came from Diana Kennedy's The Cuisines of Mexico. Articles know they were published by The New York Times. People know where they were born. Places know what cuisines they're origin to. The graph builds itself by use — not because some product manager designed it that way, but because the contract is uniform enough that anything which references anything else has to declare what it's referencing.

It is not a product. It's a substrate. The product is the agent that uses it.

The architectural commitments

Twelve principles, each of which I've broken in earlier systems and learned the hard way. They aren't aspirational; they're the load-bearing walls.

1
MCP / API is the contract; clients are many and never privileged.
A web UI is just another MCP client. So is a CLI. So is Claude. Same auth, same surface, same error codes. There is no "official app" that gets to skip the contract.
2
Canonical and overlay are separate concerns.
The recipe as published is one thing. My relationship to it — when I cooked it, what I changed, how I rated it — is a different thing. Both live on the same row, but they never mix.
3
Tier (active vs reference) is per-entity, not per-domain.
Most people in my vault are references (Diana Kennedy never logged in). Some are active (my family). The row knows which.
4
Schemas are admin-authored; data and templates are user-authored.
No runtime customFields escape hatch. Adding a new entity type requires a code change. The data model is a contract, not a runtime concern.
5
Schemas are typed, versioned, and queryable.
Every entity carries its schemaVersion in provenance. Migrations are deliberate. Old data is never re-interpreted under a new schema without an audit trail.
6
Templates accelerate creation within schemas, never extend them.
If a template can introduce a field the schema doesn't already declare, the schema is the wrong abstraction. Templates are sugar; schemas are structure.
7
Postgres is the source of truth, not markdown.
Markdown vaults are seductive — search-friendly, portable, plain-text-forever. But they don't carry provenance, they don't enforce schemas, and they can't be queried structurally. Postgres can. The plain text is exported; it is never the master.
8
Ingestion is a uniform interface across all sources.
Paste-a-URL is the same surface as paste-an-RSS-feed is the same surface as a Notion bulk import. The pipeline differs internally; the contract doesn't. And the original raw payload is always preserved in provenance.rawCapture so re-enrichment under a better model is non-destructive.
9
Connective tissue (people, entities, places) comes early.
The graph is what makes the vault valuable for agents. It can't be a late retrofit.
10
Content ingestion is never blocked by entity resolution.
If the article mentions a Diana Kennedy and we're not sure which one, we queue the resolution. The article lands. The graph fills in by use.
11
Build narrow; let the graph grow by use.
Five entity types in Phase 1: recipe, article, person, organization, place. Not because the world has five types, but because shipping six would mean shipping less of each one well.
12
Open standard, single reference implementation.
The contract is documented (/docs) and the reference implementation is open. If something else wants to speak the same protocol, nothing stops it. The vault becomes a category, not a product.

What that actually buys

It is hard to convey, before you live with it, what changes when the agent in your pocket can see your stuff. Most demos of AI agents are agents with no context — they reach into the model's training data, into the public web, into shallow connectors. They are extraordinary at the part that doesn't require knowing anything about you.

The agent that can see your vault is a different category of thing. It knows you've cooked Diana Kennedy's carnitas eleven times. It knows which substitutions worked. It knows the two friends who don't eat pork. It knows you served the dish at Marcus's birthday party in 2023 and that you'd written a note saying not to skip the orange zest. When you say "I want to cook something for tonight," what it can do is not a recipe search. It's a recipe recommendation that is actually about you.

That same agent, asked about an article, knows you've read it. Knows what you highlighted. Knows you cited it in a doc. Knows the person who sent it to you. Multiply this across thousands of small decisions and what's emerged isn't "a better chatbot." What's emerged is a personal computing layer that the silos couldn't have produced, because the silos were never trying.

What it isn't

It isn't a notes app. It isn't a CRM. It isn't a knowledge graph startup looking for product-market fit. The user count goal for the next 12 months is one. The user is me.

The reason to make it open is the same reason MCP is open — the model where one company "owns" your personal knowledge graph is the same model that gave us the silos. If Verdad's contract is right, anyone should be able to host their own. If it's wrong, the contract should change, and that change should be public.

The bet

The bet is that personal knowledge is on the verge of becoming infrastructure. Not because the apps have failed — they haven't — but because the consumer has changed. The agent in your pocket needs a thing that, until now, no one's been incentivized to build: a single, contract-stable, provenance-preserving substrate that holds the truth of your life and exposes it to whatever needs to read it.

Most things called "your data" today are an account on a server that markets to you. Verdad is a vault you control, in your own database, with a contract anyone can read. The vault doesn't have to be smart. Its smartness lives in whatever agent reaches into it.

Build the substrate. Let the agents do the rest.

Where to start

Reading list