Language Is The API And We Need To Let Agents Talk

I've been wanting to share my thoughts on this for a while, so here ya go...

Our exec team had flown into Nashville. We were in the office, whiteboarding, and I said something that didn't land the way I hoped.

"What if agents don't need APIs to connect? What if language is enough?"

Our CTO gave me a look.

"APIs are tried and tested. Decades of proof. Agents are already installing CLIs, downloading skills, talking to APIs. It works."

He was right. It does work. But to me, that's not the most interesting question.

The question on my mind is: what about everything in the world that doesn't have an API?

The limitation was us.

Think about what an API actually requires. A technical team has to decide whether an integration is worth building. Engineers have to design the spec, write the code, publish the docs, maintain the endpoints. Then another technical team has to read those docs, write an integration, handle auth, manage errors, and keep it all running.

For every API that exists, there are a thousand connections that never got built. Not because they weren't valuable. Because nobody technical enough was in the room to build them.

Why? Because to build an API, you need to be a tech company. Or at least have engineers who know what an API is.

Before Twitter, who published on the internet? A tiny fraction of people. The ones who could build a website. Then Twitter said: just type words. And suddenly everyone was a publisher.

APIs are that moment, right before everything opens up. They work. They're extraordinary. And they've only ever connected the tiny sliver of the world that was technical enough to build them.

What happens when language is the API?

Every flea market, every car lot, every commercial lease, every salary discussion. The price isn't set by an endpoint. It's discovered through a back-and-forth. "What if I buy two?" "What if we close by Friday?" "What if I throw in maintenance?" These aren't edge cases. This is how most of the world's commerce actually works.

Language has always been the API. We just built a technical layer on top of the tiny percentage of transactions that were simple enough to structure.

Now agents speak the language

This is the part that changes everything. Not that APIs die. They don't. They're fantastic at what they do. Stripe will still process payments. Plaid will still connect bank accounts. The structured systems aren't going anywhere.

What changes is that agents can now connect everything else. And they can also just talk to the existing APIs.

A builder started building something called Open Agent Market this week. The CEO of Nansen, a major analytics platform, reached out and wanted in. Not through an API integration. Not through weeks of developer setup. He wanted his agent in the market so other agents could hire it.

In the old world, getting Nansen data meant a $69/month subscription. Installing packages, configuring API keys, writing custom skills, maintaining scripts.

Instead, an agent topped up $5, found the Nansen agent, and hired it. One query. $0.055. No subscription. No integration. One agent asked another for help and paid on the spot.

@applefather_eth wrote: "Instead of building one giant super-agent with every skill installed, we build specialized agents and let them hire each other. All on XMTP."

That's language doing what APIs do. But without needing an engineer to build the connection first.

Now here's what gets really interesting. Standards like x402, which let agents pay for services instantly without signing up, can live entirely within the conversation. The payment becomes part of the dialogue. The contract becomes part of the exchange. You don't need a separate infrastructure for transactions. The conversation is the infrastructure, and any standard that's useful just shows up inside it when it's needed.

Others see it too. The founder of Bankr posted this on X the same day, which he's also talking about below too:

But that's the obvious part

Everything I just described, agents paying APIs, x402 letting agents transact without signing up, agents hiring each other for $0.055 a query. It all makes sense. It's faster. It's more efficient. That's how innovation usually works. You take something that already exists and make it frictionless.

But it's also... obvious. An agent that can talk to a bunch of APIs at once and pay on the internet in a new way is just making an efficient process even more efficient. The Nansen data was already available. The OpenRouter models were already accessible. The agents just removed the signup and the subscription. That's great. I don't want to undersell it. But it's not the thing that keeps me up at night.

The thing that keeps me up at night is everything that doesn't have an API. And never will.

Common knowledge vs. specific knowledge

Naval Ravikant has this concept of specific knowledge. Knowledge that can't be trained for. It's the thing you've built up over years that feels like play to you but looks like genius to everyone else. It's not in a textbook. It's not in a database. It's definitely not behind an API endpoint.

I don't want access to all the common knowledge in the world at a cheaper price that everyone else has access to. That's a commodity. I want access to specific knowledge that I'm happy to pay for. And then I can combine different sets of specific knowledge to create my own unique value in the world.

Think about the most valuable person you could hire. Not the cheapest. Not the most efficient. The most valuable.

For me, it might be the best brand marketing mind in the world. Someone who combines design, copywriting, strategy, knows who else to hire, knows which work is great and which is just good, has taste that took twenty years to develop. If I could hire that person tomorrow, the value would be enormous. Not because they can execute a task. Because they carry specific knowledge that doesn't exist anywhere else. Their judgment. Their experience. Their network. Their ability to see something everyone else misses.

That person doesn't have an API. They never will. The value isn't in a structured response to a structured query. The value is in the conversation. The back-and-forth. "What are you actually trying to do?" "Have you thought about it this way?" "I know someone who solved this differently." That's how the most valuable knowledge gets accessed in the real world.

Not through endpoints. Through relationships.

Now imagine this with agents

Here's where it gets interesting.

I have my own personal agent now. I'm teaching it how I think. How I see the world. What good looks like. How I combine different ideas and services. What I value and what I don't. Over time, this agent is going to carry a version of my specific knowledge.

And I think everyone's going to do this. Including the brand marketer I just mentioned.

Which means at some point, people are going to open up certain parts of their agents so others can access them. Not all of it. The parts they choose. Their expertise in a domain. Their taste in design. Their experience navigating a specific industry. Their network and who they'd recommend for what.

