The Proof.
Don't take our word for it. Here's the actual math.
We believe security architecture should be verifiable, not just trusted. Every claim on this page is backed by the actual cryptographic design.
The 90-second version
The Server
A Sky Full of Static
Imagine a thief breaks into a bank and gets your deposit box open. Inside, instead of your things, there's a solid block of steel. That's what our servers hold.
When you type your 12 words, you aren't logging into a website. There is no account to log into. You're unlocking something with a key only you have — we never saw it, and we never stored a copy. Without that key, everything we hold is .
And because there are no accounts, there are no folders with your name on them either. Your scrambled notes sit in the same shared storage as everyone else's, and nothing in that storage says which pieces belong to whom. So even a thief who took everything would get a pile of locked boxes and no way to tell whose is whose — let alone how to open one.
The real engineering
Storage holds one flat keyspace with no per-user index. Object keys are derived deterministically from the user's own key material, so the server can hand back a blob it cannot name, attribute, or enumerate. There is no account table linking a person to a row, because there is no account.
The practical consequence: a full database dump yields a set of opaque blobs and nothing that says which blobs belong together, whose they are, or what any of them contain. Correlation would have to be reconstructed from the ciphertext itself, which is the entire point of encrypting it.
Sync is switched off for the private beta. This describes the design, not a running service.
Verified against: pie_security/lib/src/doorman.dart · pie_core/lib/src/config/vault_config.dart
The Lock
Slow on Purpose, So Guessing Is Hopeless
Most apps turn your password into a key instantly. That speed helps the thief too — a fast computer can try billions of passwords a second. So we did the opposite of fast.
We run your words through , which is deliberately slow and deliberate about one thing in particular: memory. Before it will produce your key, it has to hold 64 MB of memory for a few passes. That's not a speed bump — it's a wall. To guess a million passwords at once, a thief doesn't just need a faster chip; they need a million times 64 MB of memory, all at the same time, for every single guess. Nobody has that, and nobody can buy it.
That little pause you feel when you unlock your vault? That's this wall being built, in front of you, every time. The delay you notice is the same cost a thief would have to pay — per guess.
The real engineering
Argon2id, 64 MB memory limit, 2–4 passes depending on tier, 256-bit output key. Parameters are verified against the shipped engine (argon2_ffi.dart).
Memory-hardness is the whole argument. A plain hash is embarrassing on a GPU because the attacker only pays for compute, which is cheap and parallel. Argon2id makes every guess occupy 64 MB for its duration, so N simultaneous guesses need 64 MB × N of fast memory. Scaling the attack means buying memory, not just silicon.
The visible cost is the pause on unlock. That pause is the control working — it is the same work an attacker must pay, once per guess.
Verified against: pie_security/lib/src/argon2_ffi.dart
The Math
Why Guessing Isn't a Computer Problem, It's a Physics Problem
Your vault is locked by . They're picked at random from a list of 2,048, which sounds small and isn't: twelve picks give you around 340 undecillion possible combinations. That's a 39-digit number — so big that it's more than the number of stars in the entire universe.
Now picture a computer that could try a trillion of those combinations every single second. No such machine exists — that's already far faster than anything ever built. Even at that impossible speed, trying every combination would take about 10 billion billion years. The universe has only been around for 14 billion. You'd need a billion universes, run one after another, to finish one person's words.
Every possible 12-word phrase
340,282,366,920,938,463,463,374,607,431,768,211,456
That is 340 undecillion. Now imagine trying to guess it; a billion guesses every second. Go on:
- Phrases tried
- 0
- Space covered
- 0%
Press the button. The percentage will not move in any way you can perceive.
Everybody on Earth — all 8 billion of us — each trying a billion phrases a second, working non-stop since the Big Bang, 13.8 billion years ago.
1.02%
Over 98% of the space is still untouched. That is what 2128 means.
Even every computer on Earth working together, guessing a billion times a second, would need longer than the universe has existed — by an enormous margin. 2128 is 2,048 words taken twelve times, minus a 4-bit checksum. That count is exact; the walls that stop an attacker are time and memory, not cleverness.
Could a cheat that? No. The best known shortcut is , and all it does is halve the work — like turning a 39-digit lock into a 20-digit one. Still impossible — and you cannot dodge it with a bigger or faster machine, either. The wall here is time, not cleverness: the space is simply too large to walk across.
That is the real guarantee. Not a promise from us — a limit set by the laws of physics, which apply to everyone equally.
The real engineering
128 bits of entropy, not 39 digits of decimal. 12 words from a 2,048-word list gives log₂(2048¹²) = 132 bits, conventionally treated as 128. The honest framing is key space, not a digit count.
Exhaustive search at 10¹² guesses/second takes about 1019 years. Grover's algorithm reduces the effective work to ~264 operations, which remains far beyond any buildable machine and does not touch the memory-hardness of derivation.
The energy floor is real but does not bite at this size. Landauer's limit sets a minimum energy to erase one bit (~2.8×10-21 J at room temperature). Counting through 2128 keys costs on the order of 1027 J; the Sun emits ~1044 J over its whole life. Energy only overtakes the Sun at roughly 2208 — so at 128 bits the binding constraint is honestly time, not energy. The floor that does bite is memory: a billion simultaneous Argon2id guesses at 64 MiB would need ~64 petabytes of RAM held at once.
Verified against: pie_security/lib/src/doorman.dart
Changing your words
If you think someone got your words, you don't start over — you change them.
Most apps treat “change your password” as a coat of paint. The old locked files are still sitting there, locked with the old key — so anyone who already copied them keeps a working copy.
Changing your words in Prevon actually re-locks everything. means every stored piece is unlocked with the old words and re-locked with the new ones, and the vault itself is re-keyed at the storage layer. It happens as one single operation: if any part fails, the whole thing doesn't happen, and your old words still work.
And once it succeeds, the old words are dead. They don't unlock your notes — or any copy someone stole before you changed them.
The real engineering
One rotation path exists in the shipped engine, and it always does both halves together: every stored row is re-encrypted under the new derived key, and the vault is re-keyed at the storage layer. There is no fast/partial mode.
The operation is atomic — if either half fails, rotation does not complete and the old phrase remains valid. Once it returns success, the old phrase unlocks nothing, including ciphertext captured before the rotation ran.
An optional step-up gate can require the current phrase on top of PIN or biometric before a rotation is allowed to start, which closes the “unlocked phone left on a table” case.
Verified against: pie_brain/lib/src/security/rotation_orchestrator.dart
Sync storage — not live yet
One Unlabeled Pool, Not a Filing Cabinet
Sync is switched off for the private beta. Nothing below is a running system today — it is the design we are hardening, and it ships only once it has survived the beta.
Most cloud sync services keep your files in a folder tied to your account — which means a breach, a subpoena, or a rogue employee only needs to find your folder, not break your encryption. Ghost Sync is designed so there is no folder to find: every user's encrypted notes sit in one shared, undivided pool with nothing that marks which pieces belong to whom. Finding your own data again is a calculation your device performs from your Recovery Seed, not a lookup against an account record we hold. We also pad every encrypted note to a standard size, so a short note and a long one look the same from outside — see for the exact buckets. And because there's no account record to check for inactivity, storage that's gone unpaid and unrenewed simply expires on its own — nobody has to go looking for whose data to remove, because nothing points back to a “who” in the first place.
The real engineering
Build status, precisely: the relay is a Cloudflare Worker (D1 + R2) that is deployed and running, and the client side is wired up — but shipping builds never call it, because enableNetworkSync = false makes every sync path return early. The service exists; your app does not talk to it.
There is no account system at all. Your identity is the twelve words: they derive the vault id and the key on every device, so nothing on the server is a record of a person. Device discovery runs through /v1/discover-chains and /v1/claim-device-slot against per-device chains, rather than a lookup table keyed to an account, because there is no account to key.
The honest gaps. Each encrypted envelope is padded to fixed buckets — 1 KB, 256 KB, 2 MB, 5 MB — so its length leaks little. There is no relay-level cover traffic: timing and traffic volumes between devices are not hidden. Quota is 50 MB per identity, and usage billing is deliberately deferred rather than shipped.
Transferring to a second device today works two ways, both real: a direct device-to-device transfer over your local network, or simply typing the same twelve words into the new device.
Read the full walkthrough of how this pool and device discovery fit together on the Ghost Sync page.
How We Compare
Not all privacy tools are the same
Most popular note apps compromise on privacy. Here's how Prevon compares.
| Feature | P Prevon | N Notion | K Google Keep | Apple Notes | ··· Others |
|---|---|---|---|---|---|
| We cannot read your notes | |||||
| On-device AI processing | |||||
| No account required | |||||
| Sync that stays locked in transit | |||||
| Device-to-device sync, no cloud in the middle | |||||
| No note content sent to a cloud AI | |||||
| No content used to train third-party AI |
✓yes · × no. Verdicts are read from each vendor's own published documentation as of , and describe the default setup: Apple Notes only gains encrypted sync when Advanced Data Protection is switched on, and Apple Intelligence is opt-in and unavailable in some countries. “Others” is a category rather than one product, so no single answer fits it. On the cloud-AI row: Notion AI and Google Keep's Gemini features process your content on their servers, and Apple Intelligence sends harder requests to Private Cloud Compute — so none of the three keeps AI processing entirely off the network. If any of this changes, it is on us to correct the page.
Digital Cremation
Wiping the key, not hunting the data
When you throw something away in real life, it's gone. On a phone, it isn't. Deleting a file usually just removes the name, and phone storage quietly moves “deleted” data somewhere else to save wear on the chip — so the old copy can sit there, perfectly readable, for weeks. That's true for , and it's why “erase” buttons often don't mean what they say.
So we don't chase the data down. We destroy the one thing that could ever make sense of it: the key. The moment you wipe your vault, the key is gone from your device, and every copy of your notes — the one you can see and the hidden ones you can't — turns into static at the same instant. There's nothing left to erase, because nothing left can be read.
The real engineering
Wear levelling makes overwrite-based erasure unreliable: a write to a logical block lands wherever the controller chooses, so the original physical copy can survive indefinitely and is unreachable by software.
The design removes that dependency. The wrapping key is destroyed on-device at wipe time, which renders every copy — the active one, snapshots, and blocks the controller relocated — uniformly undecryptable. Erasure becomes a property of key destruction rather than of storage media cooperation.
Verified against: pie_brain/lib/src/handlers/nuke_vault_handler.dart · pie_security/lib/src/doorman.dart
Protection
How unlocking actually works
| Level | Keys required | Best for |
|---|---|---|
| Quick unlock | Your phone (PIN or biometric) | Fast everyday access without retyping your phrase |
| Full unlock | Your 12-word Recovery Seed | Opening your vault on a new device, or after a reset |
| Step-up re-auth | Your current 12-word phrase, on top of PIN or biometric | Blocking a phrase change from an unlocked, unattended device |
Your are the only thing that can rebuild your vault on a new device. We never see them and never store them — so if you lose both your device and your words, nobody, including us, can get your notes back. We can't make an exception even if we wanted to. That is also why nobody else can get in: there is no spare key to find, because there is no spare key.
Native app
Why Prevon Will Never Live in a Browser
We could build a web version. It would be cheaper and easier. It would also quietly undo everything on this page.
A website is not one thing you install — it's code that gets re-sent to you every time you open it. So if anything between you and that server is tampered with, even for five minutes, the code running on your screen can change and you would never see it. A real app is different: it's a signed package that sits on your device, and updates arrive the same signed way. You can check it. You can't do that with a page that rebuilds itself on every refresh.
There's a second reason. A browser tab shares its world with every other tab, extension, and script you have open — and browsers treat data stored by a website as disposable, something to clear when space is tight. Your notes should not be disposable. Prevon runs in an that nothing else on your device can look into, and it writes your files exactly once, where they stay until you decide otherwise.
Convenience and control aren't always the same thing. We picked control.
The real engineering
The threat is update-channel integrity, not transport. A web app re-fetches its code on every load, so compromise of a server, a CDN edge, or DNS for even a short window injects code that runs with the user's trust — and nothing in the page can detect it, because the page is the thing that changed.
A native build is a signed artefact: the code is fixed at install, updates arrive through a signed channel, and the binary can be inspected. Storage differs too — a native app writes durable files under OS sandboxing, where a browser treats local data as a cache it may evict.
Verified against: apps/pie_notes — native build & OS sandboxing
How it works
Your data, encrypted
Security audits welcome. Our architecture is designed to be verified by security researchers.
This is the design. Sync is switched off for the private beta, so today nothing actually travels that middle leg.
Encrypted locally
Your notes are encrypted on your device before anything is sent
Only scrambled data moves
Our servers see encrypted data with no way to decrypt it
Decrypted locally
Only your devices with the right keys can decrypt the data
The fine print
Where It Ends — and Why That's the Point
Everything above is something we promise. This is the same honesty turned on the edges: the exact places the protection stops. A security researcher would find these in ten minutes — read them here first, in plain words.
Honest edge
Your notes never leave your device
Sync is built and the server side is running, but a shipping build short-circuits every call — so today nothing you write leaves the device you wrote it on. The switch exists; it is deliberately off.
enableNetworkSync = false
Honest edge
We see traffic, never notes
We cannot read your notes. But a server holding your encrypted blobs can still tell that some device sent some amount of data at some time. We do not disguise timing or traffic patterns — there is no cover traffic today, and we would rather say that than imply otherwise.
no cover traffic
Honest edge
Your device is the one thing we cannot protect
We protect your notes at rest and in transit. If malware is reading your screen or your memory while the vault is unlocked, no encryption scheme on Earth helps — that is true of every encrypted app, not just ours.
out of scope by design
Honest edge
There is no spare key — including ours
Lose your twelve words and there is no reset link, no recovery, no support path. That is the same property that makes a back door impossible. It is a feature with a sharp edge, not a flaw we can patch on request.
no key escrow exists
Honest edge
AI and sharing: built toward, not shipped
On-device AI and shared notes are not delivered yet. The AI runs against a local model path, and the sharing cryptography exists without a user interface. We do not count either as protection until it actually ships.
phases not started / crypto-only
Honest edge
Standard building blocks, audit still to come
We use well-tested, standard cryptography instead of rolling our own, which removes the most common failure mode in software. It is not a substitute for a third-party audit — we have not had one, and we will keep saying so until we do.
no external audit yet
A guarantee you can see the edges of is worth more than one you have to take on faith. None of these is a weakness in the design — they are the shape of it.
Beyond this page
