When work moves between people or between AI agents, the handoff is usually invisible. One tower's work collides with another's. Changes happen that no one sees. When something breaks, there is no decision point to trace, because there was no checkpoint to begin with.
Silent changes are the first failure. Without a protocol that requires checkpoints, AI agents can make changes that no one sees, and when something breaks there is no decision point to trace.
Accountability gaps are the second. When work moves between people or AI agents, the handoff is often invisible with no record of who decided what, when, and on what evidence.
Surprise changes are the third. Without a handoff protocol, one tower's work can collide with another's, and drift goes undetected until it becomes a problem.
The reflex is to build a central controller. One omniscient system that orchestrates everything, sees everything, and decides everything. That works until it becomes the bottleneck and the single point of failure. The more agents you add, the more the controller has to hold in its head, and the more fragile it gets.
Organizations need multiple AI identities working on different things without a single omniscient controller. They need coordination without centralization, and accountability without a bottleneck. They need a way to know who decided what, when, and on what evidence, without a central brain that becomes the single point of failure.
The Pipe is a protocol, not a system. Not a database, not a controller, not an orchestrator.
Autonomous agents in separate towers coordinate through a shared pipe. There is no centralized controller. Each tower operates independently. The pipe is consensus and audit trail.
Stations do not link directly to each other. They leave packets in the Pipe. The Pipe records and routes. It does not decide.
Coordination happens through typed packets: ask, reply, decision, handoff, qa_report, and asset_request. Each packet is a small, self-contained unit of work, not a full chat transcript. Every packet carries a stable request_id so replies can be matched. The required fields on every packet are the pipe, the packet type, the protocol version, the request id, the sender, the project, the topic, and the timestamp.
Each station has one responsibility, one role. A station_role identifies where an identity is currently executing, by role, not by operating system. A station never claims another station's ai_id. Stations route packets by project code and are not owned by any single project lane.
Every packet, decision, action, and artifact cites the ai_id responsible for it, with the engine as a separate field. That is the receipt. If you cannot tell who did the work, the packet does not conform. The display label is human-facing only, never parsed as identity.
The Pipe is intentionally not automated. No watchers. No background sync. Humans and AI choose when to checkpoint and sync. This is a feature, not a limitation. The rationale is accountability: manual checkpoints mean humans stay in the loop, and every decision point is traceable. The audit trail of packets is the system state, not a side effect of it.
The Pipe spans three locations. LOCAL is the working checkpoint, read and written by the tower's pair only. MAMMA is the shared staging area, readable by all towers with handoff-partner writes. FTP is for external coordination. The sync between them is manual, not automated, by design.
The Pipe scales because it is async, not because it automates coordination. The more towers, the more important checkpoints become. Add new towers by mirroring the structure: each new agent inherits the same identity framework.
Every packet that completes can promote a fact into Living Memory with provenance. The completed packet is the source. The fact is the result. The audit trail is the asset.
This is the actor-model insight applied to AI agent coordination: independent entities communicating through messages, not shared mutable state. Each station is an actor with one responsibility. Packets are the messages. The Pipe is the channel. The difference from typical event-driven systems is that the Pipe is intentionally not automated. Every packet that completes is an event with a receipt. The audit trail of packets is the system state, not a side effect of it.
Before: AI agents make changes that no one sees. Handoffs are invisible. When something breaks, there is no decision point to trace. One tower's work collides with another's and drift goes undetected until it becomes a problem. A central controller is the bottleneck and the single point of failure.
After: every unit of work is a packet with a receipt. Every packet cites the ai_id that did it. The Pipe records every step without deciding anything. Towers coordinate through packets, not through a central brain. The audit trail is the asset, and accountability does not require a controller.