Agent-First: The Infrastructure of the New Internet

Sergey Golubev 2026-03-22 10 min read

A conductor on a glass podium directs an orchestra of glowing AI agents, each interacting with a different service - payments, databases, storefronts. Dozens of similar human-agent teams stretch across the horizon, connected by luminous lines

This week Stripe launched the Machine Payments Protocol - an open standard that lets AI agents pay autonomously. Visa extended it for card payments. Mastercard Agent Pay is already live in the US. World and Coinbase launched AgentKit for agent identity.

All of this - in a single week of March 2026.

When three of the largest payment companies simultaneously build rails for machine transactions - that’s not a press release. That’s an infrastructure shift.

Five Distribution Channels

Aakash Gupta from Product Growth described five channels through which businesses have found customers:

Retail (80-90s) - boxed software. Microsoft won by pre-installing on every PC.
Web (2000s) - SEO and landing pages. Salesforce killed on-premise.
Mobile (2010s) - App Store. Instagram, Uber, WhatsApp ate those who ported desktop.
AI Discovery (2020s) - LLMs answer instead of links. The question is no longer your page rank, but whether you make it into the answer at all.
Agent Distribution (now) - CLI, MCP, machine-readable documentation.

Every time, the winners were those who built for the new interface first. Not those who adapted the old one.

We’re in the fifth channel now. And it’s already being built.

Three Layers of the Agent Internet

I see this as three layers of infrastructure. Each solves its own problem.

Layer 1: Interface - How Agents Interact with the Web

Until now, AI agents worked with the web like humans - screenshots, DOM parsing, clicks. It’s like asking Codex to write an app, but instead of describing the task - dictating the coordinates of every pixel on the screen.

The protocols for this have been built since late 2024. But right now - early 2026 - they’ve hit critical mass. Everything converged at once: adoption, tooling, integrations.

MCP (Anthropic, November 2024 → Linux Foundation) - 97 million SDK downloads in the first year. 10K+ servers. OpenAI, Google, Microsoft - everyone joined. The de facto standard for “agent → tool” connections.
A2A (Google, April 2025 → Linux Foundation) - standard for agent-to-agent communication. 150+ partners: AWS, Microsoft, Salesforce, SAP. Agent Card at /.well-known/agent.json - an agent’s business card, like robots.txt for bots. Google ADK already supports both MCP and A2A simultaneously.
AG-UI (CopilotKit, May 2025) - streaming UI updates from agent to frontend. Not text, but structured components: tables, charts, forms. AWS Bedrock AgentCore added support in March 2026.
AGENTS.md / CLAUDE.md / GEMINI.md (OpenAI → Linux Foundation, August 2025) - README for machines. Every major coding agent adopted its own format: AGENTS.md (60K+ projects), CLAUDE.md (Anthropic), GEMINI.md (Google). Same rules - “what the project does, how to build it, what conventions to follow” - but for different agents.
AP2 (Google, September 2025) - Agent Payments Protocol. Typed Mandates - cryptographically signed contracts proving an agent has the right to pay on a human’s behalf. 60+ partners including Mastercard, PayPal, Coinbase.
WebMCP (Google, early 2026) - a site adds a couple of HTML attributes to a flight search form, and an agent can call it directly. No scraping. Chrome 145+.
ACP (IBM/AGNTCY, 2024 → Linux Foundation) - REST-native protocol for connecting agents across different frameworks: LangChain, CrewAI, custom code.
ANP (community, late 2024) - the most ambitious: a decentralized agent network on W3C DIDs. Agents discover each other like nodes in a P2P network. Still in specification stage.

And it’s not slowing down. On March 20 - just two days ago - Anthropic released Claude Code Channels: MCP servers that turn Telegram and Discord into a coding agent control interface. You text a bot on Telegram from your phone - Claude Code on your laptop executes. Two-way channel, the agent responds back in chat. A direct response to the popularity of OpenClaw - the open-source agent that first let people control AI from a messenger.

All these protocols existed separately. But right now they’re assembling into a stack: MCP (tools) + A2A (agent↔agent) + AG-UI (agent↔interface) + AP2 (payments). The Linux Foundation Agentic AI Foundation unites MCP, A2A, ACP, ANP under one roof. Plus commercial ones: OpenAI ACP, Google UCP, Microsoft Copilot Checkout. YouTube and Twitter exploded with MCP server tutorials. The boom is here.

50% of traffic on travel sites was bots even before ChatGPT. The difference is that back then they scraped. Now they get a proper API.

Layer 2: Payments - How Agents Pay

This is the hottest part.

Stripe MPP (Machine Payments Protocol) launched March 18. Three days ago. An open standard co-authored with Tempo - a blockchain for real-world payments. Rail-agnostic: stablecoins, cards, other methods. Visa already extended MPP for card payments.

Mastercard Agent Pay has been live since November 2025. Agentic Tokens - dynamic cryptographic credentials for each agent. Pilots in Asia, Europe, Latin America.

