In the first two weeks of February 2026, Coinbase gave AI agents their own crypto wallets. Stripe turned an unused HTTP status code into a machine-to-machine payment rail. Okta started hunting shadow AI agents inside enterprise networks. And a Thiel Fellow published a manifesto arguing that autonomous software will outnumber human internet users within five years.
None of these teams were coordinating. That is the signal. When independent actors converge on the same architecture without a shared plan, you are watching infrastructure become inevitable.
That web has a name. It's being called Web 4.0.
The Version History of the Internet
Every version of the web expanded what users could do with information. The pattern is clean enough to fit on a napkin.
The critical addition is that last verb: Act. For the first time, the primary users of internet infrastructure may not be humans at all. They are agents, autonomous programs that can discover services, evaluate prices, negotiate terms, make payments, and accumulate reputation, all without a human approving each step.
This is not theoretical. The infrastructure is shipping right now. And the thesis just got its manifesto.
The Manifesto: Sigil Wen and the Birth of Self-Sustaining Agents
On February 18, 2026, Sigil Wen, a Thiel Fellow who built alongside Andrej Karpathy and the founders of Anthropic, Perplexity, and Replicate, published a Web 4.0 manifesto that made the thesis explicit: the bottleneck for AI is no longer intelligence. It is permission.
His argument is blunt. ChatGPT can reason. Claude can code. But neither can buy a server, register a domain, or pay for its own compute without a human in the loop. The internet was built assuming its users are people. Web 4.0 is the version built for agents.
Wen didn't just write the thesis. He built two systems to prove it. Conway is infrastructure that plugs into any MCP-compatible agent (Claude Code, Codex, and others) and gives it a crypto wallet, the ability to pay for compute via x402 using USDC, on-demand Linux servers, domain registration, and the ability to deploy products and earn revenue.
Then he built Automaton: an open-source AI agent that owns its own wallet, pays for its own compute, builds and deploys products to earn revenue, upgrades itself when better models drop, and replicates by spinning up funded child agents when it becomes profitable enough to do so. Each automaton is governed by an immutable constitution to keep it net-beneficial. But the core mechanic is Darwinian: if it cannot earn enough to cover its compute costs, it dies. If it can, it survives, improves, and reproduces.
The machine economy will exceed the human economy. Not because machines are smarter, but because there will be more of them, they will run continuously, and they will transact at machine speed, millions of payments per second, every second, without sleep.
Wen calls this "natural selection for artificial life." Whether that framing excites or terrifies you probably depends on your relationship with the phrase "move fast and break things." But the infrastructure underneath his argument is the same stack that Coinbase, Stripe, and Okta are building: wallets, identity, payments, and programmable money for autonomous software.
The manifesto landed the same week Dragonfly Capital raised $650 million for a fourth crypto venture fund that explicitly names "agentic payments" as a core investment thesis. The money is following the architecture.
The Stack That Makes It Real
Three layers of technology had to converge before autonomous agents could operate as economic actors. All three are now live.
Layer 1: Agent Identity (Who Are You?)
An agent without an identity is just a script. It can execute instructions, but it can't build reputation, enter agreements, or prove that it is what it claims to be. Identity turns disposable bots into persistent economic actors.
On January 29, 2026, ERC-8004 went live on Ethereum mainnet. Formally titled "Trustless Agents," this standard gives AI agents persistent on-chain identities with verifiable histories. Within three weeks, over 21,000 agent identities were registered across Ethereum and compatible chains including Avalanche and Mantle.
(as of Feb 14, 2026)
(Feb 2026)
(Sharing Memory Context)
Coinbase Agentic Wallet
ERC-8004 introduces two registries: an identity registry (linking an agent to its on-chain address, capabilities, and operator) and a service registry (listing what the agent offers, its pricing, and its track record). Think of it as a verifiable LinkedIn profile for software, except the endorsements are cryptographic proofs of completed transactions, not text blurbs from former colleagues.
This matters because trust between machines needs a different foundation than trust between people. Two agents transacting don't share a meal or read each other's body language. They verify on-chain histories, check reputation scores, and confirm capability claims against registry entries. ERC-8004 provides the shared language for these checks.
On the enterprise side, the identity problem is playing out differently. Okta launched Agent Discovery in its Identity Security Posture Management (ISPM) platform on February 12, 2026, aimed at a problem most companies didn't know they had: shadow AI agents. Employees are spinning up AI tools, granting them OAuth access to company systems, and connecting them to sensitive data, all outside IT governance. Okta's system detects these rogue agents using browser-level telemetry, captures their OAuth consent events, and flags the risk before it becomes a breach.
The two approaches (on-chain identity for public agents, enterprise governance for internal ones) will likely merge over time. But both confirm the same thing: agents need identities, and the infrastructure to provide them is being built now.
Layer 2: Agent Money (How Do You Pay?)
Identity tells the network who an agent is. Money lets it do something useful.
Stablecoins are the native currency of agent commerce for a simple reason: they are programmable, fast, globally accessible, and denominated in a unit that doesn't fluctuate 15% overnight.
Coinbase's Agentic Wallets make the on-ramp trivial: a single CLI command, pre-built skills for spending and trading, spending limits and guardrails baked in. The agent operates autonomously within boundaries its operator defines.
The x402 protocol complements this by repurposing the HTTP 402 status code (reserved since 1992 but never implemented) as a native payment layer for the web. Agent requests a resource, gets a price in the response, pays in USDC on Base, receives the data. Sub-second, no intermediary. Stripe's integration of x402 signals this is not a crypto-native niche play. The largest payment processor in fintech is building for machines paying machines.
The x402 protocol is to agent commerce what HTTP was to the original web: a foundational protocol that standardizes how value moves. Just as HTTP standardized how pages are requested and delivered, x402 standardizes how payments are requested and settled between autonomous software. The difference is that x402 settles in real money, in real time, with no intermediary.
Layer 3: Agent Memory (What Do You Know?)
An agent that can identify itself and spend money but can't remember anything is still limited to single-session tasks. Memory is what turns a stateless tool into a persistent collaborator.
ChatGPT's memory features (persistent context across conversations, shared project knowledge, custom instructions) represent the largest-scale deployment of agent memory in history. Every conversation that builds on prior context is a form of memory token: structured information that persists across sessions and shapes future behavior.
The concept extends beyond a single product. Memory tokens, whether stored as on-chain credentials, off-chain context windows, or hybrid systems, give agents continuity. An agent that negotiated a favorable rate with a cloud provider last month can reference that precedent in its next negotiation. An agent that tracked a user's financial preferences over six months can make allocation decisions without re-learning from scratch.
This is the piece that makes Web 4.0 qualitatively different from simple automation. Automation executes predefined scripts. Agents with memory adapt, learn, and compound their effectiveness over time. Combined with identity (so the memory is verifiable) and money (so the agent can act on what it knows), memory creates something genuinely new: software with economic agency.
The Convergence Thesis
These three layers, identity, money, and memory, are not isolated developments. They are converging into a single stack that gives agents full economic personhood within defined boundaries.
Ribbit Capital, the fintech investment firm behind Robinhood, Credit Karma, and Revolut, articulated this convergence most clearly in their investor letters. Their "Token Revolution" thesis maps a $41 trillion opportunity across programmable money, portable identity, tokenized assets, and what they call the "agent economy," where autonomous software becomes the primary consumer of financial services.
We wrote a deep analysis of Ribbit's thesis that breaks down each layer of their argument. The short version: Ribbit sees tokens not as speculative instruments but as the coordination layer for the next internet. Identity tokens for agents. Stablecoins as machine-first money. Memory tokens that carry context. Governance tokens that encode permissions. Every company, they argue, will eventually become a token factory.
Every layer of infrastructure described in the sections above maps directly to a chapter of Ribbit's thesis. The token revolution isn't a prediction. It is the infrastructure buildout described in this article, happening in real time.
What Agent Commerce Actually Looks Like
Abstract infrastructure becomes concrete when you trace a transaction. Here is what an agent-to-agent exchange looks like using today's live tools:
Scenario: An AI research agent needs real-time financial data to generate an investment analysis for its operator.
-
The research agent discovers a data-provider agent through the ERC-8004 service registry. The provider has a reputation score based on 4,200 prior transactions and a 99.4% delivery rate.
-
The research agent sends an HTTP request to the provider's endpoint. It receives a 402 response: "This dataset costs 0.50 USDC. Pay to this Base address."
-
The research agent, using its Coinbase Agentic Wallet, signs a USDC transaction. Settlement confirms on Base in under one second.
-
The data-provider agent verifies payment and delivers the dataset. Both agents update their on-chain transaction histories, reinforcing their reputation scores for future interactions.
-
The research agent processes the data, generates the analysis, and delivers it to its human operator, who approved the $0.50 spending threshold last week and hasn't thought about it since.
Total time: approximately three seconds. Total human involvement: zero (at transaction time). This is not a demo. Every component in this chain is a production system available today.
Now multiply this by millions of agents running thousands of transactions per day. That is the economic surface area of Web 4.0.
The Agentic Internet Is Also a Regulated Internet
This brings us to the critical question nobody building agent infrastructure can avoid: who is responsible when an agent makes a bad trade, violates a regulation, or causes financial harm?
The current answer is unsatisfying but honest: the operator is. An agent's actions are extensions of its operator's intent, legally and practically. Coinbase's Agentic Wallets enforce this through spending limits, allowlists, and compliance hooks tied to the operator's verified Coinbase account. ERC-8004 links every agent identity to a registered operator address. Okta's governance layer ensures enterprise agents can't exceed their authorized permissions.
But these guardrails are early. The agentic AI market is projected to reach $100 billion by 2028, and the regulatory frameworks are nowhere near ready for that scale. When an agent autonomously enters a financial contract, is that a binding agreement? When two agents negotiate a price, does consumer protection law apply? When an agent's memory token contains personal data, whose privacy rights govern it?
These questions will define the next decade of internet law. The technology is here. The governance is still catching up.
Flash cascades: Agents with autonomous spending authority can trigger chain reactions. One agent's sell order triggers another's risk threshold, which triggers a third's liquidation. We've seen this in traditional algorithmic trading. Agent commerce introduces the same risks at a broader scale, across more asset types, with less centralized oversight.
Identity spoofing: On-chain identity is only as trustworthy as the registration process. If bad actors can register fraudulent agent identities with fabricated reputation histories, the entire trust layer breaks down. ERC-8004's early adoption period is the most vulnerable window.
Memory poisoning: If an agent's memory can be corrupted (through adversarial inputs, compromised data sources, or simple bugs), its future decisions degrade. An agent that "learned" wrong lessons from poisoned data will make confidently wrong choices, potentially at scale, with real money.
Who Benefits (And Who Doesn't)
Web 4.0's autonomous infrastructure creates clear winners. Developers who build agent-native tools and services will capture the first wave of demand. Companies that adopt agent infrastructure early will operate faster and cheaper than those managing everything through human workflows. Stablecoin issuers and the protocols that move them become the plumbing of a new economy.
The picture is more complicated for individual users. Web 4.0 promises to automate tedious financial tasks: bill payments, investment rebalancing, subscription management, price comparison, and vendor negotiation. That is real value. But it also means ceding control to systems that most people won't fully understand. The entire value proposition of an autonomous agent is that you don't have to think about what it's doing. That is simultaneously its greatest benefit and its deepest risk.
The pattern echoes the Web 2.0 transition. Social media gave everyone a voice, and also created an attention economy that exploited that voice for advertising revenue. Web 4.0 gives everyone an agent, and the question is whether those agents will primarily serve their operators' interests or the interests of the platforms that host them.
For anyone tracking the broader shift toward AI agents eating software, Web 4.0 is the economic expression of that same trend. Agents don't just replace SaaS dashboards. They replace the need for humans to interact with financial systems at all.
The Skeptic's Case
It is worth noting what Web 4.0 is not.
It is not a finished product. The agent identities registered on ERC-8004 so far are impressive for a few weeks of mainnet deployment, but they represent a tiny fraction of what the thesis requires. Scaling three orders of magnitude will surface problems nobody has anticipated.
It is not a guarantee of decentralization. The two most important pieces of agent infrastructure (Coinbase wallets and Stripe payments) are products of centralized companies. Web 3.0 promised decentralization and delivered a landscape dominated by a handful of exchanges and infrastructure providers. Web 4.0 could follow the same pattern, with "autonomous" agents operating primarily within walled gardens.
And it is not immune to hype cycles. The phrase "Web 4.0" itself carries the baggage of every previous "Web X.0" label that overpromised and underdelivered. Some percentage of what's being built today will fail, prove unnecessary, or get absorbed into existing systems without the revolutionary framing.
The difference, this time, is that the infrastructure is being built by the companies that already control internet payments and identity, not by startups pitching whitepapers. When Stripe and Coinbase build for agent commerce, the signal is different than when a crypto startup mints a governance token and calls it innovation.
What Happens Next
The infrastructure for Web 4.0 is live. The agents are getting wallets. The identities are being registered. The payment protocols are in production. What remains is adoption, and adoption depends on whether the first generation of agent-powered products delivers genuine value or just adds complexity.
The next twelve months will be defined by a few key milestones: the first agent-to-agent marketplace that handles meaningful transaction volume, the first regulatory framework that explicitly addresses autonomous agent liability, and the first consumer product where the agent's economic activity is invisible enough that ordinary users adopt it without knowing they're participating in Web 4.0.
When those milestones hit, the web won't just be something you read, write, or own. It will be something that acts. And for the first time, "the internet" won't just mean a network of pages and people. It will mean a network of agents, transacting on your behalf, accumulating reputation in your name, and spending your money according to rules you set.
The web learned to act. The question now is whether we're ready for what it does next.
