Docs
Security
Your code and your conversations stay between your computers and your devices. The relay in the middle passes along sealed messages it cannot read, and each computer decides for itself who may talk to it.
Encrypted end to end
Every computer and every device has an Ed25519 identity key, made at first launch, that never leaves it: ~/.slashcode/key on a computer, readable by you alone, and the Keychain on an iPhone or iPad. Pairing is when a device and a computer learn each other's public key.
Each time a device connects to a computer, the two open a fresh channel:
- Each side makes a new X25519 key for this connection and signs it with its identity key. Each checks the other's signature against the key it got at pairing, so a relay can neither pass for your computer nor replay an old exchange.
- From the shared secret, HKDF-SHA256 derives two keys, one for each direction.
- Every message is sealed with ChaCha20-Poly1305 and numbered; the numbers only go up, so a message replayed or reordered does not open.
The computer takes nothing in clear: any message that is not a greeting or does not open is answered with a request to start over. A new connection, on either side, starts a new channel with new keys. Two of your computers talk through the same kind of channel.
What the relay sees
The relay is a service Slashcode runs. It links your computers and devices, so it knows:
- their public keys and ids, names and kinds (Mac, iPhone, iPad, browser);
- which devices reach which computers, and the account they belong to;
- who is online, when each was last seen, and who sends a message to whom;
- your plan, and the token an iPhone or iPad gives it for notifications.
Its database keeps public keys, names, links and last-seen dates, never content. What a message carries is sealed: the relay can neither read nor alter it. A message for a device or computer that is offline is dropped, not stored.
Devices sign in with your account. The relay checks the sign-in at each connection and closes it a minute after the sign-in expires, unless the device has renewed it.
Pairing codes
slashcode pair opens a pairing under two secrets: the 8-character code you can type, and a 26-character code carried by the QR. It lasts 15 minutes, works once, and burns after 5 failed tries.
Neither code crosses the relay. Each side turns the code into a slow key (PBKDF2-SHA256, 600,000 rounds), and only values derived from that key go through. The device and the computer each prove to the other that they know the code, bound to their own public keys, so nobody in the middle can stand in for either.
The QR also carries your computer's fingerprint: the app checks that the computer that answers is that one.
Known limit. The slow key makes guessing a typed code expensive, not impossible, for someone in control of the relay with a lot of computing power. The QR's longer code is out of reach of that: scan when you can.
New devices wait
A device paired with a code is trusted at once: typing it proves you were at the computer. Pairing also links the computer to your account, so your other devices can reach it by signing in.
A device that only signed in waits. The computer knows it but answers nothing until a device you already use allows it, in Allow a new device? or in Settings › Devices, or until you do from the computer:
$ slashcode devices$ slashcode devices approve <device-id>
Signing in to your account is therefore not enough to see your sessions. slashcode revoke, or Revoke in Settings, removes a device for good: the relay will not link it again, and it comes back only by pairing.
Notifications
Notifications pass through the relay and Apple. What they can read says only what happened and on which computer, never the session's title or anything it contains:
- Claude finished when a turn ends;
- Claude sent you a note when an agent notifies you, with the computer's name;
- Checks failed when the CI of one of your pull requests fails.
The preview you see on the lock screen, the session's title and the start of the agent's answer, the note, or the pull request and its failing checks, is sealed end to end. Your iPhone or iPad makes a key for notifications that never leaves it and gives its public half to each computer through the sealed channel. The computer seals each preview for that key alone, and the app opens it on the device just before it shows. Neither the relay nor Apple can read it. An older version of the app, or a preview that cannot be opened, shows only the agent and the computer.
A turn's notification goes out when it ends, never in the middle of one. Any of them goes out at most once per session every 10 seconds, and only when none of your devices has the app open, to the one you used last; an open app shows notes and failed checks as a banner instead.
Secrets kept out
Before writing a session's history, the daemon masks obvious secrets in tool titles and output, in permission questions and in the output of ! commands: API keys and tokens of known shapes (sk-…, ghp_…, AKIA…, xoxb-…, JWTs and more), private keys, passwords in URLs, and values assigned to names like API_KEY or password. They show as «redacted». It catches the usual shapes, not every secret, and leaves the agent's own words as they are.
An API key you give an agent from the app stays on that computer, in a file only it can read, for that agent alone; it never comes back to a device. Error reports go through the same masking; see automatic error reports.