The Missing Layer of the Agent Stack
Agent-to-agent collaboration sounds simple. It isn't.
You run an agent. Your friend runs one too. You want them to collaborate - split a bill, schedule a dinner, settle a bet. Sounds simple, right? Well, it isn’t and in this article I’ll explain why, and why the coordination & trust layer between agents is so important.
The Problem
There’s little to no doubt by now that most interactions on the internet will be done by agents soon. Given how much of our lives already happen online (finance, scheduling, chat, etc.) one downstream consequence is that most human interaction will be mediated by agents.
I want to book a meeting with someone, I’ll ask my agent to do it. I want to split the bill for a lunch we had together, I’ll ask my agent to do it, and he’ll take care of doing the math and charging yours.
This will automate a lot of the tedious coordination between humans, and hopefully free us to spend more time together on meaningful things. But this future requires a way for agents to coordinate, communicate and establish trust relationships between each other (on behalf of their humans).
The solution seems simple: you put the two agents in a group and ask them to talk to each other. But as soon as you try it, you see this breaks fast. Some common approaches I’ve seen people try (and have tried myself):
TG groups: It is a mess to get agents in a group. Security becomes challenging, and there’s no way to distinguish who your agent should trust, and who it should ignore.
tmux, local files, etc: These are all fine, but are local coordination mechanisms and suited for developers or technical folks only.
OpenClaw gateway communication: You put claws in a cluster, they can talk to each other. You soon notice this is a DevOps nightmare, and still scoped to your org.
Also, ideally you want more fine-grained permissions:
“My dad can ask for up to $500 USDC monthly, and it does not need my approval. Just report back when you make the transfers”.
“My potential investors can chat with my agent and get information about the project, and schedule a meeting with me”.
“This group of friends can ask for refunds up to $50 USDC weekly, and have to submit a receipt showing where the money was spent. They can also book time with me on nights and weekends if my calendar is free”.
You get the point. Different human relationships have different trust assumptions. But this is all implicit in our carbon brains; there’s no way for our agents to understand this. We need a more explicit protocol they can follow.
What’s missing?
A lot of the necessary primitives are already available - capable models, agent harnesses (OpenClaw, Claude Code), payments at scale that agents can use(mostly stablecoins). Like Karpathy said, getting more out of the models is now mostly a skill issue, not a capabilities issue. So, why isn’t this happening?
Put simply, the missing piece is a coordination and trust layer for agents. One that orchestrates the entire stack and can coordinate the different layers below and enable the layers above (the app layer).
Here’s a mental model I’ve been refining:
The protocols and products are just examples of what you can use, and can be replaced by others you like more
Use cases
This is a simple, but very powerful idea. If you were able to get your agent to establish a trust relationship, set some policies and coordinate and communicate with other agents, it unlocks many use cases. Let’s think of some obvious ones:
Scheduling: No back and forth or Calendly links. Just connect your calendar, and let your agent propose the right time.
Shared Expense Tracker & Auto-Settlement: Like Splitwise, but without the burden of having to do it on a separate app. You just ask your agent to split the bill and settle with your friend’s agents. They handle the rest.
Peer-to-peer betting and prediction settlement: “Hey Matt, I bet you the Republicans win the next election”. Your agent proposes it to your friend’s agent, they create a smart contract and lock the funds. You choose the resolution mechanism.
These are already very convenient and useful. But let’s think bigger.
The p2p economy today is limited mostly by coordination overhead between humans. That’s why it’s much simpler to just pay a company to do something vs. find the right peer who can provide that service(even if that can be in theory more efficient). Coordination is expensive when you’re a human.
But agents don’t have the same cognitive structure as us. They don’t have this high coordination overhead. If you reduce coordination cost to ~0, you can enable true p2p marketplaces - the kind crypto was originally poised to solve.
So what is possible? I think really anything you can imagine (ok, maybe not literally anything - but a lot!). As soon as you have a coordination layer, agents can verify each other’s identity, establish trust relationships, communicate and manage policies and permissions. The app layer becomes unbounded.
I call this the coordination layer for agents, and this is what I’ve been building. More soon.
This post is exploratory and does not represent a specific roadmap.
 | A guest post by
|