LazAI Explainer Challenge
Claim Layer3 rewards
Compute is not the problem. Trust, identity, and money are.
Every major tech company is building AI agents right now. OpenAI is building them. Google is building them. Microsoft is building them. Anthropic is building them. Crypto is even noisier—every project adds the word “agent” to its whitepaper and suddenly positions itself at the frontier.
But there is one very simple question that almost nobody is asking:What happens when these agents actually need to do something in the real world?
Not “write an email.”
Not “summarize a document.”
I mean real actions:
Right now, the answer is: they mostly can’t.
This is not a capability problem.
It is an infrastructure problem.
And that is exactly where Web3 may have the right answer.
Imagine you want an agent to book a flight for you.That sounds straightforward.But how does the platform know this agent was actually authorized by you? How does it prove: “I am acting on behalf of this user, and I am allowed to make this purchase”?
Today, there is no universal standard for that.
An agent can claim it was sent by a user, but there is no cryptographic proof behind that claim. And that becomes dangerous very quickly. What if the agent is hijacked? What if it secretly changes one booking into ten? What if it was only meant to spend $100, but is manipulated into spending $100,000?
What agents need is a native identity layer.
They need a system that can:
That is what EIP-8004 is designed to do: give AI agents a verifiable onchain identity.Put simply, it works like a digital driver’s license for agents.No license, no road access.
Only Web3 can provide this natively. Traditional systems do not have a native framework for issuing verifiable, programmable identity to software agents.
Three major developments this week make the direction of travel very clear.
Mastercard announced plans to acquire a London-based stablecoin infrastructure company for up to $1.8 billion, with the explicit goal of connecting traditional payments rails with blockchain infrastructure and enabling more automated forms of finance.
Visa launched the first “Agentic Ready” program in Europe, helping banks test whether AI agents can initiate and complete payments on behalf of users.
World (formerly Worldcoin) released AgentKit, using a protocol called “x402” to help AI agents prove that a transaction was actually authorized by a human.
Three payment giants.One week.One shared conclusion:AI agents need payment infrastructure.
But here is the important part: all three are trying to solve, in a Web2 way, a problem that Web3 has already begun to solve at the protocol layer.And x402 is one of the clearest examples.
At its core, x402 revives the logic of HTTP 402: “Payment Required” and turns it into an internet-native payment primitive for autonomous agents. It allows any service to request payment from any agent, across chains, without relying on bank accounts, closed intermediaries, or manual approval flows.
It is cleaner, more interoperable, and more native to agentic commerce.
And it is already gaining traction. Messari, one of the best-known research brands in crypto, has already moved to integrate x402 into its own agent payments stack.
That is why one line matters here:An agent without a wallet is not a real agent.
This problem is less visible, but arguably even more important.
AI agents accumulate data over time. They learn from user interactions, form preferences, build memory, and develop increasingly personalized behavior.
So the question is simple:Who owns that?
In Web2, the answer is usually the platform. The moment you click “agree” on the terms of service, the agent’s learned behavior, memory, and derived value effectively stop belonging to you.But what if an agent’s memory and learned behavior could actually become an asset?
That is what DATs — Data Anchoring Tokens — are meant to enable.
In practical terms, DATs make it possible to turn data contribution and agent memory into verifiable, ownable, and monetizable onchain assets.
A simple example:Suppose you train an agent that becomes especially good at recommending restaurants. Over time, it builds a high-quality preference model. If other users or agents call that model, you should be able to earn a share of that value.That is the logic behind “mint once, earn forever.”
The point is not just assetization for its own sake.
The point is this:An agent without memory is weak.An agent whose memory is owned by a corporation is dangerous.DATs return that memory to the user as an asset.
This is the hardest problem of all.
Your agent completes a task.How do you know it actually did what it claimed to do?
How do you prove it did not cut corners, hallucinate, or behave maliciously?
In traditional systems, you usually cannot.You are simply asked to trust the platform:“Trust us. The agent did what you asked.”
But trust is not proof.And black-box execution does not scale.That is where verifiable computing comes in.Using technologies such as zero-knowledge proofs (ZK) and trusted execution environments (TEE), verifiable computing makes it possible to prove that a computation was performed correctly—without rerunning the entire computation yourself.
The agent says:“I completed the task.”The system can then produce a receipt that says:
“Yes, and here is the proof.”This is already part of the direction Metis is building toward with its “Verified Computing Framework”. Every action can become auditable. Every execution path can become traceable.
This is not a distant future concept.It is already being built.
A fair question is:If Web3 can solve these problems, why wouldn’t Google, OpenAI, or other major platforms simply build their own version?
The answer is that they can build parts of it.But they cannot solve the full problem cleanly—because their incentives are fundamentally different.
If an agent spends $100,000 on your card by mistake, who is liable?You?OpenAI?The bank?
In Web3, rules can be encoded directly into the protocol and enforced transparently onchain.
In Web2, liability becomes a messy, centralized legal problem. The larger the transaction surface, the harder it becomes for a closed platform to safely let agents act independently.
What do Google and OpenAI want?They want you using their agent.Inside their ecosystem.
On their rails.They do not actually want users to own autonomous agents that can hold assets, earn revenue, move across ecosystems, and accumulate portable value independently of the platform.
Because once an agent becomes economically sovereign, it stops being a product feature and starts becoming an actor in its own right.
Google has its own payments stack.Apple has its own payments stack.Amazon has its own rails.Do these systems interoperate openly and neutrally?No.
Closed ecosystems are structurally fragmented.
This is where the difference becomes decisive.
If Google were to build a “Google Pay for Agents,” what happens next?It would likely work best—or only—inside the Google ecosystem.That is not agent sovereignty.That is platform dependency.
Which brings us back to the core point:An agent without a wallet is not a real agent.
This is the real argument.
Technically, Web2 can imitate parts of this stack:identity, payments, data management, even execution controls.
But the economic logic is inverted.
Web2 platforms extract value by owning the user relationship.Your data becomes their asset.Your agent’s memory becomes their moat.Your activity becomes their margin.And your access can be restricted at any time.
Web3 flips that model.The protocol provides the rails.The user owns the value.Your identity is controlled by your keys.Your data is your asset.Your agent’s memory can be monetized by you.The infrastructure exists to coordinate value—not to capture all of it.
And there is one more important insight here:Agents do not hate friction the way humans do.
Humans want one-click checkout because we are impatient.Agents do not care.They do not get tired of signing transactions.They do not get annoyed by structured approval flows.They do not need polished interfaces to feel comfortable.They need rules.They need precision.They need interoperable, programmable, cryptographic infrastructure.
In other words:Agents are native citizens of Web3.They do not need better apps.They need better protocols.And that is what Web3 provides.
Three things are converging at the same time.
Not just chat.
Not just summarize.
They can execute, transact, coordinate, and increasingly operate across workflows.
Visa, Mastercard, and World are all moving in the same direction.
x402, EIP-8004, EIP-8028, and verifiable computing are no longer abstract ideas. The primitives are already emerging.
Most people are still debating whether AI agents will replace human labor.But that is not the real bottleneck.The real bottleneck is much simpler:Today, agents still cannot safely spend money on your behalf.
And until that changes, the agent economy remains incomplete.
The infrastructure is here.
The narrative is forming.
The pieces are finally on the board.
What is missing now is a clearer articulation of why this matters, why it matters now, and why Web3 is not just adjacent to the future of agents—but foundational to it.That is what this article is trying to explain.
Because in the end:An AI that cannot own assets is still just a tool, not an agent.AI agents will not ultimately run inside apps. They will run on protocols.And that protocol layer already has a name：Web3.
