Backfill your first morning brief: turn a decade of ChatGPT into a dense day one.

Install chanio today and your first morning brief will be thin, because the vault behind it is empty. The fix isn’t patience — it’s the years of ChatGPT and Claude conversations already sitting in an export you haven’t downloaded yet.

Why an empty vault gives you a thin brief

A morning brief is a compile step, not a guess. Each night, chanio reads what is actually sitting in your vault — yesterday’s captures, the open loops you haven’t closed, the topics that keep resurfacing — and turns that into a few paragraphs waiting for you at 6am. On day one, none of that exists yet. The vault is empty, so the compile has nothing to compile. What comes back is a placeholder, not a brief.

That isn’t a flaw in the brief itself. It’s just arithmetic: density in, density out. Someone with three years of ChatGPT conversations about a business, a health question, a home renovation, and a dozen smaller threads already has the material a brief is built from — decisions made, threads set down and never picked back up. None of it counts until it’s sitting in the vault as files chanio can open. Not a waiting problem — a backfill problem, and it takes an evening, not a quarter.

Get the export

Both ChatGPT and Claude will hand you a full export of every conversation you’ve had with them, and the request itself takes under a minute.

In ChatGPT: Settings → Data controls → Export data. Confirm, and a zip arrives by email containing conversations.json — the whole archive, in one file.

In Claude: Settings → Privacy → Export data. Same shape — a zip arrives with your conversations.json inside it.

If you’ve used both, request both. There’s no penalty for size and nothing to prune first — a heavier file just means a heavier vault. Leave the zips wherever your browser puts downloads; the next step reads them directly, so there’s nothing to unzip or rename by hand. (If your actual goal is moving that history into a different model rather than into your own vault, that’s a related but separate job — see moving your whole AI history to a new model.)

Rescue it into files you own

The zip from either vendor isn’t something you want to read by hand — it’s one large JSON file, not prose. That’s what export-rescue is for.

Go to chanio.com/export-rescue and drop the zip — or the bare conversations.json, if you’ve already extracted it — onto the page. Everything from here runs in that browser tab. Nothing is uploaded — there’s no server in the path to upload it to, which matters when the file in question is years of your conversations.

The page finds conversations.json inside the zip and parses it on the spot. What comes back first is a graph preview: conversation count, message count, how many words you personally wrote, the date range the archive covers, and the topics you kept coming back to most. Below that sits a sample capture — a structured breakdown of your single longest conversation, computed deterministically right there in the browser, so you can see the shape of a capture before committing to the whole archive.

Click “Download as Obsidian vault” and you get a zip of plain markdown files back — one file per conversation, wikilinked, plus topic hub pages tying related conversations together. Unzip that into your chanio vault, next to whatever chanio has already captured on its own, and the raw material for the backfill is in place.

The backfill pass

With the rescued conversations sitting in your vault as files, the next scheduled overnight run treats them the same way it treats anything else it finds there: reading material for the compile.

chanio works in three tiers of intelligence. Most of what it reads, it handles on-device, for free — that’s the local pass, and it’s what does the heavy lifting on a backfill. Reading years of conversations means finding what recurs, pulling it into per-topic notes, and building a list of open threads: questions never fully closed, decisions that seem to have reversed, a project that shows up in month one and again in month eleven with nothing between. A decade behind it is a bigger job than a week, so on a large archive this compile can reasonably run more than one night — there’s no fixed rate to promise, and the honest answer is it depends how much you handed it.

Whatever the local pass genuinely can’t resolve gets held rather than guessed at. Overnight, the held questions go to the big AIs — Claude, Gemini, your choice — and the answers are in your brief by 6am. The local pass itself stays free; if a backfill pushes real volume into the held pile, that night’s frontier batch is the only line item, and it runs from pennies to about fifty cents.

What a dense day one looks like

The difference shows up directly in the brief. Below is a plausible example of what an early brief could look like after backfilling a few years of history — invented for this post, not pulled from anyone’s real vault:

Nothing in that excerpt is a fact chanio invented. Every line traces back to something that was actually typed, once, into a chat window — the backfill’s only job is noticing that it was typed more than once.

The honest part

Exports are lossy, and you should know where before you rely on one. Images you shared or generated inside a conversation typically don’t come through. Some tool outputs — code-interpreter files, browsing results, plugin calls — are flattened or dropped depending on the vendor and the month you exported. A link you shared into a conversation is just a link; whatever it pointed to isn’t in your export and won’t be in your vault either.

A decade, or even three years, of conversation includes plenty you no longer believe. Opinions you’ve reversed, plans you abandoned, a business idea you talked yourself out of over four sessions. The backfill doesn’t know which old threads are still live and which are dead — it surfaces what recurs, not what’s current. Expect the first few briefs to raise things you’ve already moved past. Not the system being wrong — that’s you pruning, faster than the system could guess on its own.

And the compile itself is coarse on the first pass, because the model doing the reading is the small one running on your machine, not a frontier model. It will misjudge which threads matter, merge two topics that should stay separate, or miss a through-line a better reader would catch. That’s the honest tradeoff of running this pass for $0 instead of sending your entire history to a rented model to summarize. It improves the same way the rest of chanio does — you correct it, and the correction is itself something the next pass reads.