Security and encryption
Last updated: 23 September 2026
This is the page the encryption claim points at. It exists so the claim can be checked rather than taken on faith, and so the parts that are not covered are as easy to find as the parts that are.
We have been wrong about this before. Earlier versions of our privacy policy claimed encryption we did not ship — inherited copy from the project this app was forked from, rebranded without being re-verified. That correction is still on the Privacy Policy, and it stays there. It is the reason this page lists the gaps first-class instead of in a footnote.
The short version
When end-to-end encryption is active on a session, its chat messages and terminal output are encrypted on your own devices, and our servers hold only ciphertext for them. The keys are generated on your devices and the private halves never leave them.
It is not the case that everything in Mycolab is end-to-end encrypted. Session titles, project paths, machine names, timestamps, the names of the files you open, files you upload to artifacts, and broadcast notifications are not. Some of those are merely not built yet and some cannot work by construction — the sections below say which is which, because a gap we intend to close and a gap we cannot are not the same promise.
What is end-to-end encrypted
- Chat messages — your conversation with the agent, sealed under a per-session key.
- Terminal output — the output of commands run in a session, sealed under a separate per-terminal key, minted per terminal rather than per session.
- Terminal input — what you TYPE into a session's terminal. Listed separately from the output above because until September 2026 it was NOT covered: we encrypted what the terminal printed and not what you typed into it, so a password typed into a session we described as encrypted was visible to us. That gap is closed.
- Secrets you save — when you store an API key or other credential for a machine, the value is encrypted to that machine and we never see it. (Reading them back was already safe: the machine sends only a masked preview, never the value.)
- Every call your app makes to one of your machines — the arguments AND the reply. Saving a secret and terminal input are called out above because they were the worst of the gaps and landed first, but there is no longer a short list: the exemption list is empty, so a call is encrypted unless the machine at the other end published no key. What stays visible is the routing envelope — which machine, which method name, when, and how big.
- File contents — the files in a session's folder, which you browse and edit in the app. These do not live in our storage at all: they sit on your own machine, and the app reads and writes them by streaming the bytes through our network. Those bytes are now sealed in both directions, chunk by chunk, so seeking into the middle of a large file and resuming an interrupted upload still work. The file stays plaintext on your own disk — deliberately, because the agent has to read it. Two limits worth knowing: the names and paths of the files you open are in the request address and remain visible to us, and a preview of a file over 64 MB is refused rather than shown, since showing it would mean fetching it in the clear.
All of it uses AES-256-GCM, bound to the address of the thing it belongs to — a stream, a call, or a byte offset in a named file — so a sealed record cannot be replayed somewhere else and still open.
What is not end-to-end encrypted
Stated plainly, because this is the half that gets buried. It is split by why, because "we have not built it yet" and "this cannot work by construction" are very different promises and a single list hides that difference.
Not covered today — and there is no technical reason it can't be
These are ordinary backlog, not limits. We list them separately so the gap is a commitment rather than a shrug:
- Broadcast notifications — the free-text notices an agent or a machine publishes to your other devices ("build finished", "needs your approval"). These go through our publish/subscribe channel as readable text. Nothing about the design prevents sealing the message body while leaving the routing label readable; it is simply next rather than done.
- Files you upload to artifacts — the separate artifacts/resources feature stores files in our object storage on purpose, and we can read those. This one is a deliberate trade rather than a backlog item: you chose storage we host, and encrypting it to a key we cannot hold would make it storage you could not share or serve.
Two entries left this section in September 2026 rather than being fixed in place, which is worth stating because a page like this is usually edited in the safe direction. Service calls and file contents were both listed here as unbuilt; both are now encrypted and have moved up to the covered list. The file-contents entry used to explain at length why it was the *hardest* of these items — seeking into a large file, resuming an upload, and image previews that hand your browser a plain URL which cannot decrypt anything. All three were real, and all three are what the chunked format and the new preview path exist to solve.
Not covered because of how the system works
- Session and machine metadata — session titles, project directory paths, machine identifiers and names, lifecycle state, and the timestamps and sizes of messages. We can see that a session happened, on which machine, in which directory, and how much was said — even when we cannot read what was said. This one is genuinely hard rather than merely unbuilt: our servers merge edits to this state, which means they have to be able to read it. Encrypting it means redesigning how that state is shared, not adding a cipher.
- Scheduled work — a workflow's schedule has to be read by us to know when to run it. A time we cannot read is a time we cannot act on.
Not covered because you asked us to publish it
- Anything you publish — a served site, an exposed HTTP endpoint, an MCP attachment. Publishing takes content out of the envelope; that is what publishing means.
- Your account details — the email address you sign in with, and ordinary connection metadata (IP address, request headers) that any web service receives.
When encryption actually turns on
Two conditions have to hold. If either does not, the session is left unencrypted rather than half-encrypted or broken:
- At least one device in the workspace must have published a key. Sessions are sealed under a single key held by everyone the workspace is shared with, so with no published key there is nothing to hold it — and a session sealed to no one is one nobody can open, which is worse than an honest "not encrypted". Signing in on a device publishes its key.
- The workspace must have it enabled. Encryption is rolled out per workspace.
This changed on 23 September 2026, and the change is worth stating because it reversed something we previously told you. Until then a session key was wrapped individually to each of *your own* devices, once, when the session was created. Two things followed. A device that had published no key at that moment could never read that session, even after publishing one later — a permanent exclusion we described here as a trade-off. And, more seriously, a session shared with another person was reachable by them and unreadable, because their devices were never in the recipient list at all.
Both are now gone. A session key is sealed under a key held by every device of every workspace member and by every sharing link, so anyone admitted later can read what came before, and publishing a key on a device admits it to everything rather than to future sessions only.
The honest cost of that, stated plainly: one key now opens an entire workspace rather than one session, so it matters more than it did that the devices on the list are really yours. That is what the device list and the fingerprint you compare when enrolling a machine are for.
Sessions encrypted under the previous scheme cannot be converted — the old keys are held only by the devices they were wrapped to. Those sessions stay readable on those devices and show as "encrypted under a previous scheme" elsewhere. Create a new session to share one.
There used to be a third condition here — "new sessions only" — and it was not accurate. What is true is narrower and worth stating exactly: we do not retroactively encrypt anything we already received. Messages sent before your account had encryption stay readable by us, permanently, and re-sealing them would be theatre — we already have them. But an older session is not frozen: once it is opened by an up-to-date client it gains a key, and everything written into it after that point is sealed. So a long-running session can be readable in its early part and not in its later part, and the lock in the app means "this log is being sealed now", not "none of this was ever visible to us".
For the encrypted calls above there is one more condition, and it is worth stating because you can observe it: the machine you are calling must have published its public key. A machine running software older than this feature has not, so calls to it fall back to the unencrypted path rather than failing. We chose that over refusing to talk to your own computer — but it means "this call was encrypted" depends on the machine at the other end, not only on your account.
So turning encryption on does not claw back anything we have already received. It changes what happens next.
Keys, devices, and recovery
- Every device generates its own key pair, and the private half never leaves that device.
- We do store key material — but only in wrapped form, and we hold no way to open it. Your account key is generated on your device and wrapped separately by your passkey, by your recovery code, and by each enrolled device. Those wrapped blobs sit on our servers, which is what lets you add a new phone or recover an account without us ever holding a usable key. It is the same shape a password manager uses. We say this explicitly because "the keys never touch our servers" would be the easier sentence and it would not be true.
- Each session gets its own data key, sealed under a key belonging to the whole workspace. That workspace key is wrapped separately to each enrolled device and to each sharing link, which is what lets a new phone — or someone you shared with — read a session without any of your machines being online.
- A sharing link carries its own key, in the part of the URL after the
#. That part is never sent to us: we can see that a link exists, count its uses and switch it off, and we cannot read what it opens. It also means the link only works complete — a copy with the#…trimmed off will let someone in and show them nothing, and that a link's key lives on the device that made it, so a link created on your laptop cannot be re-copied in full from your phone. - Switching a link off stops access immediately, and then retires the key. The credential dies at once, so the holder can no longer reach anything. Separately, the next time one of your devices is online it replaces the workspace key with a new one that the removed link does not have — so anything written from then on is out of its reach. What neither step can do is un-read what was already read; nobody can take a copy back.
- Removing a device does the same. You keep your history: the old key stays available to your remaining devices, because messages are not re-encrypted when a key is replaced. Only what comes next uses the new one.
- A recovery code is the fallback if you lose every enrolled device. If you lose all devices and the recovery code, we cannot recover encrypted sessions for you. That is the cost of us not holding the keys, and it is not a defect.
- Removing a machine stops it receiving keys for future sessions. It does not retroactively revoke the sessions it already holds keys for — it has already read them.
What this does and does not protect against
- It does protect the content of encrypted sessions from us, from anyone who obtains our stored data, and from a lawful order served on us — we cannot produce plaintext we do not have.
- It does not protect the metadata above, which we can still see and could still be compelled to produce.
- It does not protect you from someone with access to your own unlocked device, or from the agent itself sending content somewhere you told it to.
- It does not make us unable to see future content. We ship the client. A future version could behave differently; the defence there is that the code is open and this page is dated.
How to check it yourself
- In the app — an encrypted session shows a lock beside its name in the session list. It appears only on positive evidence: the session's log is encrypted and this device holds the key. A session whose state has not been determined shows nothing at all rather than guessing.
- In the source — the sealing and key-wrapping code is public in the repository, as is the design that produced it.
Everything else that protects your data
These apply to all sessions, encrypted or not:
- Encryption in transit — TLS (HTTPS / WSS) on every connection between your devices, our edge, and your machines.
- Encryption at rest — storage is encrypted at rest by the provider.
- Workspace isolation — each workspace is a separate, single-tenant object; cross-workspace access is denied by default.
- Scoped, revocable tokens — bound to one workspace and one permission level; authorization fails closed.
Reporting a vulnerability
Email oeway007@gmail.com. Please include enough detail to reproduce it. We will confirm receipt, and we would rather hear about a problem than have it stay quiet.