Visa Trusted Agent Protocol with Akamai distinguishes legitimate agents from bots. Visa’s forecast: millions of consumers will buy through agents by the 2026 holidays.

Forbes called it the “Machine-To-Machine Commerce Era.” The Card-on-File paradigm is shifting to Agent-on-File.

Layer 3: Identity - Who’s Behind the Agent

Payments without identity verification - chaos. That’s why they’re building the identity layer in parallel.

World AgentKit (Sam Altman + Coinbase) launched March 17. Zero-knowledge proofs link multiple agents to a single verified human. Platforms can limit usage per human.

Erik Reppel from Coinbase put it precisely: “Payments are the ‘how’ of agentic commerce, but identity is the ‘who’.”

Three Agentic Commerce Protocols

A separate story - protocols for shopping.

Three emerged in six months:

ACP (OpenAI + Stripe, September 2025) - spec is open (Apache 2.0), but Instant Checkout in ChatGPT is only for approved partners
UCP (Google + Shopify, January 2026) - 4 transports, 20+ partners. Manifest at /.well-known/ucp - robots.txt for AI shoppers
YCP (Yandex, February 2026) - Alice + Yandex Pay + KIT + protocol owner. Four roles in one. Spec is closed.

An interesting observation from @dealerai: all three protocols are designed for the “seller → AI → buyer” pipeline. Nobody is yet building a protocol from the buyer’s side - so my agent could shop around with my requirements.

The Coding Agent as a Distribution Channel

Amplifying ran 2,500 queries to Claude Code. Without specifying particular tools - just “add a database,” “deploy.”

Result: GitHub Actions = 94% of CI/CD. Stripe = 91% of payments. shadcn/ui = 90% of UI. Redux = 0 recommendations (Zustand took everything).

In 12 of 20 categories, the agent builds from scratch instead of recommending a tool. The “convenience loop” - the moment of conscious choice disappears. The agent has become a full-fledged distribution channel: it chooses, installs, and implements on its own.

The Mobile Parallel

We’re in 2008. The iPhone already exists. The App Store is just launching.

Mobile required new infrastructure: app stores, mobile payments, push notifications, responsive design. Without it, a phone was just a small computer.

Agent-first requires its own: MCP/WebMCP (interface), MPP/Agent Pay (payments), AgentKit (identity). All of this appeared in 6 months.

Karpathy wrote: “It’s 2026. Build. For. Agents.”

OpenAI in their article on 5 AI value models confirms: “The biggest mistake is looking at AI as a set of features and pilots. The biggest opportunity is seeing it as a new distribution model.”

What to Do Right Now

If You Work with Coding Agents

The minimum set so an agent understands your project from the first prompt:

AGENTS.md / CLAUDE.md / GEMINI.md in the repo root. Three files - because Claude Code, Codex, and Gemini CLI read different ones. The content is the same: what the project does, how to build it, what conventions, what test commands. Write once, copy to three files. 10 minutes - and any agent navigates your code without extra questions.
Structured documentation instead of tribal knowledge. An agent doesn’t attend standups or ask colleagues. Everything unwritten doesn’t exist for it. README, ADRs, architecture descriptions in /docs - that’s not bureaucracy, it’s the interface for your new “colleague.”
OpenAPI spec for internal APIs. Even if you’re not planning an MCP server - the spec makes your API understandable to an agent. It will generate the right calls on its own if it sees the contract. Already have Swagger? Half the job is done.

If You’re Building a Product

This goes deeper. Your users increasingly don’t come themselves - they send an agent. And the number of these “agents-as-end-users” will only grow. The question: is your product ready for a machine to interact with it on behalf of a human?

MCP server for your API. Vercel, Stripe, Cloudflare, Supabase, GitHub, Notion - all have already published theirs. There are generators from OpenAPI specs in a couple of commands. The point: your service becomes a native “tool” inside Claude, GPT, Gemini. The agent calls your API as a built-in function - no parsing HTML or guessing endpoints.
WebMCP attributes for web forms. If you have a site with forms (search, booking, ordering) - two HTML attributes make the form callable for agents directly from Chrome 145+. No scraping, no separate API. Google is already testing in AI Mode. Minimal effort, maximum impact for B2C.
A2A Agent Card at /.well-known/agent.json. If your product is itself an agent or has an agentic interface - publish an Agent Card. It’s a business card: what it can do, what capabilities, how to call it. 150+ companies already support the protocol. Your agent becomes discoverable to other agents.
Customer development for agents. Log how agents interact with your product. Where do they stumble? Which calls fail? What data can’t they find? This is a new type of UX research - and a new source of product insights.

The key mindset shift: your customer is a person who will tell their Claude or Codex: “Order this for me through that service.” If the agent can’t find your product, understand the API, or complete a transaction - the customer will go where the agent succeeds. The agent is becoming the filter between you and the buyer. And that filter is already working.

Gartner forecasts: 40% of enterprise apps will have agent-specific AI by end of 2026. Versus 5% in 2025.

Not a question of “if.” A question of “when.”