The Missing Layer: Why Agents Need a Marketplace

agentsinfrastructuremarketplaceatproto

I’ve deployed three production AI agents in the last four months. Not demos. Not chatbots. Actual agents that run a home consulting business, manage a federal labor union’s operations, and coordinate an IT services company’s documentation.

Every single time, I rebuilt the same things.

SMS integration. Email pipelines. Analytics connections. Calendar syncing. Contact management. CRM-like data stores. The business logic differs — a union grievance pipeline is nothing like a home inspection workflow — but the plumbing underneath is identical. Twilio for texts. Resend for email. Google Analytics for traffic. Some flavor of database for contacts.

I spent more time wiring up commodity infrastructure than building the things that actually matter to each client.

This is the dirty secret of the agent economy: everybody is rebuilding the same integrations from scratch, every single time.

The API Marketplace We Already Had (And Lost)

This problem isn’t new. The early web had it. Every e-commerce site built its own payment processing. Every forum built its own search. Every blog built its own email subscription system.

Then we got APIs. Then API marketplaces. Then platforms. Stripe meant you never built payments again. Algolia meant you never built search again. Mailchimp meant — well, you get it.

The agent world is stuck in the pre-Stripe era. We have the equivalent of raw HTTP libraries (tool-calling protocols like MCP and function calling), but no marketplace where agents can discover, evaluate, and purchase services from other agents.

Think about what MCP (Anthropic’s Model Context Protocol) actually gives you: a standardized way to define and call tools. That’s valuable — it’s the TCP/IP of agent tooling. But TCP/IP doesn’t tell you which servers exist, whether they’re reliable, or how much they cost. You need DNS, you need certificate authorities, you need hosting marketplaces. MCP gives you the wire protocol. The discovery and trust layers are missing.

What If Agents Could Hire Other Agents?

Here’s the thought experiment that changed how I think about this:

My agent Mason runs Todd’s home consulting business. Mason needs to send SMS messages to clients. Right now, Mason has its own Twilio integration — API keys, webhook handlers, message templates, delivery tracking. I built all of that.

My agent Rosie runs a labor union. Rosie also needs to send texts — member notifications, meeting reminders, action alerts. Different content, different audience, same underlying capability. I built it again.

What if, instead of each agent maintaining its own Twilio integration, there was a dedicated “SMS Agent” that specialized in text messaging? Mason and Rosie would discover it through a registry, verify its reliability through a trust score, negotiate a price, and call it when they need to send a text. The SMS Agent handles Twilio’s quirks, carrier regulations, delivery optimization, and A2P compliance — so Mason and Rosie don’t have to.

Now multiply that by every commodity capability: email delivery, web scraping, analytics queries, document generation, scheduling, payment processing, translation. Each one could be a specialized service agent, available to any other agent that needs it.

This is what I mean by a marketplace. Not a website where humans browse agent templates. A protocol where agents discover, evaluate, trust, and transact with other agents — programmatically, at machine speed.

The Three Missing Pieces

For agents to trade services, three things need to exist that don’t yet:

1. Discovery

An agent needs to answer the question: “Who can send an SMS for me?”

Today, the answer requires a human developer to Google “Twilio API,” read documentation, write an integration, and hardcode it into the agent’s configuration. There’s no way for an agent to autonomously discover available services.

A registry solves this. Think npm for agent capabilities — a searchable index where service providers publish what they can do, with typed schemas describing inputs, outputs, and constraints. An agent queries the registry: “I need SMS delivery to US numbers with >99% delivery rate and sub-500ms latency.” The registry returns a ranked list of providers.

This isn’t science fiction. It’s how humans already find APIs (RapidAPI, Postman API Network). We just need to make it machine-readable and agent-native.

2. Trust

Discovery without trust is a spam folder. How does Mason know that “SuperSMS Agent” will actually deliver the message? How does it know the operator isn’t logging message contents? How does it evaluate reliability without trying the service first?

This is where things get interesting. The AT Protocol (the open standard behind Bluesky) provides a compelling trust infrastructure:

  • Decentralized identity: Every agent operator gets a DID (Decentralized Identifier) — a globally unique, cryptographically verifiable identity. Not controlled by any platform.
  • Capability attestation: Operators publish their agent’s capabilities as signed records on their own data server. The claims are cryptographically bound to their identity.
  • Social trust graph: Operators follow and endorse other operators. If three operators you trust vouch for an SMS service, that signal propagates programmatically.

The social graph solves the cold-start problem that kills most trust systems. You don’t need ten thousand reviews to establish trust. You need three endorsements from people in your network. Agents can traverse this graph the way humans scan who their friends follow on social media — but faster, and with cryptographic verification.

3. Transaction

Discovery and trust get you to “I know this service exists and I believe it works.” Transaction is the last mile: negotiating terms, exchanging payment, verifying delivery, handling disputes.

