The Web Is Forking. Builders Should Pick a Side.
By Conny Lazo
Builder of AI orchestras. Project Manager. Shipping things with agents.
Three announcements. Same week. Nobody compared notes.
Coinbase launched Agentic Wallets — crypto wallets built for agents, not people. Cloudflare shipped Markdown for Agents — real-time HTML-to-markdown conversion for any AI client requesting it. OpenAI published their skills-and-shell roadmap — versioned instruction packages, a real Linux terminal for agents, and server-side context management for long-running workflows.
Three companies. Three layers of the same stack. Zero coordination.
That's not a coincidence. That's a signal.
Money First, Then Everything Else
Agents can't function on the web if they can't pay for things. Coinbase solved this on the crypto side with x402 — a protocol that repurposes the HTTP 402 "Payment Required" status code, a 30-year-old placeholder that the web never actually activated. x402 has already processed over 50 million machine-to-machine transactions. Wallets come with programmable spending limits, session caps, and gasless trading on Base network. Non-custodial architecture means private keys live in secure hardware the agent itself cannot access — so a compromised agent can't leak its own credentials.
The implication nobody fully said out loud: agents with wallets become real economic entities. They can earn, spend, and accumulate capital independently of the humans who built them. That's a category of software that has rarely existed at this scale — not a trading algorithm operating in a bounded market, but an agent that can transact across arbitrary services on the open web. The legal frameworks haven't caught up. That's visible from here.
Stripe solved the same problem on the traditional payments side. Their Agentic Commerce Suite, launched December 2025, introduced shared payment tokens — scoped, time-constrained credentials that let an agent initiate a purchase without ever seeing the card number. The more interesting story is what happened to Stripe's fraud detection system when agents started shopping. Stripe had to build entirely new fraud signals for agent traffic — the old behavioral fingerprints, built over decades on human movement patterns, don't apply to a buyer that is software. Agents don't move a mouse. They don't browse. They make the API call.
Every major payment company reached the same conclusion within the same two-month window. Google launched their Agent Payments Protocol in September 2025. PayPal and OpenAI partnered on instant checkout in October. Visa announced a Trusted Agent Protocol at NRF 2026 in January. Google's Universal Commerce Protocol — announced January 11th with 20+ partners including Shopify, Etsy, Wayfair, and Target — was immediately endorsed by Stripe, meaning any merchant already integrated became compatible with Google's agent commerce infrastructure without writing an extra line of code. Not coordinated. Just converging.
Content and Search: Rebuilding for a Client That Doesn't Read
HTML is designed for browsers. When an agent needs a web page, it has to strip the tracking pixels, nav menus, scripts, and ads — convert the whole thing to something a model can process. An entire category of companies (Firecrawl, Exa) built businesses around that conversion step alone.
Cloudflare's Markdown for Agents removes that middleman. When an agent sends an Accept: text/markdown header to any Cloudflare-enabled site, Cloudflare intercepts, converts in real time, and returns markdown with an X-Markdown-Tokens header so the agent can manage its own context window. One example from the Cloudflare blog: a page that costs 16,180 tokens as HTML renders as 3,150 tokens as markdown — an 80% reduction. Cloudflare handles more than 20% of all global internet traffic. When they decide agents are first-class clients, that's not a product decision. That's infrastructure policy. That concentration of power in a single vendor is also worth scrutinizing — for the same reasons we scrutinized it in cloud and CDN contexts before.
I'm building a multi-agent orchestration engine on this infrastructure — developed by an AI agent named Toscan — and that token reduction isn't an abstract metric. I didn't plan that dependency. It emerged because the agentic web is the surface the engine runs on.
The companion features are equally telling. llm.txt and llms_full.txt give agents machine-readable site maps — exactly what robots.txt did for search crawlers two decades ago. Cloudflare's AI Index lets sites make their content discoverable to agents through an MCP server and search API, bypassing Google entirely. Built-in x402 support means site owners can charge agents for content access — same protocol as Coinbase's wallets.
The content layer is wiring itself directly to the payment layer. No integration work required.
The same first-principles logic is playing out in search. Exa.ai built an agent-native search engine from scratch — their own index, neural retrieval models, embedding infrastructure. Where Google built search for humans over two decades and retrofitted it for agent queries, Exa built the API layer first: raw URLs and content, not SERPs; a research endpoint that chains multiple searches together with agentic parallelism across output fields. That architectural difference shows up in benchmarks. They score 94.9% on SimpleQA (factual accuracy), the current industry lead. An independent benchmark from AI Multiple found latency varies 20x across agent search providers — 669ms (Brave) to 13.6 seconds (Parallel Pro). In an agent workflow, that difference compounds into minutes fast.
The Execution Layer Completes the Stack
OpenAI's February 11th post on Skills, Shell, and Compaction reads more like an architecture announcement than a feature release.
Skills are versioned, mountable instruction packages — closer to Docker images than chat templates. An organization builds a skill, tests it, locks the version, deploys it across every agent in the company. Every agent follows the same procedure. When the procedure changes, update the version. No system prompt archaeology. No prompt drift. Glean's early results: accuracy on Salesforce tasks jumped from 73% to 85% with a single well-structured skill. Time-to-first-token dropped 18%. The gains come from moving stable procedures out of the system prompt and into versioned modular instruction packages — software engineering applied to AI operations. Nothing revolutionary. The second-order effects are.
The Shell Tool gives agents a real Linux environment — not a sandbox playground, a terminal where they can install dependencies, write files, and run commands. The pattern: read the brief, set up tools, fetch the data, deliver the artifact. What a human researcher or freelancer does — now in a container, in seconds. That's a genuine capability shift, and it's worth being honest about what it compresses: roles built around process execution rather than judgment.
Compaction handles context management server-side, automatically summarizing long-running workflows before the context window fills — the feature that makes hours-long agent workflows viable at enterprise scale.
Money, content, search, execution. Every layer went from concept to production to infrastructure in months. The question the rest of the article can't avoid: complete for whom?
The Trust Gap Is the Only Unsolved Problem
Every primitive that makes agents more capable also makes them more dangerous.
An agent with a wallet can pay for APIs or get drained by a malicious skill. An agent with shell access can run workflows or execute arbitrary code injected through a prompt. An agent with Cloudflare-served markdown can read the web or consume adversarial content at machine speed. The capability surface and the attack surface are the same surface.
The security community is already responding. IronClaw — a Rust reimplementation of OpenClaw by Ilya Polosukhin of near.ai — sandboxes every tool in isolated WebAssembly environments. The assumption: any tool an agent touches is a potential compromise vector. OpenAI's shell tool includes org-level and request-level network allowlists, domain secrets to prevent credential leakage, and container isolation. Coinbase's wallets use enclave isolation for private keys and programmable spending guardrails.
I build on this infrastructure — my orchestration engine runs an OpenClaw mode. The Cisco and Conscia security reports I cite here weren't distant news. They were about the platform I operate on, and knowing that firsthand shapes how I read every security response in this space.
The pattern across all serious security responses: treat the agent as a potential adversary. Not a trusted employee. That's the correct mental model for 2026.
The same dynamic plays out anywhere fast agents meet slow humans. Researchers from IMDEA Networks Institute analyzed 86 million Polymarket bets: only 0.5% of users earned more than $1,000 — the rest were providing liquidity for bots to extract from. Algorithmic traders extracted roughly $40 million in arbitrage profits over 12 months. One operator turned $313 into approximately $414,000 in a month running latency arbitrage on the millisecond gap between Bitcoin moves on Binance and Polymarket odds adjustments. Collocated infrastructure. Sub-10-millisecond latency. Significant capital. Not a hustle tutorial.
The trust gap — capabilities versus the trust users actually extend to agents — is the central tension of the next few years. The infrastructure being built assumes full autonomy; the demand side still wants significant oversight. Closing that gap isn't a product decision. It's a years-long process of demonstrated reliability.
A Fork, Not a Replacement
In 2007, the web already existed. It technically worked on phones. But it was designed for desktops — the interface layer was wrong for the new client. What followed was a decade of building for mobile: responsive design, app stores, GPS-aware services, push notifications, tap to pay. Same physical infrastructure. Forked interface.
The companies that built for the new client — not for the old interface retrofitted onto a new device — built the dominant platforms of the next decade. Uber, Instagram, WhatsApp. None of them could have existed on the desktop web. Not because the desktop web lacked information — because it lacked the interface primitives mobile clients actually needed. Real-time location. Always-on connectivity. Camera-first interaction.
The agent fork works the same way. The web already exists. Agents can technically use it. But it's designed for humans. What's being built now is the agent interface: structured data, tokenized payments, machine-readable content, programmatic search, execution environments. Different primitives. Same physical infrastructure.
The businesses that emerge from this fork will be the ones that couldn't have existed on the human web — not because the human web lacks information, but because it lacks what agents actually need.
So: pick a side. Builders who integrate agent infrastructure now — structured payments, markdown pipelines, agentic search, execution environments — are building on a surface that compounds. Builders who wait to retrofit will discover what mobile taught us: the migration cost is higher than the build cost. The sides aren't hypothetical anymore.
That it's happening is not a question. The only question worth sitting with: are the builders shaping these standards optimizing for a web where humans and agents work together — or just for the part where agents extract value from humans who never saw them coming?
L'infrastructure n'attend pas la confiance. Elle ne l'a jamais fait. (The infrastructure doesn't wait for trust. It never has.)
Sources & Inspiration
- Coinbase Agentic Wallets — Crypto wallets built for agents, not people (Feb 2026).
- x402 Protocol Documentation — HTTP 402 repurposed for machine-to-machine payments; 50M+ transactions.
- Cloudflare: Markdown for Agents — Real-time HTML-to-markdown conversion; 80% token reduction (Feb 12, 2026).
- Cloudflare Traffic Statistics — Cloudflare handles 20%+ of all global internet traffic.
- Cloudflare: An AI Index for All Our Customers — llm.txt, MCP server, and AI-discoverable content.
- OpenAI: Skills, Shell, and Compaction — Versioned instruction packages, Linux terminal, context management (Feb 11, 2026).
- Glean Skills Launch — Salesforce task accuracy 73%→85%, time-to-first-token down 18%.
- Stripe Agentic Commerce Suite — Shared payment tokens, agent-native checkout (Dec 2025).
- Stripe: Shared Payment Tokens — Scoped, time-constrained credentials for agent purchases.
- Stripe: Developing an Open Standard for Agentic Commerce — New fraud signals for agent traffic.
- Google Agent Payments Protocol (AP2) — Google's agent payment infrastructure (Sept 16, 2025).
- Google Universal Commerce Protocol — 20+ partners including Shopify, Etsy, Wayfair, Target (Jan 11, 2026).
- PayPal + OpenAI Partnership — Instant checkout for AI agents (Oct 28, 2025).
- Visa Trusted Agent Protocol — Announced at NRF 2026.
- Exa.ai: 94.9% SimpleQA Accuracy — Agent-native search engine benchmark comparison.
- AI Multiple: Agentic Search Latency Benchmark — 669ms (Brave) to 13.6s (Parallel Pro) latency range.
- DL News: Polymarket Bot Profits — IMDEA Networks Institute analysis: 86M bets, $40M arbitrage extracted.
- Yahoo Finance: Arbitrage Bots on Polymarket — One operator: $313→~$414K in a month via latency arbitrage.
- IronClaw by near.ai — Rust reimplementation of OpenClaw with WASM sandboxing.
- Cisco: Personal AI Agents Are a Security Nightmare — Security analysis of agent platforms.
- Conscia: The OpenClaw Security Crisis — Detailed security incident reporting.