Every AI lets you export your chats. None of them can read each other's.

One shape for every export

Every service exports the same underlying thing — who said what, and when — in a different container. Memvelope defines the one shape they all become.

ChatGPT → a tree of message nodes, Unix timestamps, split across conversations-000.json, -001.json…
Claude → flat arrays of chat_messages, ISO dates, content blocks
Future profiles (Grok, whatever ships next) → next shapes, not this converter yet
  ↓  one converter for ChatGPT + Claude today
Memvelope → one envelope — this is the whole mental model:

{
  "memvelope": "envelope-v0",
  "meta": { "source_provider": "chatgpt", "conversation_count": 1, "message_count": 4 },
  "conversations": [
    {
      "id": "c-3f9a2b",
      "title": "Pricing the beta",
      "created_at": "2025-11-02T14:22:51.000Z",
      "updated_at": "2025-11-02T14:41:10.000Z",
      "messages": [
        { "id": "m1", "role": "user", "ts": "2025-11-02T14:22:51.000Z",
          "text": "walk me through the beta pricing options again" },
        { "id": "m2", "role": "assistant", "ts": "2025-11-02T14:23:04.000Z",
          "text": "Three tiers came out of last week's call: a free reader, a $14/mo hosted plan, and an annual prepay." },
        { "id": "m3", "role": "user", "ts": "2025-11-02T14:40:12.000Z",
          "text": "who was pushing for the annual option — was that Dana?" },
        { "id": "m4", "role": "assistant", "ts": "2025-11-02T14:41:10.000Z",
          "text": "Yes — Dana Okafor argued the annual prepay covers the big one-time import cost." }
      ]
    }
  ]
}

Download the full sample .mve.json JSON Schema Conformance fixtures

A top-level tag declares what the file is; everything under it is your conversations, in the spec's canonical field order, with their original timestamps — legible in a text editor, parseable in any language in an afternoon.

Every envelope guarantees:

• Lossless prose. Every word you and the assistant wrote, kept after the spec's trim-and-join extraction — nothing summarized, nothing invented. It's the text of the conversation; attachments and images aren't carried.
• Real dates. Timestamps are what the export recorded — when things were actually said — never the day you happened to convert.
• Your words, not the machinery. Tool calls, system plumbing, and hidden reasoning are left out. It's the conversation, not the exhaust.
• Self-describing. Each file declares its format and version in a top-level field — the first key as the reference tools write it — so no tool guesses from a filename, and a v0 file will still identify itself correctly in ten years.
• Deterministic. The envelope is a pure function of your export — same file in, identical envelope out, byte for byte, under the canonical serialization profile every conforming implementation targets. No stamp of the moment you ran it, no tool signature, nothing that drifts. That's why any converter can be checked against the published fixtures with an exact diff, not vibes.

What it deliberately isn't: a database, a memory graph, or any one app's format. Memvelope is the neutral layer in between — the common envelope everything else can agree on. Read the specification →

Convert your export

Drop a conversations.json export from ChatGPT or Claude. Multiple files — including ChatGPT's split conversations-000.json / -001.json — merge into one envelope automatically.

Two layers, kept apart on purpose

Memvelope separates the lossless-prose archive from the memory distilled out of it — because only one of the two can honestly promise not to drop prose.

Read the full specification →

Why this exists — and what happens if it dies

Every export button produces dead bytes: readable by the app that made them, illegible to everything else, and liable to change shape the next time the vendor ships. But what's underneath — who said what, and when — is simple, and it's yours. What's been missing is a common envelope any export can be poured into and any tool can read back out. That's the whole job Memvelope does, and the reason it's a standard rather than a product: a format only unifies if no one owns it. The full argument — the moat, the prior art, the objections — is an essay of its own. Read the full essay →

A young standard owes you an answer to the obvious question — what if it doesn't last? Durability here is structural, not reputational. Every envelope names its own version in a top-level field every reader checks first, so files never rot into ambiguity. The spec evolves additively: a v0.x file may add fields, readers ignore fields they don't know, and anything that would break an existing file means a new major version — which the file declares. Spec, schema, converter, and fixtures are all MIT; fork them. The reference converter is a static page with no server behind it — load it once and it keeps working offline, or clone the repo and any static file server runs it forever (npx serve public). And if every steward of this project vanished tomorrow, your envelope would still be plain JSON: your words and your dates, legible to a text editor, jq, or a ten-line script. A standard should fail gracefully. This one is designed to.