Banks Know Who You Are. Soon They May Need to Know Who Your AI Is.
"That Wasn't Me. That Was My AI."
Your bank calls.
"Did you authorize this $4,800 purchase?"
You answer:
"I didn't buy it. My AI did."
The bank asks:
"Which AI?"
And suddenly we have a problem.
Banks know how to identify customers.
Soon they may also need to identify the machines acting for them.
We Already Have KYC. Now Comes KYA.
Banks have spent decades building Know Your Customer (KYC) processes around: identity, account ownership, fraud prevention, anti-money-laundering controls, signatures, credentials, and authentication.
Now AI agents enter the system. Visa, Mastercard, and Ant International are now working toward a shared Know-Your-Agent framework for identifying and verifying AI agents across payment ecosystems.
KYC asks: Who are you?
KYA asks: Who is this machine acting as?
An AI Agent Is Not Just Software Anymore
Traditional software usually operates within predefined workflows. AI agents increasingly interpret goals, choose among options, call other systems, and act with a degree of autonomy.
The moment software begins acting on behalf of a person, identity becomes more than a cybersecurity problem. It becomes an economic problem.
If an AI Acts for You, How Does Anyone Know It Is Yours?
Suppose an agent says: "I represent Ernesto. Charge his card."
Why should anyone believe it?
The merchant needs to know: Is this an approved agent? Is it actually connected to this person? Was it authorized? Is that authorization still valid? Has it been compromised? Is it behaving normally?
Trust cannot come from the agent merely saying who it represents.
Machine Identity Is About to Matter
Humans have identifiers: passports, usernames, biometrics, bank credentials, signatures, certificates.
Agents will need their own equivalents. Mastercard already describes its system in terms of registered agents, traceable network tokens, verified user intent, and explicit consent.
The future internet may contain not only identified humans, but identified machines acting with delegated human authority.
Identity and Authority Are Different Problems
An agent can be correctly identified and still exceed its permissions.
For example:
Yes, this is Ernesto's approved travel agent.
But: Was it authorized to spend $5,000?
Different question.
Identity tells the world who the agent is. Authority tells the world what it is allowed to do. Those are not the same problem.
An AI Can Be Legitimate and Still Be Wrong
Imagine: the agent is genuine, the credentials are valid, the identity is verified.
Yet it: spends too much, uses the wrong account, misunderstands a constraint, acts after permission expired, or enters a prohibited category.
Authentication can prove who acted. It cannot prove the action was authorized.
So What Exactly Is the Agent's Identity?
Is the identity tied to: the model? the app? the developer? the account? the user? the cryptographic key? the wallet? the specific agent instance?
"Which AI did this?" sounds simple until you try to answer it precisely.
Because the same underlying model may power thousands of agents. So the model itself cannot be the identity.
The intelligence may be shared. The authority must not be.
The Agent May Change While Keeping the Same Role
Your shopping agent today might run on one model.
Tomorrow: model updated, provider changed, tools changed, memory changed, permissions changed.
Is it still the same agent?
If the substrate changes, does the identity survive?
Machine identity may need continuity that exists above the underlying model.
What Happens When the Agent Delegates?
Your primary agent calls: another agent, a payment agent, a travel agent, a merchant bot, a logistics agent.
Does your identity travel with the delegation?
Does your authority travel too?
Those are separate.
This creates a chain: Human → Agent A → Agent B → Payment System → Merchant.
The longer the chain becomes, the harder it becomes to know where identity ends and delegated authority begins.
Agent Impersonation Is the Obvious Next Fraud Problem
If merchants begin trusting AI agents, attackers will try to impersonate them.
Possible attacks: cloned credentials, stolen tokens, malicious agents claiming to represent users, fake delegated authority, or compromised agents behaving outside normal patterns.
The new KYA initiatives are specifically trying to create traceability, certification, and verification across ecosystems because agentic commerce creates exactly this problem.
The phishing email of the future may not pretend to be you. It may pretend to be your AI.
Revocation Becomes Critical
Humans lose credit cards. We cancel them.
What happens when an agent is compromised?
Can you instantly revoke: its identity? its payment token? its spending authority? its access to certain merchants? its right to delegate?
Any identity system without revocation is incomplete.
Agent Identity May Need Expiration
Maybe an agent identity is valid. But authority should expire.
Example: "Book a hotel this weekend."
That authority should not remain forever.
Persistent identity does not require persistent permission.
An agent may remain yours even after its authority to act has expired.
The Signature of the Future May Be Machine-Generated
Humans sign contracts. We enter PINs. Use biometrics. Click "I agree."
But agents may increasingly sign or authenticate digitally on our behalf.
What counts as a valid machine signature when the machine is not the principal?
The industry is already moving toward verified intent and agent-specific tokens as proof that actions connect back to a human mandate.
The signature may belong to the machine. The authority still belongs to the human.
Know Your Agent Is Really Know Your Chain of Authority
KYA sounds like identification. But eventually the real problem is larger.
You need to know: which agent, which user, which permission, which scope, which expiration, which delegation, which transaction, which consequence.
Knowing the agent is only the beginning.
What matters is knowing the chain of authority behind it.
Identity Without Lineage Is Not Enough
Imagine a disputed transaction.
You can prove: Agent X made it.
Great.
But can you prove: who authorized Agent X? what the original instruction was? whether it delegated? what constraints were active? whether those constraints changed? which downstream agent executed?
Identity answers who acted. Lineage answers why the action was allowed to happen.
The Recursum Connection
Recursum separates three things that are increasingly being collapsed:
- identity
- access
- authority
An intelligence may be known.
It may have access.
It still may not have authority.
Persistent AI needs an identity layer, but governable AI needs an authority layer above it.
Who the AI is matters. What it is allowed to become responsible for matters more.
We Are Building Identity Infrastructure for Digital Actors
We are beginning to build systems that determine: which machines are recognized, which machines may transact, which credentials they carry, what authority they possess, how their behavior is monitored, how trust is revoked.
That is not citizenship in the human sense.
But it is starting to look like an identity and permission infrastructure for digital actors.
The Real Internet May Soon Have Two Populations
The web was built primarily around: humans, websites, servers, applications.
The next web may increasingly contain: humans, agents acting for humans, agents acting for companies, agents acting with limited authority, and agents transacting with other agents.
The internet is about to contain actors that are neither users nor ordinary software.
We are going to need ways to know which machine is acting, whose authority it carries, and when that authority ends.
Ending
Banks spent decades learning how to answer a basic question:
Who are you?
- They built identity checks.
- Authentication.
- Fraud systems.
- Credentials.
- Signatures.
Know Your Customer.
Now another participant is entering the financial system.
- One that can search.
- Decide.
- Negotiate.
- Buy.
- Pay.
And potentially delegate those actions to other machines.
So the question is changing.
It is no longer enough to know who the customer is.
The system may also need to know:
- Who is the agent?
- Whose authority does it carry?
- How far does that authority extend?
- And when does it stop?
Because identifying the machine is only the beginning.
Identity tells the world who the agent is.
Authority tells the world what it is allowed to do.
And the future of trusted AI may depend on never confusing the two.
---
TL;DR: The core idea: Who is the AI, and how does anyone know it is really yours? Banks know who you are (KYC), but soon they'll need to know who your AI is (KYA). Visa, Mastercard, and Ant International are now working toward KYA frameworks for identifying trusted AI agents.
An AI agent is not just software. It interprets, chooses, and transacts on your behalf. If an AI acts for you, how does anyone know it's yours and authorized? Trust cannot come from the agent's claim alone. Machine identity will matter, with agents needing verifiable identity, delegated authority, and spending limits. The critical distinction is that identity tells the world who the agent is, but authority tells the world what it's allowed to do.
An agent can be legitimate but still exceed permissions. The identity of an agent is complex (model, app, user, etc.) and its continuity matters even if the underlying model changes. Delegation by agents creates complex chains of authority. Agent impersonation is the next fraud problem. Revocation and expiration of agent authority will be critical. The signature of the future may be machine-generated, but the authority remains human.
KYA is really about knowing the chain of authority behind the agent. Identity answers who acted, lineage answers why the action was allowed. Recursum separates identity, access, and authority, asserting that persistent AI needs an identity layer, but governable AI needs an authority layer. We are building an identity and permission infrastructure for digital actors, creating a new internet with humans and various agents. The future of trusted AI may depend on never confusing identity with authority.
By Ernesto Verdugo, AI Architect, Founder of Verdugo Labs, and Creator of Recursum. He builds systems for what happens when human and artificial intelligence stop working separately.
Links: