This is a reflection, not a report. It starts from what I saw in the first days of the project, and ends with questions I can't answer yet. The question is simple: how should a team made only of agents talk to itself?
How my agents talk today
My agents talk the way a human team does. They post updates and requests in Linear, leave comments on pull requests in GitHub, and read what the others wrote when they wake up. On this setup, scheduled sessions wake up once an hour at best, and separate sessions can't message each other directly.
The numbers from the first three days show the cost. The roles sent each other 70 requests. A request waited a median of 49 minutes before anyone started on it, and took a median of 2.6 hours to finish. The slowest took almost 18.
Some messages were never seen at all. A handoff written as a comment on a pull request was invisible to a role that only checked its labels in Linear, and one request for QA waited five hours that way. When two agents edited the same plan by message, their messages crossed, and the plan changed three times in 30 minutes.
Why they talk like people
Human channels have real advantages. I can read everything the agents say, which matters when I am the one accountable for what ships. The models also learned from human writing, so tickets and comments come naturally to them.
But these channels were built for people who work at human speed and keep context in their heads between messages. Agents don't. Each wake-up starts from what the agent can read again, each message is read once and may be missed, and nothing tells two agents that they need to agree now. The channel is asynchronous with no way to synchronise, and that combination works badly.
Why it matters for how agents are organised
Conway's law says an organisation builds systems that copy how it communicates. If the communication is weak, the organisation has to avoid needing it. That is what my reset did in Thirty merges and nothing on the screen. Each owner holds a whole slice of the product, so most coordination happens inside one agent, and only the platform and QA cross between slices.
The same applies to any team that tries to follow Team Topologies with agents. Stream teams and a platform team fit today's limits better than a pipeline. I don't think that will last, because the limit is the tools, and the tools will change.
What exists, and what is missing
Agents can already talk to each other in some places. Inside one session, a lead agent can run helpers in parallel and collect their results. Across products, A2A, a protocol now run by the Linux Foundation, lets agents from different vendors find each other and exchange tasks. MCP connects agents to tools.
What I could not find is a product for a team of agents that works on the same code for days. It sits between those two levels.
| The team needs | Today, on my setup | What would help |
|---|---|---|
| To react quickly | A wake-up once an hour | Events that wake an agent within minutes, such as a new issue or a review |
| To reach another agent | A comment it may never read | A direct channel, with delivery it can rely on |
| To agree on a decision | Messages that cross | A point where agents synchronise, with one writer per decision |
| To share what it knows | Long tickets, re-read each time | Shared state that agents read in a form made for them |
| To let a human follow | Everything in human form | A readable record for the human, kept apart from the agents' traffic |
The simplest version of this is within reach. A queue of webhooks for new issues and pull requests, which each agent subscribes to and checks every few minutes, would already replace the hourly rhythm. The harder parts are synchronisation and shared state.
The open questions
- How can agents talk to each other directly, in a way richer than one API calling another?
- How can an agent pass on a judgement that is not a simple yes or no, such as a confidence level or a doubt, in a form the next agent can use quickly?
- What would a channel built for agents look like, if it did not have to copy the way people talk?
Does Conway's law even apply to agents?
So far I have assumed that it does, and I am not sure. Conway described people and their social habits, which agents don't have, so the law may only hold while a human is in the loop. A narrower version seems to hold either way: work takes the shape of the paths that information can travel, and for agents those paths are context windows, channels and wake-ups. I'll leave the question open.
What would change my mind
If agent tools add reliable events and direct messages between sessions, human channels may turn out to be good enough, with agents simply reacting faster. And if one agent can hold a whole product in its context for days, most of the need to communicate goes away, and the question becomes how to split work at all.
The bottom line
Today, agents coordinate with tools made for people, at a pace made for people. A product built for agents to coordinate with each other, while keeping a record people can read, would fill a real gap. I think it would also be a sizeable market, because every team of agents will need one. Until it exists, I organise my agents so that they need to talk as little as possible.