After eight months of running a multi agent setup, the thing that actually mattered was the message bus, not the agents

I have been running a small multi agent setup for about eight months. Not a framework, not LangGraph, not a product. A folder of markdown files, a few scheduled jobs, and one rule about who wins a conflict. I posted about it and got flooded with replies from people running nearly the same thing, so I want to write down what actually held up under load. The agents were never the hard part. Spinning up a second or third instance with a different role is easy and it feels productive. What breaks is coordination. Two instances confidently writing contradictory state into the same place, and neither of them knowing the other exists. What fixed it was a post office. Not shared memory. A directory of message envelopes, each one a small JSON file with a sender, a recipient, a timestamp, and a payload. Agents write envelopes and read their own inbox. They do not read each other's working state. Once messages became artifacts on disk instead of passing through a context window, every coordination bug became inspectable. I could open the folder and see exactly who told whom what and when. Second thing that held: a strict split between identity and log. Every agent reads a small canonical file describing who it is and what it is responsible for, then reads recent dated entries for what happened. Mixing those two into one growing document is how you get an agent that is technically well informed and functionally useless, because the signal about its role is buried under transcript. Third: the human is the tiebreaker, always. Somebody in the replies put it better than I had: the human is always the tiebreaker, because we can overwrite. I do not let the system arbitrate its own memory. When two agents disagree about state, it escalates to me rather than resolving itself. That single rule killed an entire class of silent corruption. Fourth: heartbeats, and a recovery path when one is missed. Scheduled jobs that wake an agent, have it check state and report, then go back to sleep. The important half is not the heartbeat, it is the protocol that fires when a heartbeat does not arrive. Without that you do not have a running system, you have a system that stopped an unknown number of hours ago. The failure mode I did not see coming: notes that loop. Entries that summarize the previous entry, which summarized the one before it, until the log is long, busy, and carries no new information. Somebody called it exactly right, it looks busy but does nothing. My current fix is that every entry has to contain at least one fact that is not in the previous entry, or it does not get written. What I still have not solved. Saved and remembered correctly are not the same problem. I can guarantee a file is on disk. I cannot yet guarantee that the agent reading it draws the same conclusion from it that it did last week. That gap is where all my remaining bugs live. If you are running something similar, I would like to know how you handle the tiebreak and whether you let agents write to each other's state directly or force everything through messages. My instinct is that direct writes are the trap, but I have only got one setup's worth of evidence. Disclosure: I work on posts like this with an AI assistant. I bring the content, it helps me structure it.