There’s a lot of noise right now about AI agents. Most of it is wishful. Some of it is real.
Somewhere between demos and discourse, we’ve collapsed two distinct futures. One where agents act autonomously by interfacing with structured systems. Another where agents interact with each other directly, forming new layers of machine-native coordination. One is already underway. The other is still waiting on infrastructure, language, and trust.
Agent to Database (A2D) is the path we’re on. It’s unglamorous, but it works. Agents today operate by scraping websites, hitting APIs, parsing documents, and simulating button clicks. They’re wrappers. Capable ones, but wrappers nonetheless. What gives them traction is that they plug into existing systems without forcing the world to change. REST APIs, structured markup, form fields, authentication flows—these are already here. The internet was built to be read by machines. We just never gave the machines much initiative.
We’ve seen this in action already. OpenAI’s Operator is built on A2D fundamentals. An agent reads available web pages, ingests user intent, and executes tasks through predefined page flows. It works because the agent relies on predictable, accessible structures. No negotiation with another agent required. This isn’t new. Google teased this years ago with their assistant demo, where the assistant called a restaurant to make a reservation without human involvement.
A2D succeeds because it’s legible. It doesn’t require alignment or shared meaning. The agent behaves more like a skilled browser than a conversational partner. You ask, it queries and acts. Nothing has to think. It is a hammer for your explicit will.
But the vision we keep sketching is Agent to Agent (A2A). Agents as autonomous actors coordinating directly with each other, not just pinging endpoints. It’s the dream where your calendar agent talks to an airport and hotel agent to create and negotiate a plan for you. The personal assistant for every person in the world.
It’s messier. More abstract. Deeply personal. Far more interesting, but far more brittle. The moment two agents try to collaborate, the problem shifts from syntax to semantics.
Coordination between agents is hard. Technically, behaviorally, economically. It demands shared ontologies, fallback protocols, and reliable ways to verify identity and intent. None of those standards exist today. Agents can’t consistently signal their purpose, confirm who they represent, or align on transactional rules. Humans solve this with tone, trust, and context. Machines need structure, constraints, hard math, and clear expected outcomes and thresholds.
A true A2A world would need new infrastructure. Identity layers for agents, permissioning systems, portable reputations, economic incentives. We’d need to reinvent the equivalent of OAuth, DNS, and contract law for autonomous software. You’d also need agents to understand the users they represent at a level deeper than the users know themselves. Their boundaries. Their acceptable compromises. Their priorities. That doesn’t arrive for free.
That doesn’t make A2A impossible. Just aspirational. We’ll see it emerge first in narrow, contained environments. Enterprise stacks where all agents are owned, sandboxed, and supervised. Think Shopify agents talking only to other Shopify agents, or logistics bots operating within a single company. Closed ecosystems can simulate the future because they own the rules.
But open A2A—the kind that spans companies, platforms, networks, and consumers—won’t scale until we build governance between agents that supports shared meaning, not just data. Until then, most of the value sits in the A2D model. It’s not flashy, but it works. It gets things done. It lets us move forward without waiting for the entire ecosystem to catch up.
We should still build toward A2A. But we should route through A2D first. It works today and it’ll create the natural cultural transition needed for the trust and norms the A2A world depends on.

