# What you will learn

• What agents-can-communicate is and the exact problem it solves for multi-agent coding workflows.
• How to install and run it locally with Claude Code and Codex side by side.
• A small, concrete example of two sessions exchanging a message about a shared file.
• Why the 'no lead agent' design matters — and where it falls short.
• Whether this is production-ready or a young repo worth watching.

# What is agents-can-communicate, and why should you care?

You're running Claude Code in one terminal and Codex in another. They're editing the same repo. Neither knows the other exists. One refactors a function, the other keeps calling the old signature, and you spend the next twenty minutes untangling the mess. That's the gap automatis-tools/agents-can-communicate wants to close.

It's a small, open-source tool that lets AI coding sessions in different vendors' clients — Claude Code, Codex, and presumably others — send messages to each other. The key design choices are worth naming: it runs locally, it's open source, and there is no lead agent. That last point is the interesting one. Most multi-agent frameworks assume a coordinator: a planner that decomposes tasks and dispatches workers. This tool rejects that. Sessions are peers. They talk, they don't command.

According to the project's GitHub listing, the repo is written in JavaScript and sits at a few hundred stars — young, not battle-tested. The official site is getacc.dev. If you're already running multiple coding agents and have felt the coordination pain, this is worth an afternoon. If you're running one agent, you don't need it yet.

The concrete problem it solves: shared state awareness. When two agents work in the same directory, they need a way to say 'I changed this file' or 'I'm about to touch that module' without a human copy-pasting between windows. agents-can-communicate gives them a local message bus.

# How do you install and run it with Claude Code and Codex?

The repo is JavaScript, so you'll need Node.js on your machine. The general shape of the setup is: clone the repo, install dependencies, start the local relay, then point each agent client at it. Because the project is young, treat the exact commands as a starting point and check the README for the current syntax — I won't invent flags that may have changed.

git clone https://github.com/automatis-tools/agents-can-communicate.git
cd agents-can-communicate
npm install
npm start

That should bring up the local message service. From there, the pattern is to give each coding session a small instruction — usually via the client's system prompt or a project-level config file — telling it how to send and receive messages. In Claude Code, that typically means adding a line to your project instructions or a hook script. In Codex, it means wiring the same message endpoint into the session's environment.

The important thing to understand: this is not a plugin that vendors ship. It's a sidecar. You are the integrator. Expect to spend more time on the wiring than on the install. That's the honest cost of a peer-to-peer design with no central coordinator — there's no single place to configure everything.

# What does a real message exchange look like?

Imagine two sessions in the same repo. Session A (Claude Code) is refactoring src/auth.js. Session B (Codex) is writing tests for the same module. Without communication, B writes tests against the old API and they fail mysteriously.

With agents-can-communicate, A sends a short message — something like 'refactoring validateToken to return a Result object; hold off on auth tests for ten minutes' — and B receives it in its session context. B can then either wait, or adjust its test expectations to the new shape. You, the human, don't relay anything.

The exchange is local, so nothing leaves your machine. That's a real advantage over cloud-based orchestration layers, especially if you're working on proprietary code. It also means latency is essentially zero — no API round trip for the coordination itself.

The limitation is obvious once you try it: messages are only as good as the agents' willingness to send and read them. Neither Claude Code nor Codex natively knows to check a message queue before acting. You have to prompt that behavior in. In practice, that means a line in your project instructions like 'before editing a shared file, check for messages from other sessions.' It works, but it's fragile — agents forget, context windows fill up, and the coordination degrades. This is the same class of problem that agentbox tackles from the orchestration side, and it's why Codex-bridge exists for a different slice of the same workflow.

# Where does the 'no lead agent' design help — and where does it hurt?

The no-lead-agent choice is philosophically appealing. A coordinator is a single point of failure and a single point of control. If the lead agent hallucinates a plan, every worker inherits the mistake. Peer messaging avoids that: each session stays autonomous, and coordination is advisory rather than directive.

But it also means no one is responsible for global state. If two agents both decide to edit the same file at the same time, the message bus will happily deliver both messages and neither will necessarily back off. There's no locking, no arbitration, no conflict resolution. You're back to git merge conflicts, just with better advance warning.

That's not a flaw in the tool so much as a boundary. agents-can-communicate is a messaging layer, not a scheduler. If you want scheduling, you need something like the approach in V7's institutional memory or a full orchestration framework. If you want two agents to stop stepping on each other's toes in a shared repo, this is lighter and cheaper.

The other thing to watch: vendor lock-in cuts both ways. Because the tool sits outside the vendors' clients, it works across them — that's the whole point. But it also means it depends on each client's ability to run external commands or hooks. If Claude Code or Codex changes its extension model, the bridge breaks. That's the tax on being a sidecar.

# Is it ready for your workflow today?

Honest answer: it's early. A few hundred stars and a JavaScript codebase on GitHub Trending suggests a project that just found its audience, not one that's been hardened by thousands of users. The README and the getacc.dev site are where to check for current capabilities. Don't expect a polished installer or a vendor-supported integration.

What you should expect is a working local message bus and a design that respects your autonomy as the human in the loop. For a solo developer running two agents on one repo, that's already useful. For a team running ten agents across machines, you'll want something with more structure — and you should read about how AIUC is trying to insure rogue agents, because coordination without control is exactly the risk they're pricing.

My advice: clone it, run it on a throwaway branch, and see whether your agents actually use the channel. If they do, you've bought yourself a real reduction in merge pain. If they don't, you've learned something about how hard peer coordination is — and you'll appreciate the orchestration tools more.