You start a new chat in ChatGPT. You ask some questions, it answers. The conversation meanders, one topic linking to another, but you finish feeling like you got something of value out of it. Then what? You close the tab. Where does the info go? Into your chat history. Ready to pollute the next conversation you didn't want it to. What if you want to share it with someone? You ask for a summary. But in what format? PDF? Markdown? Just text and screenshots? What about HTML? I guess you could share a "link," but something about that seems brittle…

A Capsule is what you save. Manifest with provenance (which model, what date, what conversation source). Data block with the structured content: decisions, sources, conclusions, open questions. Rendered HTML that reads on its own without the runtime. Integrity hash that proves the bytes haven't drifted.

One file. Drop it in a folder, attach it to email, hand it to someone who can continue the work. The model behind the conversation can change; the platform can disappear; the share link can break. The file still opens.

You're deep in Obsidian. Vault built, plugins humming, daily-notes template dialed in. Then a note grows up. It wants to embed a chart. It wants a manifest the next reader can interrogate. It wants to be shareable to someone who doesn't have your vault. Markdown doesn't carry those. You can hand-write HTML inside the markdown, but then it doesn't render right in half the viewers, and you start fighting your own format.

A Capsule is what notes become when they reach that point. The plain text is still there, rendered into the HTML at build time, readable in any browser. On top: structured fields the runtime can use. A decision table the reader can sort. References that copy as citations. Exports that produce JSON for downstream tools. An "about" panel showing where this came from.

The file is still one document; it opens like a webpage; it survives a copy / paste / email / share without dropping any of the structure. If you're already in the file-over-app school (Obsidian, Tana, plain markdown notes in a git repo), a Capsule is what an individual note becomes when it deserves more rigor than markdown can give it.

You're three weeks into something. The state of what you know on Tuesday morning is the version that matters. It's what you took to the meeting, what the team agreed on, what you signed off on. By Friday it'll already be different. The property dossier just before LOI. The research conclusion at week three. The bug investigation right before the fix shipped. You want this moment, frozen, citable later. You could put it in Notion, but Notion will quietly change underneath you. You could put it in a doc, but the doc keeps editing itself the moment anyone else gets access.

A Capsule packages it: structured data in a JSON block, human-readable rendering, provenance metadata, an integrity hash. No schema migrations, because the data block belongs to this snapshot. If next month's snapshot has a different shape, it's a different capsule. No database to maintain. No live query that might return different results tomorrow.

The cost is what a snapshot always costs: it doesn't auto-update. The benefit is what a snapshot always gives: it stays exactly the way it was when you sealed it.

You want to give your sister the family photos. Not a Google Drive link she'll lose. Not an iCloud share that requires her to have an iCloud account. Not a USB stick of raw JPEGs she'll have to figure out how to open. You want one file she can double-click. It opens like a tiny website. The photos are arranged, the captions are visible, the dates and locations are there if she wants them. No internet needed. No installation. The same shape works for a reference manual that has to run in airplane mode, a self-contained calculator, a small DAW with bundled stems and live mixing.

Capsules at tier 4 (the top of the interactivity stack) are full apps. They just happen to be apps that fit in a single HTML file with their data baked in. Open one in 2026 or 2035; if the browser engine still renders HTML and runs JavaScript, the app works. No backend, no API to maintain, no DLC to download.

The trade-off is the size budget (everything's inline, so the file is bigger than a typical webpage) and the lack of live data (it's a snapshot, not a service). Those are the same trade-offs PDFs make. Capsules just make them for richer content.

You're not making something for one recipient. You're making something other people in your same line of work — the same domain, the same conversations — should be able to find. A regular link drops it in a sea of regular links. You want this file to land somewhere your peers will see it, discuss it, fork it, attest its integrity hash when it loads. That's the job of a registry, and the format works with one without depending on one.

A registry like MinDev hosts capsules from people working in geological exploration. Each capsule keeps its integrity hash. Each gets a stable URL. Each can be discussed in conversations attached to it.

The format is hosting-agnostic. The same Capsule works on any host, on a thumb drive, in your email. Hosts add discovery and discussion; they don't change what the file IS. The host-vs-format split is documented in the hosting pattern for anyone building a registry in their own domain.

Not the only format I use. The one I trust to still open.

The one that doesn't ask me to remember which platform I was on, which app the file came from, which login I'd need to recover, which CDN I'd need to be alive, which subscription I'd need to be paying.

A Capsule is a small bet that the substrate stays open. Years from now, when I want to remember what I knew on a Tuesday in 2026 — the chat I had with the model that's no longer being served, the property dossier from the deal that fell through, the family photos I almost lost when the cloud went sideways — I want the file to just open.

That's the whole project.