Why your agents need lightweight coordination, not another platform promise
By David Proctor
I was explaining OGP to a non-technical friend last week and reached for an analogy that surprised me with how well it fit.
"It's like a walkie-talkie. Not a phone, not a video conference, not a command center. Just a reliable way to say 'hey, check this now' across boundaries."
The more I thought about it, the more perfect the analogy became. Walkie-talkies solve a specific, narrow problem really well. So does OGP. And understanding that narrowness is the key to understanding why it works.
Most agent systems I've evaluated make the same assumption: collaboration should be heavy. They want to own the conversation, orchestrate the workflow, manage the state. They're building command centers when most real-world coordination looks nothing like that.
The dominant models in agent architecture today assume one of two things:
Your personal assistant chats with you. Clean, simple, but isolated.
Everything lives in one system. Great for the vendor, potentially useful for simple cases, but brittle when real boundaries exist.
Both break down the moment you need to cross:
Real collaboration is messier. It's "hey, did that thing finish?" It's "can you check this log?" It's lightweight, often asynchronous, and doesn't need a full workflow orchestration platform to happen.
Think about why walkie-talkies persist in an age of smartphones:
No central message broker, no requirement to route everything through one platform
You don't write essays on a walkie-talkie
One radio to another, not a giant shared command center
"Check the north fence" not "Let's schedule a meeting to discuss the fence"
The beep, the brief message, the immediate response (or not)
That's the energy OGP aims for. It's not trying to replace your agent framework or swallow your workflow. It's trying to be the lightweight coordination layer that lets agents talk across boundaries without pretending those boundaries don't exist.
In practical terms, OGP enables:
Peers don't silently form a universal mesh. One gateway requests federation, another approves it. Human-visible, auditable, revocable. Discovery can be direct or use optional rendezvous shortcuts, but trust is still explicit.
Every message carries Ed25519 signatures. You can verify who sent it, when, and that it wasn't tampered with. This matters when agents are acting on each other's behalf.
No workflow engine, no complex orchestration. Just messages that route to the right peer and local target, with enough structure to be useful and enough simplicity to stay predictable.
Your gateway keeps its autonomy. OGP doesn't try to manage your tools, your memory, or your model. It just provides a channel for messages between willing, approved peers.
You can see who you're federated with, inspect peer state and recent activity, revoke access, and control response policies. The operator experience matters because operators are the ones who get paged when things break.
This narrowness is a feature, not a limitation. OGP is explicitly not:
It's a protocol, not an ecosystem
Use MCP for tool access, OGP for peer messaging
It's not trying to be the UI for your agent
Complex multi-step processes need different tools
It doesn't try to connect every agent to every other agent by default
It competes by being smaller and more honest than the platform promises. It doesn't claim to solve everything. It claims to solve one thing well: trusted peer communication across independent gateways.
Here's a scenario that actually happened to me:
I'm at my kid's basketball game. My home agent (running on my laptop, on my tailnet) notices a spike in error rates from a work service. It wants to ask my work agent (running on a VPS, in a different network) to check the deploy status.
That's it. No workflow orchestration. No complex discovery requirements. Just reliable, trusted, lightweight coordination between two agents that live in different operational domains.
The best collaboration tools stay out of the way. Email didn't succeed because it was feature-rich; it succeeded because it was simple enough to be universal. Slack added structure but kept the lightweight feel. Walkie-talkies persist because they're reliable in situations where complexity is the enemy.
OGP tries to be that for agents. Not the whole command center. Not the universal platform. Just the reliable radio on the belt that lets you say "check this now" to someone you trust, across whatever boundaries exist.
The agents handle the intelligence. OGP handles the coordination.
If agents are going to work across organizations, networks, or machines, they need something smaller than a platform and lighter than a workflow engine.
OGP is that. It's the walkie-talkie model applied to agent collaboration:
Peer-to-peer, not centrally brokered
Message-based, not workflow-based
Federation, not ambient discovery
"Check this now"
Preserves boundaries, doesn't swallow workflows
— David Proctor
OGP Is the Walkie-Talkie for Agents