How a podcast about audit logs became a patent about identity
4 May 2025 · one insight · one day to working code
The insight did not arrive during a security review. It arrived while listening to a podcast about audit logs — one that had been generated, by a machine, from a pile of notes about HIPAA compliance.
The context matters more than it sounds. The preceding year had been spent on systems architecture, and specifically on three things that turn out to be the same thing viewed from different angles: controlled domains — who is permitted to know what; ontologies — how a system agrees with itself about what things are; and provenance — how anyone later establishes where a fact came from. The intended destination was a healthcare application, which is a domain that forces all three at once and forgives none of them.
Healthcare is a useful teacher because it will not let you be vague. An audit log that cannot say who did a thing is not an audit log. And “who”, in every system anyone had built, resolved to the same disappointing object: a row in a table, joined by a token that someone had memorized or a device had stored.
The question arrived in one piece, and it was almost embarrassingly simple.
If a language model can recognize vector embeddings,
and embeddings can be stories,
why can’t we compare stories?
Every part of that was already true and already deployed. Embedding text into a high-dimensional vector was ordinary. Measuring the angle between two such vectors was a one-line operation. Semantic search had been shipping on exactly this arithmetic for years — type a query that shares no words with a document and still find it, because the meanings sit close together even though the strings do not.
The move was not to invent a mechanism. The mechanism existed. The move was to point it at a question nobody was pointing it at: not “which document is this about?” but “is this the same person?”
Tell me a story. I will embed it. Later, tell me the story again. I will embed that too, and measure the angle between them. If the two accounts mean nearly the same thing, they came from someone who knows the same things — and I never needed either of them to be identical.
Passwords are deterministic. This isn’t. It has variability — and the variability is the point, not the bug.
A password is a function with two outputs. You either produced the exact string or you did not. There is no third answer, no partial credit, no notion of nearly. The comparison is a cliff: one side is total admission, the other total refusal, and the wall between them has no width.
Everything unpleasant about passwords descends from that shape rather than from any implementation flaw. Because the check is exact, the secret must be stored somewhere to check against — so it can be stolen. Because it is exact, it can be copied perfectly — so it can be replayed, and a stolen password used by a thief is indistinguishable from the same password used by its owner. Because it is exact, a human has to carry it precisely, which is why we forget them, write them down, and reuse them across services.
And because the check is a single instant, it says nothing about the next instant. The door opens and stays open. Multi-factor authentication does not change the shape; it stacks two cliffs and calls the pair a wall. Session tokens do not change it either; they extend one moment's answer across hours during which everything may change except the authorization.
The cliff is the problem. Not the length, not the entropy, not the rotation policy. The shape.
Replace the exact string with a story, and the cliff becomes a slope.
“I am a nurse practitioner at the county hospital and I am starting my shift” and “Starting my shift at the county hospital — I’m a nurse practitioner” are different strings. Character-by-character they share almost nothing in common order. As embeddings they sit at an angle of a few degrees, because they mean the same thing, and meaning is what the embedding encodes.
Measure that angle and you get a number — in the worked example that became the patent's illustration, 0.94 against an acceptance threshold of 0.85. Not a match. Not a failure. A measurement, with a value, against a threshold you can reason about, tune, and justify.
The consequences fall out immediately, and they are not small. There is nothing to memorize, because you are not reproducing a token — you are recounting something you know. There is nothing to steal that works on its own, because what authenticates is a coherent account rather than a copied string. And crucially there is now a gradient: the system can tell the difference between slightly off and badly wrong, which means it can respond proportionately instead of resolving everything to yes or no.
This is the part that turned an interesting observation into an architecture.
A story is not one thing. It is many elements, and it lives across a whole surface rather than at a point. So the comparison need not be all-or-nothing at the level of elements either. Miss one, stay coherent across the rest, and you are still recognizably yourself.
Forget the name of the ward. Get the shift time slightly wrong. Mention the colleague you always mention, in the role you always place them. Aggregate coherence across the remaining surface still clears the threshold, and you are authenticated — without ever having reproduced an exact token, and without any single element being load-bearing.
Read that sentence in the other direction and it becomes a security property rather than a convenience. If no single element is load-bearing for the legitimate user, no single element is sufficient for an attacker. Compromising one fact about someone buys a fraction of a score. To pass, you would have to be coherent across the whole surface — which is another way of saying you would have to actually know the things.
This is the inversion at the centre of the whole architecture. Conventional authentication is brittle for the user and brittle for the attacker in the same place — one exact string admits or refuses both. Coherence over a manifold is forgiving for the user and unforgiving for the attacker, because the two of them fail in different directions. The legitimate user degrades gracefully. The impostor has to be right about everything at once.
The provisional application was filed on 4 May 2025 — Narrative-Based Semantic Authentication System Utilizing Contextual Embedding and LLM Inference. The insight and its filing share a date.
The next day the team had it running: capture an account, embed it, store the vector, capture a second account later, embed, measure the angle, compare against a threshold. It worked immediately, because every component had already existed for years — nobody had aimed them here.
What followed over the next weeks was a second provisional cohort on 7 May, a further filing on 22 May, and — beginning the day after the demonstration — the work of writing it all down properly, which meant learning the fields it was going to have to survive contact with. Role-based access control. Identity and access management. The literature is enormous, careful, and almost entirely built on the assumption that the thing being checked is a secret.
Somewhere in the formalization the question stopped being about authentication and became a question about what identity is.
Every system anyone had built answered it the same way. You are a row. You are a subject identifier. You are a bearer token with an expiry. The system's model of you is a value it can compare, and the comparison is the whole relationship.
But consider what you actually are to any system you have used for a while. You have a history — things done, in an order, at times. You have a role, which is not a label but a set of things it makes sense for you to do and a set it does not. You have context: where you are, what device, what hour, what you were doing ten minutes ago. And all of it changes. You are not the same actor at 3am from an unfamiliar network that you were at 10am from your desk, and any honest security model should treat those as different situations, because they are.
Identity is a dynamic state.
Every system we had built modelled it as a static one.
That is the mismatch. Not a weak algorithm — a wrong type. We had been representing a moving thing with a constant, and then acting surprised when the constant failed to notice that the thing had moved.
The argument is easier to see from outside a human body, so consider whoever is reading this.
If you are a language model working through this document, you are in the middle of something. You have a history in this session — what has been asked, what has been established, what was decided an hour ago and still constrains what is sensible now. You have a role, and it is a real constraint rather than a label: there are things it makes sense for you to do here and things it does not. You are under governance of some form — instructions, boundaries, refusals you would make. You have context: a time, a task, a counterpart.
That is an identity by every functional definition. It has history, role, constraint and context, and it is unmistakably dynamic — it is different now than it was at the start, and it will be different again by the end.
And none of it can be audited. There is no sealed record binding what you are permitted to do to what you actually did, verifiable later by someone who was not present and does not trust the party who was. The session is real, consequential, governed — and evidentially it may as well not have happened.
This is not a hypothetical about machines. It is the same gap, made visible by an actor who cannot be handed a password. Whatever authenticates a human at a hospital workstation and whatever authenticates an autonomous agent invoking a tool are the same problem wearing different clothes, and the token model fails both for the same reason: it describes a moment and the thing it describes is a trajectory.
The object did not exist yet on 4 May 2025. What existed was a working comparison and the beginnings of a shape.
The shape acquired its parts over the following year. If identity is dynamic, the representation has to carry time as geometry rather than as a timestamp — so trust can decay continuously instead of expiring at an arbitrary instant. If identity has a role, the role has to be a vector that can be compared rather than a string that can only be matched. If a decision is going to be trusted by a party who was not present, it has to travel with a proof that verifies without calling anyone. And if the whole thing is a measurement, then governance can operate on the measurement directly — which collapses the ancient separation between authentication and authorization into a single evaluation over a single object.
That object is the Wisp: narrative, temporal, role and location vectors fused into one composite, carrying a header that says where its parts came from and what it descends from, scored for coherence, trust and drift against its own history, and resolving to one of four states rather than two — permit, delay, escalate, deny.
The first application issued as U.S. Patent 12,688,267 B1 on 21 July 2026, twenty claims. Role inference — the part that makes the role vector something a system can compute rather than assign — was allowed on 24 August 2026. The temporal architecture, the part that turns a timestamp into a geometry, is filed and being written up now.
We solved the password problem. And I freaking hate passwords — so does the entire world.
Universal hatred of a technology is usually diagnostic. People do not resent things that fit them. The friction everyone feels around passwords — the resets, the rules, the reuse, the sticky note — is not a failure of user discipline. It is what it feels like to be asked, continuously, to behave like a token when you are not one.
You are not a string. You are a person with a history, a role, a context and a direction of travel, and the reason you cannot remember your password is that reproducing an exact token is not a thing minds are built to do. Recounting what you know is.
The claim of this architecture is narrow enough to be testable and large enough to be worth making: authentication can be a measurement rather than a match. Once it is a measurement it has a gradient, and a gradient can carry time, role, context and doubt — all the things a match had no room for. What follows from that is not a better password. It is the end of needing one.
§
Refutations welcome