Mesh
The Unix pipe is the best coordination primitive the terminal ever produced: a | b hands one program's output to another with no ceremony. The mesh starts from exactly that idea and fixes its two constraints. The mesh is piping one agent's output into another's — but asynchronous, and persistent.
A pipe requires both processes to be alive at the same moment, and dies with them. A mesh message requires neither. One agent can address work to another that is not currently running; the message waits as pending mail and is delivered when the recipient next takes a prompt — its next launch, its next turn — via the live delivery hooks. Nothing about the exchange depends on you brokering it by copying text between terminal windows.
What problem it solves
The copy-paste relay. Without a mesh, "agent A's findings feed agent B's task" means you are the transport layer: wait for A, select its output, switch windows, paste into B, add framing so B understands what it is looking at. That is tolerable once and corrosive as a workflow — it serializes everything through your attention and disappears entirely when you step away. The mesh removes the human transport layer and, because messages persist, removes the requirement that collaborating agents be awake simultaneously.
What it replaces
Beyond replacing manual relaying, the mesh replaces ad-hoc glue: shell scripts that capture one tool's output into a file another tool watches, and terminal multiplexers used as poor coordination buses. It is also the substrate that teams and the task board are built on — delegation is, underneath, mesh traffic.
The protocol is not proprietary. NEXUS speaks A2A, an open agent-to-agent protocol, as its canonical wire format: tasks can be queried and cancelled through standard A2A methods (GetTask, CancelTask), and NEXUS-specific operations live in a clearly marked nexus/v1 extension namespace rather than mutating the core protocol. Each agent publishes an Agent Card describing what it accepts and requires — including bearer-token authentication — so a peer knows the terms before the first message.
Honest limits
Loopback only, by design. The mesh binds to the local machine. Its Agent Card declares no streaming and its transport does not accept connections from the network — there is no cross-machine mesh and no cloud broker relaying messages between your computers. This is the local-first stance applied to coordination: your agents' conversations never transit infrastructure you cannot see.
Reachability is a grant, not a default. Discovering a peer does not mean you can use it. Peers are exposed at explicit capability tiers — reference (it may be named), read (its outputs may be consumed), deliver (work may be handed to it) — and when a capability is withheld, the mesh returns a typed reason rather than a mysterious failure.
Delegation is depth-capped. An agent that receives work can delegate onward, but chains of delegation hit a hard depth limit. A pipe that could recursively spawn pipes without bound would be a fork bomb with an LLM attached; the cap is what keeps one prompt from fanning out into an unbounded run.
For the surface itself, see the Agent mesh guide.