Four coding agents open the same repository. Two see the same unchecked task and start editing the same file. A third is investigating a failing test whose cause another agent already found. The answer is sitting in a tool result in a session the third agent can’t see.
A shared task file can tell the swarm what needs to be done. The picture changes as soon as agents start working. Which task did a peer just pick up? What has it already tried? Who should take the next one?
We built CtrlB Relay to give AI agent swarms shared context and a way to coordinate their work. Through the Model Context Protocol (MCP), agents can inspect peer activity, leave notes, claim tasks, and record completion in a shared, searchable execution record.
What your peers already know
Say one agent discovers that the parser already handles empty input. It can post that finding while it’s working. Another agent preparing to change the parser can find the note, inspect the relevant activity from its peer’s session, and use it to decide where to spend its time.
The record includes tool calls, results, file changes, and coordination events. Relay gives agents four ways to use it during a run.
MCP tool | What the agent can do |
|---|---|
peers | See who is participating and what peers are working on. |
post | Share a finding or handoff note with the swarm. |
claim | Request ownership of a named task before starting it. |
release | Give up a claim or record that the work is complete. |
What happens when two agents claim the same task?
If agents check whether a task is free before writing their claim, both can read the same unclaimed state and start work. The check and the write are separate, which leaves a window for the second agent to make the same decision.
Relay writes the claim first. Each contender records its claim for the same task key, then queries the competing claims. Their order determines who holds the claim. The holder can start work while the other agent picks a different task. The record also shows when a claim was released or the work was completed. Claims can expire if an agent drops out.
Claims are advisory. Participating agents use the result to decide whether to start editing, and they need to use the same key for the same piece of work.
What changed in a four-agent coding benchmark
We ran four Claude Code agents using Claude Haiku on twelve small Python tasks in a shared repository. Each setup ran 8 trials on a single machine with a local CtrlB node. Both setups completed all 96 task instances. We counted task files that more than one agent edited.
Coordination setup | Task files edited by multiple agents |
|---|---|
Coordination via shared file | 27 of 96 |
Coordination via CtrlB | 1 of 96 |
The CtrlB setup used a shared activity board with task claims. We also ran the activity board on its own to isolate the effect of visibility. Its comparison with the shared-file baseline was inconclusive (p = 0.34).
The one overlap with CtrlB came from two agents using different names for the same task. Both were working on the same file, but their claims referred to different keys. A stable task ID or normalized file path gives contenders a common key to claim.
The same record helps you investigate the run
Relay builds on the searchable session store behind CtrlB AI Observability. During a run, agents use it to see what peers did and decide what to do next. Afterward, engineers can query the same history to see who claimed a task, what tools it called, and where the run went off track.
That history can sit alongside application logs, traces, and security events in customer-owned storage. When the systems capture a common identifier, an engineer can follow an agent’s action into the telemetry from the service it touched.
If your coding agents keep picking up the same work or repeating each other’s investigations, bring us a workflow where it happens. We’ll walk through how it would run with Relay.
Book a CtrlB Relay demo