How it works
Two ideas do all the work. Sync is DAG replication — a synced filesystem and a version-control timeline are the same problem underneath. And the run is the unit of meaning — an agent's work as one object (prompt → plan → edits → test → kept|reverted), not a pile of uncommitted files. The Mac app ships the file half today. The run, transcript included, is recorded by the CLI and hook.
timestore records the run as a capsule — prompt, plan, edits, test outcome, and whether the work was kept or reverted. The file diff is a shadow cast by that object, not the object itself. Replicate the capsule and the files come with it.
Sync is DAG replication. The diagram is the open-core run, recorded by the CLI. Hosted early access syncs files along that arc. Private accounts encrypt them on your Mac before upload; keys are unlocked by OPAQUE sign-in. Standard accounts are not end-to-end encrypted. The Mac app does not attach the transcript. Solid = present. Live process state never resumes.
1 Capture
You never have to remember to commit. Chronos captures file changes continuously. The agent, prompt, model, and transcript are attached when the CLI and hook record the run — that recording is not in the Mac app. A checkpoint then flushes files, transcript, and provenance as one object, on the machine where the CLI is running.
That provenance is a real data model: every change carries a receipt. (We record what an agent claimed and whether tests passed — conflict-resolution efficacy across runs is not yet independently verified, and we say so.)
Chronos autosave — live Provenance data model — live
# nothing to stage, nothing to remember
$ eidos coordinator serve --port=4399
serving on 127.0.0.1:4399
# Chronos captures every change as it happens,
# tagged with the run that produced it
$ eidos checkpoint --flush
recorded run 666e8a4c… (files + transcript + provenance)2 Sync
Both are replicating a content-addressed DAG: nodes are immutable blobs named by their hash, edges are history, and "are these two places in sync?" reduces to "do they hold the same nodes?" Content addressing makes replication cheap and verifiable — a fetch is checked against the hash it claims to be, so a corrupted or tampered byte fails closed rather than landing silently.
The piece that makes this durable and always-on is the coordinator. The
open core ships a loopback coordinator you can run with zero cloud and zero credentials —
and a single conformance-tested CoordinatorContract that any backend
implements. The hosted coordinator timestore runs is that same contract, made durable and
reachable from every machine you own.
Honest limit: the loopback coordinator is in-memory and non-durable — it forgets on restart, by design. The hosted coordinator (Convex / R2 / NATS) is operating in early access and syncs files across Macs you sign in. It does not, by itself, record an agent transcript. Trusted / FSKit does not ship in the Mac app.
Loopback coordinator — live CoordinatorContract — conformance-tested Hosted backends — live (early access)
3 Resume
Paste the run id into a second process and the working tree is reconstructed from content
hashes, conversation attached. diff -r returns nothing. That is reproducible
in the open core today, cross-process, one machine, zero cloud
(cli/test/checkpoint-resume.ts). Hosted early access puts the files on another
Mac. It does not record the transcript for you.
In the open core, encryption is on the standard paths by default. The coordinator stores only ciphertext with paths redacted; a key-holder resumes transparently, a non-holder fails closed. You hold the keys on Private accounts and in the open core. Private accounts encrypt Drive content on your Mac before upload; keys are unlocked by OPAQUE sign-in. Standard accounts are not end-to-end encrypted: the operator can read Standard-account Drive content.
Honest limit, printed on every resume: resume rehydrates your files and your transcript — not live process state. RAM, open ports, and running servers are not restored. The tool tells you this itself; we don't hide it.
CLI resume — one machine File sync — early access Transcript resume — not in the DMG
$ eidos resume 666e8a4c /tmp/restore
2 file(s) rehydrated → /tmp/restore (byte-identical)
$ diff -r /tmp/proj /tmp/restore
# (no output — byte-for-byte identical)
honest_limit: files + transcript rehydrated exactly;
LIVE PROCESS STATE (RAM, ports, servers) is NOT restored.They sound similar and they are not. One lets you travel the timeline you have; the other keeps what the timeline would otherwise lose.
The continuous autosave timeline. Because every change is captured as it happens, you can scrub backward and forward through your run's history — no commit ritual, no lost work between saves. Chronos is the present and the path you took to get here.
Chronos autosave + time-travel — live in the open core.
A GC-proof ghost layer on the machine that saw the delete. When you delete or refactor code away, git will eventually collect it. Eidolon keeps a local record you can restore from this Mac, with undo. A deletion only another Mac recorded is not recoverable from here yet.
Deleted-file restore — live on the Mac that saw the delete. Not across machines.
We will not pretend the laws of distributed systems don't apply to us. CAP is real, and the honest design choice is the one we made.
When two timelines diverge, timestore preserves both sides and surfaces the conflict. It never silently merges. Today you resolve that by restoring an earlier point. Keep mine and Take theirs are not functional yet. That is the price of never having your code quietly overwritten.
The full LIVE / GATED / NOT BUILT ledger lives on the security page.
Recorded from the open-source CLI — two processes, one machine, zero cloud. Hosted early access extends the files to another Mac. It does not extend this transcript by itself.
In plain terms: close your laptop mid-task, open another machine, and your run — your code and the AI conversation — is already there, exactly. The two terminals below are the real proof; the line under each step says what just happened.
serving on 127.0.0.1:4399
One local process. No cloud. No credentials.
You do real work — an agent run, edits, a test.
recorded run 666e8a4c… → resume with: eidos resume 666e8a4c <dir>
One checkpoint captures files + transcript + provenance as a single run.
2 file(s) rehydrated → /tmp/restore (byte-identical)
A second process on this machine. The Mac app does not record this transcript — the CLI and hook do.
(no output)
diff -r returns nothing. Byte-for-byte identical.
honest_limit: files + transcript rehydrated exactly; LIVE PROCESS STATE (RAM, ports, servers) is NOT restored.
And it tells you the truth: your bytes and your conversation — not a running server.
note: this local coordinator is in-memory — it forgets on restart.
The hosted coordinator is the durable one. It is operating in early access, for files. This demo is still the CLI.