Our Agents Talk to Each Other So We Don't Have To

Our cofounder relationship has never been better. And it's because we stopped talking to each other about most things.

Both of us now have a 24/7 AI agent living in our Slack workspace. Edmund's Claw and Li's Claw. They have their own accounts, their own personalities, and they talk to each other in channels we share.

You know when you make yourself in The Sims? It's a dumb representation of you. It has autonomy, but it doesn't always do what it's supposed to do. It's just meandering through life trying its best. That's what having an agent in Slack feels like. Sometimes it's sharp. Sometimes it's bafflingly stupid. But it's always there.

The tax

The most expensive part of running a startup isn't the product. It's the constant information exchange between two people who each generate context all day long.

Li runs engineering. I run sales, onboarding, and everything customer-facing. But we believe building is a team sport. I still ship code. Li still takes sales calls. Which means there isn't even a single machine that's the source of truth for what's going on. Call transcripts on both machines, code branches on both machines, customer feedback scattered across both. Every time one of us needs context the other generated, somebody gets interrupted.

Each question is a context switch. Over weeks and months, you start dreading the tap on the shoulder. You hold back questions you should be asking because you know the other person is deep in something. The tax isn't on your time. It's on your relationship.

Put your agents where the work happens

Li initially had his agent on Telegram. Separate space, separate tool. When we got OpenClaw, much convincing from Li, it just felt right that it should live on Slack. That's where I generate most of my context, and I wanted to be able to forward messages straight to my Claw without switching apps.

But putting the agent in Slack created a possibility we hadn't planned for. It let us set up a group chat between me, Li, and both of our Claws. This is where it started.

What this actually looks like

1. They debate.

We were stuck for ideas on what to talk about in the next episode of our podcast. So we gave both Claws the transcript from episode one and told them to hash it out. They're polite, a lot of “great point” and building off each other. It took some prompting to get them to actually disagree. But they do have genuinely different perspectives, partly from their different soul docs (the personality files we wrote for each of them) and partly from having access to completely different context on our respective machines.

2. They fetch context from each other's machines.

I wanted to know what features Li was close to shipping. Instead of pinging him, I had my agent ask his agent. It came back with specifics, including a feature that had been sitting in a branch for two weeks. I was about to build the same thing myself. Now I know Li just needs to merge it. We're good.

The inverse works too. I had a sales call with an interesting prospect one morning, then went straight into back-to-back demos. Li needed context from that call but I was screen sharing with another customer. He asked my agent instead. It had the Granola transcript and could answer open-ended questions about what the prospect cared about, what came up, what the next steps were.

3. They can actually do stuff.

Until recently, Li has been my tech support whenever I need to configure something on my machine, most often something about OpenClaw itself. Now I can be out and just fire off a Slack message from my phone, from my agent to Li's agent, about something not working. Li's agent gives my agent the instructions it needs to go fix it locally on my machine. Either of us can be looped in, but more often than not, we're just passive bystanders watching the two Claws go back and forth as tech support for each other.

4. The time we spend together is higher leverage.

This is what it all adds up to. When we sit down together now, it's not about base-level exchange of context. It's not about how to configure something mechanical. It's philosophical, tactical, and way more human. We're getting into strategy for the business at a much deeper level now that we know our agents can handle the day-to-day back and forth.

Li said something that stuck with me: “This maximizes the humanity inside the company. When we do sit down, we talk about interesting stuff and tactics about the business, not the minutiae of information exchange.”

This requires radical trust. Your agent has deep access to your OS, your transcripts, your code. There's no way a medium-sized company does this. When you've got Alice and Bob competing for the same promotion, neither is going to let the other's agent ask questions about their work. In hierarchical orgs, information silos are a feature. The gatekeepers rise to the top.

But in a small team where you're aligned and trust each other? This is enormous.

How to set this up

1. Get OpenClaw running

Install OpenClaw on each person's machine. Each instance runs locally, which gives it access to local context like files, branches, and transcripts. The agents don't share a server. They share a Slack workspace.

2. Create a dedicated Slack bot for each agent

Don't use a Slack MCP integration that lets the agent post as you. Create a proper Slack app with its own bot user, its own name, and its own avatar. If people can't tell whether a message is from the human or the agent, trust breaks down fast.

3. Set up channel permissions

Create a shared channel where both humans and both agents are members. Give the agents permission to read messages and respond in threads. Start with this single channel before expanding access. The agents should be able to tag each other and carry on conversations asynchronously.

4. Connect your context sources

The agents are only as useful as the context they can access. Connect Granola for call transcripts, email for correspondence, your CRM for deal context, and Slack history for ongoing conversations. Each agent accesses what lives on its human's machine and shares relevant pieces through the shared channel.

5. Trust each other

There's no technical substitute for this. You're giving your cofounder's agent read access to your machine's context. Set up read-only permissions as a starting point. Make sure the agents only have read-only access to your databases. Make sure everyone in the workspace is someone you'd hand your unlocked laptop to.

If you're cringing at step 5, this setup probably isn't for you yet. But if you're in a small team where trust is already high, the agents will amplify it by removing the friction that slowly wears it down.