We Made Money Programmable but Left Identity in a PDF
A payment is only as fast as its slowest step, and right now that’s identity.
On a stablecoin panel recently, someone asked what “continuous identity verification” looks like in practice. Here’s what I said: it looks like a credit score, not a passport. A credit score travels with you; it updates once and is referenced everywhere, so no lender re-runs your full history from scratch. A passport works the opposite way: every institution downstream checks it again because none trusts the previous institution’s verification. As a result, speed hits a wall that has nothing to do with the network itself.
In payments, most identity checks still work like a passport. A company checks a customer one time. A customer gets verified, a box gets checked, and that verification is trusted for months, sometimes years. This was a reasonable design when an account was the product, and when the settlement took days. Now that most settlements take mere seconds, this design fails.
Cross-border payments make the pattern easier to see. One transaction can move through five or six licensed entities, often in different jurisdictions. Each entity runs its own KYC, and none recognizes the last one's check. The sender’s wallet knows its customer; the receiving bank knows its customers; everything between the two is a repeated cost, not a repeated safeguard. Multiply that redundancy by volume, and it stops being a UX problem. It's a per-transaction cost with nothing to show for it.
Settlement is increasingly real-time, so identity has to move at the same speed, or it becomes the bottleneck by default. And payments are getting smaller, increasingly micro, which means the math has to be razor sharp. A model that re-runs the same check at every hop doesn't just cost time. At micropayment scale, the cost of resetting trust can exceed the value of the transaction itself. Solving speed and solving math turns out to be the same problem.
What matters here: identity can’t be a single checkpoint anymore; it has to be a continuum. The real question isn’t “who are you?” It’s now “are you still who you were, and does your behavior since then still match?” That’s where fraud lives, but the deeper point is that identity now has to flow and persist, not just get confirmed once.
Retrofitting better fraud tools onto the old model is a poor solution for closing this gap. The right solution includes identity as part of the payment message itself, whereas now identity lives in a document outside the transaction. Continuous identity is an attestation that moves with the money, verified once and trusted downstream. In practice, this means the verification event is bound to the payment instruction, not filed away and referenced later.
This solution requires a party willing and able to stand behind the verification check and not just check a box. In payments, that’s historically been the role of a regulated bank, and this doesn’t change. Identity providers supply the signals, and fintechs build the customer experience. But one party must be the anchor that all other parties trust without re-checking.
The ground keeps shifting, too. AI agents are starting to initiate payments on people’s behalf. Asking “who is this?” is no longer enough. An agent doesn’t have an identity of its own, it’s acting on someone else’s authority.
So, the real questions shift from identity to architecture: who authorized this agent, what are its precise boundaries, and how do we enforce scoped delegation? An AI agent doesn't just need to be identified; it needs a defined perimeter that proves what it’s allowed to touch, how much it can move, and for how long. It’s about bounding authority so a system can act safely on someone else's behalf. The industry already has a name for this: Know Your Agent. KYA is the KYC equivalent, but for software, turning authorization and scope into something we can verify. This change is moving fast, and it’s coming whether the industry is ready or not.
Stablecoins have solved much of the orchestration layer for money movement. The more difficult challenge that remains is making sure that trust, settlement, and identity move at the same speed as money, and at scale.
These are ultimately architecture questions. Money is already programmable and increasingly real-time. We think that the industry needs to embed identity attestations directly into payment and settlement messages rather than keep them as separate systems. Trust, like the credit score, it should resemble, has to move as a continuum, not stop at a checkpoint.
