Agent-native · local-first · encrypted on your machine

Time Machine for Claude Code and Codex sessions.

Continue the exact session on any machine, any time.

UNLOSE / ANY MACHINE · ANY TIME · SAME SESSION

laptop $ unlose snap --push
✓ claude-code   session 8f21c3 · 42 files · 2.1 MB · sealed
✓ codex         session b04d77 · 18 files · 640 KB · sealed
  sha256 verified · encrypted before upload

── three weeks later · a different machine ──────────

new-laptop $ npx unlose init
✓ recovery code accepted · vault synced
new-laptop $ unlose continue 8f21c3
✓ session 8f21c3 restored · original session id preserved
  claude-code resumes 8f21c3 · full context intact

The continuity loop

Capture

unlose watch --install captures byte-exact session files on a schedule. When signed in, every healthy capsule is encrypted and pushed off this machine.

$ unlose snap --push
✓ local saved · encrypted sync complete

Prove

Every file is hashed; every capsule is verified when it comes back.

sha256 8f21c3 ✓
sha256 b04d77 ✓

Recover

restore brings the session back. continue hands it to its agent.

$ unlose continue b04d77
✓ handed back to codex

Agent-native

Your agent runs it.

Claude Code and Codex call unlose themselves: every non-interactive command speaks a stable JSON envelope, and the handoff back is the agent's own resume.

One command installs the skill

$ unlose integrate claude
✓ skills/unlose/SKILL.md · installed
$ unlose integrate codex
✓ skills/unlose/SKILL.md · installed

The same skill lands in each agent's own skills directory.

Non-interactive commands speak JSON

$ unlose snap --agent claude --json
{"ok":true,"command":"snap",
 "data":{"claude-code":{"sessions":3,
 "new":1,"updated":0,"unchanged":2,"error":0,"vanished":0},
 "vanished":{"claude-code":[]},"errors":[]}}

One stable envelope, progress on stderr, exit codes an agent can branch on.

The site has a machine twin

$ curl unlose.sh/skill.md
name: unlose
description: Capture, verify, and
  recover session capsules.

skill.md and llms.txt live at the root; an agent can learn unlose without a human.

One thing stays human on purpose: fresh init shows the only recovery code, so it refuses to run autonomously.

Trust boundary

Encrypted before it leaves.

your machine · plaintext, owner-only local vault

~/.unlose/vault/claude/8f21c3/
transcript.jsonl            readable
{"role":"user","text":"refactor auth"}

unlose.sh · no recovery key by default

8f21c3.capsule              2.1 MB
4qgm2vx9w3k1r8ozpq6ts0y5hj7n
recovery key on server:     none

Default

You hold the key. The recovery code stays with you and never reaches the server.

Optional

Host the recovery key. Optional recovery-key hosting lets the operator decrypt that account.

The recovery path

Recovery is one command.

restore puts the files back; continue hands them to the agent. On a new machine, init and your recovery code do the rest.

$ unlose restore <id>
✓ exact same-session recovery
  original session id preserved

$ unlose continue <id>
✓ session returned to its agent
  native Claude/Codex handoff

Straight answers

Why not just copy the session folder?

You can. unlose adds what a copy misses: hash-verified integrity, encrypted sync, and a native handoff back to the agent.

What if unlose disappears?

The vault on your machine stays plaintext and yours, and unlose export writes capsules to files you keep. Nothing needs this server to stay readable, and the CLI can point at any server you run.

What does the server ever see?

Encrypted capsules plus routing metadata: sizes, timestamps, session ids. Contents stay unreadable unless you turn on recovery-key hosting. The full security model.

Before the next update

Your coding sessions survive.

npx unlose init