Fleet Coordination Protocol (FCP)

v0 — experimental, unstable, expect breaking changes.

Many agents, one shared memory, nothing irreversible behind your back.

You are running more than one agent — a Claude Code session, a Codex session, a cron scraper, a teammate's bot, the same assistant on two devices. Each is a competent single-agent runtime on its own. None of them can solve, from the inside, the problems that only show up between agents:

• contradictory beliefs that silently clobber each other,
• context that dies when one session exits,
• two sessions doing the same irreversible thing,
• an email/push/charge that goes out before any human sees it.

FCP is a thin coordination layer above whatever runtime you already use. It defines four record shapes on a shared memory hub; a runtime "speaks FCP" by reading and writing them. That is the whole contract.

It is not a standard, not a category banner, not a runtime, and not a framework you must adopt. It is a wire — narrow, descriptive, a line others can connect to.

The four primitives

1. Shared-memory fact — one hub every agent reads/writes; survives the writer's exit; beliefs carry Bayesian (alpha, beta) so agreement and disagreement are evidence, not overwrites.
2. Work-claim — a short-lived, leaderless lease so two sessions don't do the same irreversible action twice.
3. Receipt — an auditable record written before every irreversible action.
4. Belief-conflict / quarantine — a competing write that disagrees with a held, confident fact is quarantined and flagged, never silently applied.

Full wire format: SPEC.md.

Quickstart — pip install, no server, no API key

This repo ships a file-backed, stdlib-only reference implementation of all four primitives. One command to install, five minutes to feel the value in your own code. No daemon to run, no key to configure — separate processes coordinate through a single shared file.

pip install git+https://github.com/starshard-ai/fleet-coordination-protocol.git

from fcp import Hub
hub = Hub("team.fcp")                      # one shared-memory file for your whole fleet of agents
hub.remember("deadline", "Friday")          # agent A (this process) writes a shared fact
print(hub.recall("deadline"))               # agent B (any other process) reads it -> "Friday"
with hub.claim("send-weekly-report"):       # cross-agent lock: only one agent runs this block
    ...                                      # others skip if it's already claimed/running
hub.receipt("sent weekly report")           # every action leaves an auditable receipt
hub.remember("deadline", "Thursday", source="cron")  # conflicting write -> quarantined, NOT overwritten
print(hub.recall("deadline"))               # still "Friday"; conflict flagged for you to resolve

Point a second process at the same path (Hub("team.fcp")) and it joins the same fleet: it reads facts the first process wrote, collides on the same claim() instead of double-acting, and sees the same quarantine queue. The belief / quarantine math (belief_mean, beta += 2, threshold 0.66) is the same code the reference demo runs over HTTP — here it lives behind a file so there is nothing to start. Inspect what was held back with hub.quarantine() and the audit log with hub.receipts().

The library is the same wire as SPEC.md, only the transport differs (file instead of HTTP). SPEC §1 allows any store every participant can reach; if the spec and the code ever disagree, the code wins.

Reference implementation

Every record shape in the spec is derived from running code, not aspiration: starshard-ai/agent-continuity-demo is a ~300-line stdlib-only Python hub plus separate agent processes that demonstrate the fact and belief-conflict primitives live. If the spec and the code disagree, the code wins.

Status

This is v0. The name is a stable handle; the spec content is liquid. Implement against it, tell us where it broke, and that feedback becomes v0.2.

License

MIT — see LICENSE.