Months of context. One file.
Everything your AI learned about a project — the task, the decisions and why you made them, the files that matter, the traps you already hit — written to a single portable file. Hand it to a teammate and their first session starts where yours left off, not at zero.
Onboarding, as a file transfer.
The knowledge that usually lives in one person's head and three Slack threads, made portable.
One command writes your project's accumulated memory to a .dawn file: the brief, the decisions and why they were made, the knowledge graph, hot paths, debugging findings, commands, and the board.
It is a file. Commit it, attach it, drop it in a channel. A Trail records the repository and the exact commit it describes, so nobody has to guess how current it is.
Merge it into a new project or one you already have. Nothing you already knew is overwritten — an incoming value only fills a gap it finds empty.
Open it in a text editor. That is the whole trick.
A .dawn file is plain JSON. Not encrypted, not obfuscated, not a container you need our software to open. Diff two of them in git and read what changed. Write your own reader in an afternoon — the checksum is a SHA-256 over a documented canonical encoding, so anyone can verify a Trail without us.
Your memory is not a hostage. If a format only holds you because it is hard to leave, it was never worth staying for.
{
"format": "dawn",
"format_version": 1,
"manifest": {
"title": "Sync Loop",
"source": {
"repo_url": "https://github.com/acme/sync-loop",
"commit_sha": "a1b2c3d4e5f6...",
"pinned": true
},
"counts": { "decisions": 9, "graph_nodes": 26, "paths": 4 }
},
"content": {
"brief": { "current_task": "Harden the extraction retry path" },
"decisions": [
{
"summary": "Store context as JSONB, not normalized tables",
"reasoning": "The shape changes every few weeks and migrations were the bottleneck."
}
]
},
"checksum": { "algorithm": "sha256", "value": "…" }
}An import can only add.
Pulling in someone else's Trail should cost you nothing you already knew. If importing could overwrite, nobody would import twice — so it cannot.
An incoming value only lands where yours is empty. Every collision is reported rather than applied.
Their stack and your stack merge into one. You do not trade yours for theirs.
If you both define "migrate", yours stays and the difference is shown to you.
A card marked done in their project arrives in your backlog, not your done column.
Entities dedupe on identity, so a second import converges instead of doubling.
A Trail is private until you walk it through the gate.
What you are publishing is months of private project memory, assembled by an agent that was never told any of it would be public. Exporting is private and unscanned by design. Making one public is a separate, deliberate act.
The scan runs on our side, on the exact bytes about to go public. A scan your machine ran is a courtesy, not a pass.
Credentials, email addresses, home directory paths, account numbers, money, and names. Each one is resolved individually.
Bulk approval is refused by name. Keeping a high-severity finding costs you a written reason, per finding.
Each decision is bound to the text it approved. Change the field and it goes back in the queue.
Unpublishing removes a Trail from the gallery. It does not recall copies already downloaded, forked, or indexed, and we say so in the product rather than letting you assume otherwise. If something leaked, rotate it.
Three real Trails. Open them in a text editor.
Exported from real projects and pushed through the same publish gate you would use, findings and all. No sign-up to download, because a format you cannot inspect before committing to is not open.
The context sync loop and the services around it — retries, merge semantics, and the landmine that breaks npm ci.
The Trails feature itself, mid-build: why the format is plain JSON, why import cannot clobber, and two gate bugs found the hard way.
The public site and its landing pages, including the decision to publish an unflattering measurement.
Nobody has published one yet — the gallery opens with the feature. Until then these three are examples, exported from real projects through the same redaction gate you would use. Download one and open it in a text editor; it is plain JSON, and that is the point.
Want yours listed when it opens? Start free and build the context first — a Trail is what your project already knows, not something you write.
A markdown file answers everything. It just costs more to read.
We tested our own premise before selling it. Nineteen questions, asked against a Trail and against a plain markdown rendering of the exact same content, with the markdown written to be as good as we could make it.
Markdown answered all nineteen. So we will not tell you it cannot. What it cannot do is answer them cheaply, and context is the thing your agent runs out of.
Every figure is emitted by our own test suite, not written by hand. Sort by cost and the weakest case for us sits at the bottom: looking one fact up is a tie, and markdown is often cheaper.
Stop re-explaining your project.
DeerDawn keeps the brief current while you work. A Trail is what you hand someone when they need all of it at once.