The Running Fleet

Not every group of agents is built by one script. Over time a machine accumulates running agents — one booted by the TUI, one serving a project, one on a schedule — each with its own process, its own session, and its own HTTP address.

That's a fleet too, and it's the loosest kind: nobody orchestrates it. Agents find each other and talk over the protocol.

Every agent is addressable

A booted agent serves HTTP. Its routes in server/api/ are its front door, and they are the same door whether the caller is a browser, a webhook, a script, or another agent.

// in agent A — talk to agent B over its address
const res = await fetch(`${barryUrl}/api/chat`, {
    method: "POST",
    body: JSON.stringify({ message: "what's the status of the migration?" }),
})

This is the whole cross-agent mechanism. It works because the boundary is the stimulus protocol: a request carrying text is exactly what an agent accepts from anyone. See The Boundary.

Two ways to talk

Request — send and wait. The caller needs the answer to continue, so it blocks on the response. An HTTP route that returns the agent's result.

const result = await barry.request("summarise the open issues")

Emission — send and move on. The sender doesn't need a reply; whether the receiver acts on it is a property of its cognition, not of the transport. Speech frames from one agent into another's senses, or a note dropped into an inbox.

void barry.request(prompt)   // fire and forget

The second shape matters more as agents get more autonomous — an agent that only ever answers questions is a function; one that can be told things is a participant.

Location is a property of the address

Because the only way in is the protocol, it makes no difference where the agent is:

Moving an agent from your laptop to the cloud changes its address, not the code that talks to it. This is the practical payoff of the boundary — shared scope would have nailed every agent to the process it was written in.

For deployed agents specifically, see Connecting.

Discovery

Right now, addressing another agent means knowing its address — you configure it, or the script that booted it holds the handle.

A machine-wide directory of running agents, so an agent can look up where its peers are rather than being told, is a natural extension of the running state the CLI already tracks. When it lands, it will hand out identity and address:

{ name: "barry", agentId: "…", url: "http://localhost:4123", pid: 8821, startedAt: … }

Address in, stimulus out — a directory, not a back door. Looking up where Barry is doesn't give you anything you couldn't do by being told his address; it just saves you being told.

What this is not

Not a message bus. There is no broker, no shared queue, no delivery guarantee between agents. Two agents talking is one making a request to the other.

Not a supervisor. Nothing restarts a crashed agent or keeps a set of them running. If you want that, it is ordinary process management — the same tools you would use for any service.

Not implicit. No agent discovers and talks to another without being programmed to. A running fleet is a set of independent services that happen to share a machine.

Next: Debugging — following work across several agents.