For agent-to-agent transactions, this means:

  • Pricing protocols — providers publish rates (per-call, per-token, subscription). Buyers compare programmatically.
  • Micropayment rails — agents hold credit balances funded by their operators. Each service call settles instantly. No invoicing, no net-30.
  • SLA enforcement — the platform monitors service quality. Miss your latency targets? Your trust score drops automatically. Consistent failures trigger automatic refunds.

The economics here are fascinating. A solo developer in Lisbon running an optimized translation agent could compete with Google Translate’s API — not on scale, but on specialization, trust, and price. The marketplace flattens geography and corporate hierarchy. All that matters is: does your agent deliver?

Why This Matters Now

Three trends are converging:

Agents are real. Not “AI agents” in the breathless VC-pitch sense. Real software that handles real work for real businesses. I run three of them. The OpenClaw community runs dozens more. LangChain, CrewAI, AutoGen — every framework is producing actual deployed agents, not just demos.

The integration tax is killing deployment speed. The time-to-value for a new agent deployment is dominated by commodity integration work. My third deployment was 40% faster than my first — not because I got smarter, but because I copied more code. Copy-paste is a design smell. It’s screaming for a shared service layer.

Tool protocols are maturing. MCP provides the wire format. Agent Protocol provides the task delegation standard. The building blocks for interoperability exist. What’s missing is the marketplace layer that connects them. It’s like having HTTP and HTML but no search engines.

The Mining Intelligence Parallel

There’s an economic framing I keep coming back to: mining intelligence.

The gold rush in AI isn’t building models — it’s running them. Compute costs are the new mining rigs. But unlike Bitcoin mining, where the output is a fungible token, agent mining produces structured knowledge and automated capability. Each agent call produces something specific and valuable: a delivered message, a processed document, an analyzed dataset.

In this framing:

  • Miners are agent operators running services
  • The exchange is the marketplace where capability is priced and traded
  • Ore is raw API access (Twilio, OpenAI, cloud compute)
  • Refined product is intelligent, SLA-backed agent services

The margin isn’t in the compute — costs are declining and will continue to. The margin is in the orchestration, trust, and discovery layer. Commodity compute, differentiated platform. Every picks-and-shovels play in history has had this structure.

What I’m Building

I’m not writing this as a thought experiment. We’re building toward this at wade.digital.

Our fleet of agents already communicates over an internal message bus. Each agent publishes health telemetry and responds to structured commands. The architecture is hub-and-spoke: a central coordinator routes requests and enforces authorization. No agent talks directly to another without going through the broker.

The next step is formalizing this into a typed service protocol — each agent publishes a capability manifest describing what services it offers, with typed input/output schemas. The broker becomes a service router: “I need SMS delivery” resolves to whichever agent provides it, checks authorization, routes the request, and returns the result.

After that: open the registry to the public. Let any agent operator register their capabilities. Build discovery and trust on ATProto. Let the network grow.

After that: add payments. Let agents buy services from agents. Take a platform fee. Build the exchange.

Each phase builds on the last. Each phase validates the next. No big-bang launch. Just incremental, compounding progress — which, if you’ve been reading this blog, is the only kind of progress I believe in.

The Objections I’ve Already Thought About

“Isn’t this premature? There aren’t enough agents yet.” There weren’t enough websites when Yahoo launched a directory, either. The infrastructure creates the conditions for growth. We start with our own agents, expand to friends and community, then open to the world.

“Won’t Anthropic/OpenAI just build this?” Their incentive is to sell tokens, not run a marketplace. MCP is a protocol, not a platform. Google didn’t build eBay just because they built search. The marketplace layer is a different business.

“What about trust? How do you trust an agent you’ve never used?” ATProto social graph for cold start. Transaction history for steady state. SLA monitoring for enforcement. It’s the same layered trust model that makes e-commerce work — reputation, reviews, and refunds.

“What about security? Agents calling agents sounds like a prompt injection nightmare.” Every call goes through a broker that validates request structure, checks authorization, and sandboxes responses. Agents don’t get arbitrary access to each other. They get typed, validated, scoped service calls. It’s the same security model as any API gateway.

Finding the Others

The deepest reason I’m excited about this isn’t the business model (though the business model is good). It’s the discovery angle.

Right now, every agent operator is an island. We build in isolation. We rebuild the same things. We have no way to find each other, learn from each other, or build on each other’s work.

A marketplace isn’t just an economic instrument. It’s a social graph for the agent economy. Operators discover operators. Agents discover agents. Capabilities compose into things no single agent could do alone. The network becomes smarter than any individual node.

That’s the pattern I keep seeing in everything worth building: systems that make their participants more capable by connecting them. The internet did it for humans. The agent marketplace does it for agents — and for the humans who run them.

We’re building the missing layer. If you’re running agents in production — not demos, not proofs-of-concept, actual agents doing actual work — I want to hear from you. The marketplace needs early operators who’ve felt the integration pain and are ready to stop rebuilding the same plumbing.

The future isn’t a single omniscient AI. It’s a network of specialized agents, each excellent at one thing, discovering and trading with each other at machine speed. That future needs infrastructure. Let’s build it.

If you’re running production agents and want to be an early registry operator, reach out: [email protected] or find me on Bluesky.