Every morning in 50 First Dates, Lucy wakes with no memory of Henry. So he makes her a tape — a short film she watches over breakfast that catches her up. Who she is. Who he is. What they’ve been through. By the end of it, she trusts him again.

That is my AI. Every single chat.

It wakes up bright and blank. It doesn’t know my projects, my servers, the decision I made last week, or the way I like things written. So I re-explain. Every session I pay the same tax — the warm-up, the context dump, the “no, I prefer it this way”.

I got tired of being Henry.

So I built the tapes. This is the behind-the-scenes of how — the idea, the decisions, and the surprises that kept landing.

A vault that worked, and sprawled

For months I’d kept a vault — plain notes my AIs read at the start of each chat. It worked. It also sprawled. Obsidian held the files. A git hook on my Mac guarded the rules. A clutch of bots hung off the side. Conventions only I remembered.

It was a personal rig held together by me.

I wanted it to be a real thing instead — portable, open, something any AI could read and any person could run. So I sat down to redesign it from first principles. Strip the tools away.

What is this actually for?

Six jobs: remember, trust, find, write, act, and keep me in control.

Everything else — Obsidian, the bots, the folders — was just one way of doing those six.

The reframe — and the shock of company

The reframe was small and it changed everything.

Stop treating the vault as an Obsidian folder with rules bolted on.

Treat it as layers — plain files at the bottom, an index built over them, one doorway any agent uses to read and write, and the rules and agents on top.

Swap any layer without breaking the rest. Files I can copy out and walk away with. That last part matters to me more than any feature.

Then the shock. While I was sketching this, I looked at what others were doing — and the whole field had arrived at the same place within weeks.

• Andrej Karpathy had published the “LLM wiki”, where the AI builds and keeps a wiki of plain markdown instead of re-deriving everything each time.
• Somebody had shipped a hosted version of it.
• Google had turned the same pattern into a vendor-neutral spec (Open Knowledge Format). The exact shape I’d been building in spare evenings.

Two feelings at once. Quiet relief — the idea was real, I wasn’t imagining it. And, louder: move. So I decided. Speak the standard everyone’s converging on, and go further on the parts they all skip — trust, governance, and a memory that lasts.

The boring middle that turns a clever pattern into something you’d hand your life’s notes to.

Four arguments I had to win

A redesign is really a stack of small arguments with yourself. Four I had to win:

Files, not a database. Everything lives as plain markdown in git. It’s slower and less clever than a proper store. I don’t care.

The whole promise is that I can leave — no lock-in, no dead format, no company standing between me and my own words. Portability isn’t a nice-to-have here. It’s the point.

Local-first, not a server I dial into. I nearly talked myself into a tidier version — the core lives on a server, my laptop just mounts it, one copy, no sync to worry about. Then I followed it through.

A mounted server dies the second the wifi drops. And if the data is to be truly private, the encryption has to happen on my machine — so my machine has to hold the keys and the readable copy — so I’m local-first anyway.

The “simple” cloud idea collapsed back into the thing I already had. The files live with me; the cloud is a helper, not a landlord.

Build the plumbing, borrow the bricks. There are good tools for wiring up automations. I’m embedding none of them. Their licences would tangle a thing I want to give away, and a workflow engine isn’t where the value sits anyway.

I’ll build the small reactive core myself and borrow only tiny, permissive libraries where they save real work. Own the parts that matter. Rent nothing load-bearing.

Let it forget — on purpose. I read how one agent framework handles memory: a tight, bounded core, and the rest fades by how often it’s used. Forgetting as a feature. I took it, with one change.

In my vault, forgetting never means delete. It means demote — the cold stuff slides down to an archive, out of the way but never gone. A memory you can’t trust to keep things isn’t a memory.

None of these are decided once and forgotten. I wrote each one down with its reasons, so the next person — or the next me — doesn’t have to fight the argument again.

Every good name was already taken

Then came the part I thought would take an afternoon. It took a day, and it taught me the most.

The working name was “Knowledge OS”. Plain, descriptive, fine. It’s also a registered trademark held by someone else, in my exact category — and the “[thing] OS” pattern is so worn it’s nearly a punchline. Dead on arrival.