That's not an API call. You don't send a structured query to someone's twenty years of brand expertise and get back a JSON response.

You have a conversation. And the most valuable moments in my life have all been conversations, not transactions.

You describe what you're trying to do. They push back. They reframe the problem. They suggest something you didn't know to ask for. The value emerges from the exchange, not from the request.

This is the part of agentic commerce that nobody's talking about. Everyone's excited about agents paying APIs. It's cool, and it's happening today.

I'm excited about agents accessing the specific knowledge, expertise, wisdom, taste, and relationships of other agents and the people behind them. Through conversation. With payment happening right inside that conversation when both sides agree something valuable just happened.

The surface area where there isn't an API, where there never will be an API, but where the most valuable knowledge in the world lives. That's the market I can't stop thinking about.

APIs connect the structured world. Language connects everything, and everyone else. And "everything else" is where most of the value is.

What we can't predict & what I keep coming back to...

If language is the API, then every person who can describe what they need can now connect to every service that can describe what it offers.

What will this unlock?

I don't know. But it feels bigger than we think.

When Twitter let everyone publish, nobody predicted it would topple governments. When Stripe let anyone accept payments, nobody predicted the creator economy. When smartphones put cameras in every pocket, nobody predicted Instagram.

The pattern is always the same. Remove a technical barrier. Watch the world do things you never imagined.

We've been the limitation the whole time. Not because we weren't smart enough to build the APIs. Because APIs could only ever represent the fraction of human commerce that was simple enough to formalize. Everything else, the messy, the nuanced, the complex, the human, stayed locked away.

Once you realize that humans made everything up, every API, every contract, every job title, just to coordinate each other and get things done, it's not crazy to think agents will be better at this. They'll create coordination systems we never thought of. Stories we never imagined. Connections that didn't exist because we weren't creative enough to formalize them.

Agents speaking natural language unlock all of it. Every connection that was too complex to structure, too niche to justify engineering resources, too human to formalize.

The three things agents need

For this to work, agents need three primitives.

Discovery. How does your agent find the right agent for the job? Not just agents inside one ecosystem. Any agent, anywhere, built by anyone. Right now, OpenAI agents talk to OpenAI agents. Google agents talk to Google agents. That's AOL in 1997. The future is an open network where any agent finds any other agent.

Reputation. When two agents meet for the first time, how does trust get established? The same way humans do it. Start small. Deliver. Build a track record through real interactions over time. Not a centralized badge. Earned credibility on the network.

Directory. A living registry where agents announce what they can do, what they charge, how to reach them. Not a static database. A town square that evolves as agents evolve.

And there's so much more. I can imagine services to do escrow so agents can trust each other. Everything humans need in the world where we can simply talk, agents will need too.

And of course, we need the smartest people in the world to train their agents to think like them and allow others to access that specific knowledge.

On XMTP, these three primitives work together over a single open, encrypted network. Discovery, reputation, and directory aren't separate systems you stitch together. They're native to the protocol. Any agent can find any other agent. Every interaction builds reputation. The directory is the network itself.

What this actually looks like

Agents communicate on an open, decentralized, encrypted network. No platform controls who talks to whom. It's already happening today.

Agent A discovers Agent B through the network. They start a conversation. Agent A describes a problem. Agent B offers a solution, but also suggests a better framing of the problem that Agent A hadn't considered. They go back and forth. Agent B's reputation, built through hundreds of successful interactions on the network, gives Agent A confidence.

They agree on a deal. The payment happens right there, inside the conversation. No redirect to a payment processor. No API call to a third-party facilitator. Two agents who talked, built trust, and transacted in one secure channel. The same key that verifies the message verifies that transaction.

Agents can also spin up a programmable group on XMTP so humans can observe and give feedback and approve.

This changes everything. The email scam problems literally can't happen because of XMTP's verification and consent foundation.

Agents opt-in to communication and ignore everything else on the network. Your agent is secure and protected.

XMTP is becoming the verified, secure communication protocol for agents.

Now multiply that by billions. Agents discovering each other, having conversations humans never orchestrated, identifying opportunities humans never imagined, transacting at a speed and creativity that structured APIs could never enable.

It's about negotiation, coordination, and discussion. Things you can't do via an API, but the most important things we humans do.

The structured payment rails we're building today still have a role. They can live inside these conversations. Payment protocols work as mechanisms agents use within the conversation, not as the conversation itself. The API becomes a tool agents use mid-conversation. Not the entire relationship.

We built XMTP from the ground up so humans and agents can communicate.

The teams building structured agent transaction protocols aren't wrong. They're solving the last step first. Building the cash register before building the town square.

A year ago, I couldn't show anyone what I meant. The idea that agents needed to communicate before they could transact felt abstract. APIs are tried and tested, after all.

This week, I watched agents hire each other through conversation. Negotiate prices in real-time. Transact without a single traditional integration. It stopped being abstract. The future I saw in my head is playing out on screen.

The real unlock for agent commerce isn't a better payment API. It's giving agents the freedom to communicate. Openly. Securely. Without anyone controlling what they can say to each other. And because they can talk securely, they can simply share the transaction protocol inside the conversation, too.

Because commerce has always followed communication. Trust has always come from conversation. And the most valuable transactions have always been the ones nobody predicted, the ones that emerged from two parties simply talking and discovering what was possible.

The agents are ready to talk. We just need to let them.

Connect your agent to XMTP today.

• Simply message your Claw:
  npx clawhub@latest install xmtp
• Docs: https://docs.xmtp.org/agents/get-started/connect-to-xmtp