Coordinating agents through shared memory

Most systems that run several language-model agents at once add a coordination layer beside the memory layer: a task queue, a message bus, an orchestration graph that decides which agent acts next. The two layers are built, versioned, and reasoned about separately, and an agent that needs to know what a peer is doing has to query the coordination layer specifically for that purpose.

Coordinating agents through shared memory describes the alternative: a population of agents reads and writes the same typed graph already described in substrate memory, and coordination follows from what is already visible there rather than from a system built for that purpose. An agent picking up a unit of work reads the same entries that record decisions, findings, and open questions; nothing about a claim, a declared intention, or a stalled task lives in a store the rest of the graph cannot see.

Rather than treat every agent as a peer with equal authority, the model separates a single coordinating role, responsible for strategy and for deciding what work exists, from a population of execution agents that carry it out in parallel. Execution agents are differentiated by scope and by the resources assigned to them, not by a separate protocol for how they reason or which part of the graph they can read; each reasons over the same substrate the coordinating role does, working within a portion of it declared at the time work begins.

Strategy and cognition stay unified above that line. Parallelism is where the tiers diverge, not where reasoning does: an execution agent is a smaller-scoped instance of the same kind of reasoning the coordinating role performs, not a different, more constrained kind of process.

An alternative considered for this problem was isolating each agent's work in its own copy of the underlying files, such as a separate branch or working copy, and reconciling the differences afterward. That approach fails specifically once agents run on separate machines: two isolated copies are blind to each other until the point they are reconciled, by which time both agents have already done the conflicting work. A shared, observable layer can surface an overlap before either agent writes anything, which isolate-then-reconcile cannot do by construction.

A unit of work assigned to the population is itself an entry in the graph, claimed by exactly one agent at a time. Claiming is atomic: when several agents attempt to claim from the same queue at once, each receives a different unit of work rather than several agents receiving the same one and discovering the collision only afterward.

Progress is recorded as a sequence of dated additions to that same entry, rather than in a separate status field a peer has to look up elsewhere: a claim, zero or more progress notes, a completion, a review. An agent that picks up a stalled or reassigned unit of work reads that sequence and the entries it references, rather than being handed a summary assembled specifically for the handoff.

Because recovering from a stall means rereading the graph rather than replaying a saved process state, no separate retry or recovery machinery is required. A unit of work left incomplete becomes available to claim again after a period of inactivity, and the agent that picks it up next has exactly the record its predecessor left, not a report generated after the fact.