Zephr
Start free

Continuity / Slipstream

Hand off mid-task,land mid-thought.

Switching tools normally means re-explaining the problem. Slipstream seals what the session knows into one signed envelope, hands it to the next agent, and lets that agent verify every claim before it uses one. It works exactly once, and it fails closed.

Shipped · Continuity Format v1ADR-014Ed25519 + destination HMACE2E-proven
The gap nobody fills

There is no interchange format for what an agent learned.

Every AI coding tool has a memory now. None of them can hand it to another one. That is not a missing integration — it is a missing format, and it is the part of the problem that survives any single vendor closing its own loop.

  • The tool switch

    Cursor cannot read what Claude Code learned this morning. Each tool keeps a private, machine-local scrap and neither can prove anything about the other’s.

  • The machine switch

    The context lives in a file on one laptop. Opening the same project on a second machine starts from nothing.

  • The pasted blob

    The workaround is copying a context summary into a new chat: unsigned, unscoped, unverifiable, and stale the moment a cited file moves.

The mechanism

One command out, one command in, six checks between.

Nothing here is a synchronization protocol. It is a single object, signed at one end and verified at the other, with a consumption ledger that makes replaying it impossible.

  1. 01

    /zephr handoff

    One command in the origin tool. Zephr gathers the live beliefs, their anchors, their review states, and the scope you are actually admitted to.

  2. 02

    Seal the envelope

    The payload is serialized into Continuity Format v1 and signed with Ed25519. The signature covers the anchors, not just the claims, so swapped evidence is detectable.

  3. 03

    Bind it to one destination

    A destination HMAC ties the envelope to the receiving session. An envelope lifted and presented elsewhere does not open.

  4. 04

    zephr resume

    Open the other tool — on the same machine or a different one — and resume. There is no export ritual and no copy-paste of a context blob.

  5. 05

    Verify before reading

    The receiving agent checks the signature, the binding, the scope, the tool contract, and every anchor before it uses a single claim.

  6. 06

    The capability revokes itself

    Consumption is an atomic compare-and-swap against a ledger. The envelope works exactly once; a replay fails closed rather than degrading quietly.

The journey

Claude Code → Cursor, on another machine.

The same envelope, at three moments: sealed at the origin, in transit as a signed object, and opened by a receiving agent that checks everything before it reads anything.

Origin · Claude CodeVerified

Everything this session established

Seven beliefs, nineteen anchors, three review states, and the scope the session was actually admitted to. Not a summary of the conversation — the records themselves.

  • 7 beliefs4 verified · 2 unreviewed · 1 carried with an open challenge
  • 19 anchorspath + line range + commit + content digest, each
  • 1 scope proofapps/billing, binding epoch 14 — not "the whole repo"
  • 3 review statesthey travel with the beliefs, so nothing is re-litigated
  • 1 allowed-tool contractrecall, why, verify — no write tools at this boundary
Claude Code · sonnet · macOS
Destination · Cursor1 anchor challenged

Opened, verified, and carried forward honestly

The signature and the destination binding both check out, and the capability is consumed. One cited file moved after the envelope was sealed, so that claim arrives with an open challenge rather than as settled fact.

The receiving agent is one contract minor version behind. It downgrades visibly and tells you which capability it dropped — it does not execute against a surface it only partly understands.

Signature validEd25519

Illustrative example — not live data.

The specimen

The envelope, opened up.

What is inside, what the signature covers, what the receiver checks, and what happens the second time the same capability is presented.

Envelope zsx_01HQ9B7V4N3PDR

Continuity Format v1: one signed object carrying beliefs, anchors, review states, a scope proof, and the tool contract it expects. The signature covers all of it.

Envelope · sealedVerified

Sealed for transport

Format
Continuity Format v1
Origin
Claude Code · sonnet · macOS
Destination
Cursor · linux · another machine
Scope
apps/billing @ 8d13ba0
Digest
sha256:c74e1b09f36a25d8
Signature
ed25519:9f4c2ab7…d013
Binding
hmac-sha256:5b81e0c7…a4f3
Issued
2026-03-04T13:52:18Z
SignedEd25519
Receiver · verification2 findings

Six checks before a single claim is read

  1. Ed25519 signature over the whole envelopeVerified

    Valid — payload and anchors unmodified in transit

  2. Destination HMAC bindingVerified

    Valid — this envelope was issued for this destination, not replayed from another

  3. One-time capability, CAS-consumedVerified

    Consumed at 14:07:41Z — a second presentation now fails closed

  4. Scope binding + epochVerified

    apps/billing @ epoch 14 — matches the receiving session admission

  5. Tool-contract compatibilityStale

    Receiving client is one minor version behind — downgrades visibly, never silently

  6. Anchor revalidationStale

    18 of 19 anchors resolve; 1 file moved and is carried as an open challenge

4 pass · 2 carried as open findings
Capability · replayBlocked

The same envelope, presented a second time

Consumption is an atomic compare-and-swap against a ledger, so the second presentation loses the swap and is refused outright. The signature is still valid; the capability simply no longer exists. A one-time credential that merely warned on reuse would not be a one-time credential.

Capability consumedEd25519fails closed — never degrades quietly
Handoff · E2E-provenCross-device resume · cloud registry pendingPublished interchange spec

Illustrative example — not live data

What Slipstream owns

Signed continuity, and the guarantees that make it usable.

Six of these are shipped and proven end to end. Cross-device resume is real locally and waiting on the cloud session registry; the published interchange spec is deliberately not drafted until two external tools have round-tripped the format.

  • Cross-tool handoff

    Shipped

    Claude Code to Cursor, Cursor to Codex, Codex to opencode. The receiving agent gets the same beliefs, review states, scope, and rules — not a summary of them.

    authenticated handoff E2E-proven · ADR-014

  • Ed25519 signatures

    Shipped

    The whole envelope is signed, anchors included. A modified payload fails verification instead of arriving as plausible context.

    Continuity Format v1

  • One-time capability

    Shipped

    Consumption is an atomic CAS against a ledger. The envelope opens once. A revoked or replayed handoff fails closed, visibly.

    atomic CAS consumption ledger · ADR-014

  • Destination binding

    Shipped

    A destination HMAC ties each envelope to one receiving session, so a captured envelope cannot be opened somewhere it was never issued for.

    destination HMAC-SHA-256

  • Allowed-tool contracts

    Shipped

    An envelope carries the tool contract it expects. A mismatch downgrades visibly and never executes silently against a surface it does not understand.

    tool contract v2 · ADR-004

  • Scope proof travels with it

    Shipped

    The envelope carries the scope it was issued under and its binding epoch, so the receiving side inherits a bounded admission rather than the whole repository.

    ScopeSnapshot + binding_epoch · ADR-009

  • Cross-device resume

    Local proven · cloud registry in progress

    Hand off on a laptop, resume on a workstation. The cloud session registry is what extends the proven local path across machines.

    gated on the cloud session registry (R3)

  • The interchange spec

    Planned

    A published format any tool can implement, so learned memory is portable by specification rather than by integration. Drafted once two external tools round-trip the format.

    spec draft gated on two external round-trips · ADR-014

Continuity you can verify, not just trust.

Slipstream carries what Memory recorded. Read how a belief is anchored in the first place, or take the whole architecture from the top.

How memory worksThe whole platform