Save what's worth saving.

You finish a chat with Claude, ChatGPT, Gemini. You worked through a decision, found sources, weighed trade-offs, landed somewhere. The conversation matters. It will close. The canvas will mutate. The share link will rot.

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.

Markdown is excellent until you need a manifest, an integrity hash, embedded media, declared capabilities, or a runtime that actually does something with the content.

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 want to capture a moment of work — what you knew on this date, what you decided here, what was true then. The state of a property dossier on the day you took it to LOI. The shape of a research conclusion at week three. A bug investigation right before the fix shipped.

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.

Put a Capsule on a USB stick. Hand it to someone. They double-click and it opens in their browser. No installation, no account, no internet. An interactive family photo album with navigation, EXIF / location views, face annotations. A reference manual that works in airplane mode. 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.

A Capsule is portable, but sometimes you want it discoverable — not just by people you email it to, but by everyone working in the same domain.

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.