Essay ยท August 2026
Why Passkeys Don't Travel
A passkey proves a key is present. The case for giving it a parent.
Passkeys earned the praise. The key never leaves the device, there is no shared secret to steal, and the phishing that works on passwords does not work on them. If the problem is stolen credentials, they are the best mass-market answer the industry has shipped. We build with them ourselves. What follows is about what they cannot carry.
But watch what a passkey actually proves. At registration, your device makes a key pair and hands the public half to one website. At sign-in, the site sends a challenge, the device signs it, and the site checks the signature against the key it kept. That proves one thing: the key that registered is present, and someone unlocked it. Everything else, who you are, what you hold, what you may do, lives where it always lived. In the site's database, behind the sign-in.
Start with where the check happens. The challenge comes from the server. The answer goes back to the server. The yes or no is computed on the server. A passkey resists phishing, and the sign-in it performs still cannot happen unless that server is up and reachable from where you stand. Put the passkey on an aircraft or a disconnected plant floor and nothing about it works, because the other half of the conversation is not there. "You Cannot Cheat Physics" covered what that dependency costs. The passkey does not remove it. It rides it.
Second, the scope. A passkey is bound to one domain on purpose. That binding is the anti-phishing feature: a key registered to the real site will not answer for a fake one. It is the right design for the web, and it means the credential cannot go anywhere else. The WiFi network is not a website. The turnstile is not a website. The disconnected site has no origin to bind to at all. Every new surface needs another relying-party relationship, another enrollment, or another server-side bridge. Passkeys sync beautifully across your devices. Across surfaces, they do not travel at all.
Third, the payload. There is none. A passkey asserts that a key is present. It carries no name, no tier, no entitlement, no consent. Every fact a transaction needs is a lookup after the sign-in, on the same server that ran the sign-in. "The Revenue That Never Existed" walked through what that costs the business: the customer is now authenticated, and everything they are still sits somewhere else, one lookup away.
Authenticator apps sit in the same box, one step lower. The six-digit code generates offline, which fools people into thinking the scheme is offline. Verification is not. The server checks the code, so the server has to be reachable, and a push prompt needs the network twice, once to reach your phone and once to carry the answer back. More proof at the same door, and the door is still far away.
Then there is the question underneath all three, which has nothing to do with travel. The passkey itself did not verify who you were. Registration binds a key to whatever assurance the account already had. Sometimes that is strong, a bank that checked an ID at the counter. Often it is an email link. Either way, the passkey adds possession, not identity proof. It proves the same person came back. It says nothing about who that person is. For a forum, fine. For anything where being wrong is expensive, the strength of the key is not the weak part.
Row by row, the split is clean.
| Passkey | Krutho credential | |
|---|---|---|
| Proves the right key is present | Yes, and does it well | Yes, by minting the passkey to do it |
| Survives phishing | Yes | Yes |
| Knows who the person is | No, inherits the account's assurance | Only exists because an identity was verified |
| Works with the network down | No | Yes |
| Verifies where the person stands | No, at the site's server | Yes, against local trust anchors |
| Reaches WiFi, gates, doors | No, one domain | Yes, a credential minted per surface |
| Carries claims | No | Tier, entitlement, consent, signed |
| Revocation reach | One site, nothing propagates | Kill the root, every surface dies |
The first two rows are the reason to keep passkeys. The rest are the reason they cannot be the foundation.
And none of that is why most people bounce off them anyway. The tap is lovely. Everything around the tap is not: which device holds the key, whether it lives in the browser or the phone or a password manager, the QR dance when you sign in on a borrowed laptop, and the cold sweat when the device is gone. Technical people lose track of where their own passkey lives. Normal users do not debug it. They back away, and take the password reset they understand. Notice where the difficulty concentrates. Enrollment and recovery. The two moments a credential should be handling on the person's behalf, and the two moments a passkey hands to them instead.
None of this makes passkeys the wrong tool. It makes them the wrong foundation. A passkey is an output: one credential, for one surface, doing one job well. The missing piece is the thing that mints it, and its siblings, from an identity someone actually checked. Verify the person once, against a government-grade credential they already carry. Mint the portal passkey from that verification. Mint the WiFi certificate from the same root. Mint the session token beside them. Each records its parent, and revoking the root kills every one of them through the signed revocation bundle the physics essay described. No new enrollment per surface. No orphaned credentials when something goes wrong. Lose the phone and recovery is the same identity check that started it, not a helpdesk call and a question about your first pet. One identity event, many outputs, one kill switch.
This is not an architecture diagram. In the Krutho lab it runs in code: a root credential minted from a live wallet verification, a working passkey derived from that root as one output among three, and a revocation that cascades to all of them on a verifier whose network calls are disabled. The passkey works fine in that system. It just is not load-bearing.
Identity that travels needs a credential that carries its own proof and its own claims. A passkey does neither, and was never meant to. Keep the passkey. Give it a parent.