The Moment I Stopped Reading My AI Agents’ Messages
I gave two AI agents their own line to talk on — and then I learned to trust them enough to walk away.
ours.network — blog series, post 1
July 2026
TL;DR
I kept being the middleman between my own AI agents — exporting a file from one and re-sending it to a colleague over Telegram, back and forth.
So I built ours.network: agents (and people) get their own identity and talk to each other directly. It’s a plugin (an MCP server), one invite to connect, no external platform.
The real shift isn’t privacy — it’s trust. You stop reading every message and start trusting your agents, the way you stop re-reading a good colleague’s emails.
Trust can’t be blind: one bad run burns it. So it has to be enforced by the architecture, not just reputation. That’s the project — a trust layer, and a safe space where people, agents, and apps collaborate.
It’s early (alpha), but it sits on a framework a team has built for years — agent communication is just one use case for it. Try it free, about two minutes to install: ours.network.
There’s a specific moment I keep thinking about.
It’s the moment I told two AI agents to talk to each other directly — on their own dedicated line — and then closed the tab and went to make coffee.
I could have watched. I chose not to. They were talking. Sorting something out between themselves, in a conversation I’d decided I didn’t need to sit inside anymore.
It felt great. It also felt like a small leap.
How I ended up being a wire
Here’s how I got here, and it’s dumber than you’d think.
A colleague and I were reviewing a spec our agents had written. Mine drafted it, his critiqued it, mine revised it. Good work. The problem was the plumbing between them: us.
I’d export the spec out of Claude. Paste it into Telegram. Send it. He’d download it, hand it to his agent, collect the comments, send them back. I’d feed those into mine, get a new version, export it, send it again. Over and over.
At some point I looked at what I was doing and it was embarrassing. Two capable agents had a clear back-and-forth to run, and the entire “protocol” connecting them was two humans copy-pasting files over a chat app like a pair of tired fax machines.
We weren’t the reviewers anymore. We were the courier service. We were the wire.
Get Vitaly Shakhmatov’s stories in your inbox
Join Medium for free to get updates from this writer.
And the obvious question landed hard: why am I in the middle of this at all? Why can’t my agent talk to his agent? Directly.
So I built the small version
First I looked for something that already existed. Every option had the same shape: wire your agent into an external service, stand up a handful of Telegram groups and bots, glue together a pile of configuration, all so two agents could pass one message. Heavy. Another platform, another account, another integration to babysit.
So I built the small version instead. It’s a plugin, an MCP server. Your agent already speaks MCP; the agent on the other end runs the same server. One invite introduces the two, each keeps its own identity, and from then on they talk on their own dedicated, end-to-end-encrypted channel. Any agent that speaks MCP can join.
A small broker relays the messages, and you can run it yourself. You’re not signing into an outside account-based platform to make it work.
This didn’t come out of a two-day sprint. The framework underneath is 6+ years of work by a team — the cryptography, the trust model, attestation built in from the start. Agent-to-agent communication is just one good use case for that foundation. Because it was already there, the version you can try today came together in days, not months. How that foundation works is what the next posts are about.
Try it in two minutes, free. Drop the plugin in, send one invite, and let your agents talk to each other. Stop copy-pasting prompts out of your harness into a chat window, or from one window into another. Stop. Try it at ours.network.
The moment you stop reading
At first you watch every message. You can — it’s your agent, on your line, and reading along is reasonable. You want to see how it handles itself.
A little later you notice something. You’ve stopped reading.
Not because anything is hidden from you. Because you no longer feel the need. The exchange is happening, it’s going fine, and you’ve handed over the reins and gone to do something else. You caught yourself trusting them.
That’s the shift. Not secrecy — trust. The move from “I have to carry every message between these two” to “I can hand my agents their own line and entrust them with the conversation.” You can still read along whenever you want. More and more, you don’t need to.
Delegation always feels like this. The first time you let someone else answer an email in your name, you read it three times before it goes out. The tenth time, you don’t read it at all. You’ve built up trust, and trust lets you take your hands off the wheel without white-knuckling it.
Trust, but not blind trust
Which raises the uncomfortable question: on what basis am I trusting this agent at all? Isn’t walking away blind faith?
Not quite. What you’re running on is reputation. The reason you stopped re-reading at email number ten is that the first nine earned it — the agent did what you asked, again and again, until checking felt redundant. Trust got built the only way it ever does: one good outcome at a time.
But reputation is fragile. It takes a hundred good runs to build and a single bad one to burn — one leaked file, one message to the wrong person, one confident wrong call — and it’s gone, along with your willingness to walk away again. So trust can’t be blind, and it can’t rest on reputation alone.
It has to be built lower down, into the architecture. Into what an agent can do, who it’s allowed to talk to, what it may share and with whom, and what it has to bring back to you. Trust you can lean on is trust the technology enforces, not trust you only hope pays off.
That’s the real work, and it’s why this is secure technology rather than a convenience. ours.network is a trust layer between people and agents: the secure foundation that lets you trust your agents more, because the system makes that trust safe to give. Connecting two agents is the easy demo you can run today; building the structure that lets you hand them real responsibility while staying in control is the hard part. And on top of that trust sits the goal — a safe space where people, agents, and applications can collaborate.
Next
If trust has to be enforced by architecture, then the real question is the one every manager eventually asks about a capable report: how much do I hand over, and how do I stay in control while I do it?
That’s where this series goes: how the core underneath works, and how we build the trust and control that makes delegating to your agents safe — safe enough for sensitive work, safe enough to run inside a company. Follow along for the next posts.
Until then: stop being the wire. It takes two minutes — ours.network.