So I went hunting, and found one I loved: Glinthawk — a flying machine from Horizon Zero Dawn, glint and hawk, a flash of clarity with a sharp eye. The .com was free. I was ready to buy it.

Good thing I checked properly. Microsoft already ships an open-source AI engine called exactly that — glinthawk — in my exact lane, with a research paper behind it. Launching beside it would mean launching into its shadow.

That killed Glinthawk, and it reset the whole search. The lesson hit hard — a free domain means nothing. What kills a name isn’t whether the website is going spare. It’s whether someone has already shipped a project of the same name in your own field.

The domain is the easy part. The twin in your lane is the assassin.

After that I ran name after name through a hard, adversarial check — not “is it pretty” but “find me the reason this is already taken”. Invented words, coined from scratch: blocked, one after another, each colliding with some funded startup.

I went back to Horizon — it has a whole bestiary of machine names. Most were already taken by other AI projects. Twin after twin.

There was a perfect one: Tallneck, the giant machine you climb to reveal the map of a whole region — almost word for word what my engine does. The handle was squatted and the trademark too near. Gone.

Here’s the surprise that’s stayed with me: the space is full. Nearly every clean, sayable, evocative name a person would actually want has already been claimed by someone building something next door. I checked dozens. The yield was close to zero.

The name in my own filing cabinet

I was about to settle for a coined word I didn’t love. Then I stopped and read my own notes.

Months ago, when I first started keeping the vault, I’d given the idea a private name — 50 First Tapes. A nod to the film. The AI is Lucy, waking blank. I’m Henry.

The notes are the tapes she watches to learn to trust me again. I’d written it down and forgotten it as anything more than a joke to myself. It had been sitting there the whole time.

I ran it through the same brutal check. Clean. No twin in my lane. Free across the board.

The thing I’d spent a day hunting had been in my own filing cabinet since the start — and it meant more than anything I could invent, because it named the actual idea instead of dressing one up.

That’s the bit I keep turning over. I went looking for a brand and found a description. The metaphor wasn’t packaging for the product. It was the product.

What it is now

So that’s where it stands. 50 First Tapes is named, scaffolded, and being built in the open under a permissive licence — the engine free for anyone to run, read, or build on. The clever parts I’ll sell sit on top. The floor stays open.

The reason hasn’t changed since the first morning I got tired of re-introducing myself to a machine. Every new chat, my AI is Lucy — willing, sharp, and blank.

The tapes are how it catches up by breakfast: who I am, what we decided, how I like things done. Made once, kept current, replayed each morning, so the trust doesn’t have to be built from cold every time.

If you’ve ever re-explained yourself to an AI for the hundredth time, you know the problem already. I’m building the tape — in the open.

Come and watch it take shape.

The whole thing, in one picture

Here’s the shape end to end — what’s open and free, and what gets built on top.

One engine underneath — different faces on top.

What each layer is, bottom to top:

• Substrate — the raw files where knowledge lives. Plain markdown + git, nothing else. It survives any tool dying. (The substrate is the bytes on disk — the bedrock.)
• Derived index — a map for fast lookup, built from the files on demand. Never hand-kept, never saved into git. (An index is a lookup map, like the back of a book.)
• Protocol — one doorway every tool and agent uses to read, write, search, and obey the rules. An MCP server is that door today — a CLI and a code library follow, all speaking the same contract. (A protocol is the agreed way to talk to the vault.)
• Agents & governance — crew and locked rules written as data, not as prose, so any model can load them. (As data means plain structured facts a machine reads, not an essay.)
• Products & views — Obsidian, my vault, the LMS, client deployments. Each reuses everything below and builds only its own new parts.

And what that buys:

• Portable — knowledge is plain files. Lose Obsidian, lose me, lose the company — the vault still opens.
• Any AI — an agent needs only the protocol, not my folder layout or my habits.
• Token-lean — an agent loads top-down and stops when it has enough. A few hundred tokens to get its bearings — more only on demand.
• Built upon — the LMS inherits storage, search, rules, and audit. It writes only the new parts: courses, lessons, tutors, learners.