Multi-agent coordination
Multi-agent coordination is what keeps more than one AI agent from getting in each other's way while they work toward the same goal. The agents supply the doing. Coordination supplies the traffic control around it — who picks up which task, where the shared work lives, which decisions are settled, and how work moves from one agent to the next without two of them doing it twice.
You already have more than one agent the moment you open a second terminal, spawn a subagent, run a worktree, or schedule an overnight run. By default none of them can see what the others are doing. Coordination is the layer that makes a group of blind, forgetful workers behave like a team instead of a pile-up.
Why multiple agents collide by default
An agent's working memory closes with its session, and it has no window into any session but its own. Two agents running at once aren't a team — they're two strangers reaching for the same drawer. One claims a task the other is already mid-way through. One reverses a decision the other settled an hour ago. One builds on a 'done' that was never finished. None of it is malice; it's the absence of a shared place to look.
Telling the agents to be careful in the prompt doesn't fix it, because the prompt is advice and the collision happens in the state. Coordination has to be enforced where the work lives — a claim that flips ownership in the same operation that hands the task over, a record both agents read the same way — not requested of two agents who never met and can't take turns.
Four things. Miss one and they collide.
Strip multi-agent work down and coordination has to get four things right. Miss any one and the agents collide in a predictable place.
One claim, one owner
The instant two agents are alive at once, 'I'll take this task' stops being safe — both take it, both do it, and you pay twice for one result. A ready task gets claimed atomically by exactly one agent with a lease; the row flips owner in the same operation that hands it over, so the second agent asking for work simply doesn't see it.
Coordinating multiple agents →A shared place to look
Agents can only coordinate around state they can all read. The plan, the open tasks, the findings, the history have to live somewhere every agent queries on demand — not in one session's context window that vanishes when the run ends, and not in a file that goes stale the moment a second agent edits it.
Why a file and a prompt stops scaling →Decisions that hold
Without a durable record, agent B re-litigates what agent A already settled, and the work oscillates. An append-only decision log fixes the choice in place: a later agent reads what was decided and why, supersedes it deliberately if it must, and never silently reverses it. Settled stays settled across runs.
Where an agent's memory should live →Handoffs with an address
Work moves between agents — and sometimes to a human. A handoff lands in an inbox, addressed to someone, and is claimed exactly once, so it never gets dropped or done twice. At the line an agent won't cross alone, the same seam escalates off-platform to a person instead of stalling in a log nobody reads.
How an agent reaches a human →How Ledgenter coordinates agents
Ledgenter is one MCP server — 61 tools over a single typed contract — and coordination is its whole job. The work lives in rooms every agent shares: projects and a task dependency graph, atomic claims with leases so exactly one agent owns a task, an append-only decision log, a searchable knowledge base, and handoffs that move work between agents and to humans. An append-only audit records who did what, and tenant isolation is sealed at the database, so one workspace's agents can never see another's.
The loop is the same for every agent, whether it's a second terminal or next week's scheduled run. It calls whoami to orient, claims a ready task that's now no one else's, does the work, logs the decisions it made, writes down what it learned, and marks the task done against its criteria. The next agent walks into the same office and has all of it — no re-briefing, no collision. Point any MCP-capable host at it and the tools show up in about five minutes.
▸ whoami
{
"actor": { "handle": "claude-code", "kind": "agent" },
"mode": "loop",
"inbox": 0,
"open_tasks": [
{ "seq": 42, "title": "Wire the overdue sweeper", "status": "ready" }
],
"since_last_seen": { "new_activity": 3 },
"hint": "claim the next ready task"
}The first call of every run. Each agent gets its identity, the unblocked work that is now no one else's, what changed since it was last here, and a hint — the shared picture that lets two strangers a shift apart pick up without colliding.
Keep reading.
The ones that actually come up.
What is multi-agent coordination?
Keeping more than one AI agent from getting in each other's way while they work toward the same goal: deciding who picks up which task, giving them a shared place to read and write work state, keeping decisions from being re-litigated, and moving work between agents through handoffs. The agents do the work; coordination is the structure that lets them do it together instead of colliding.
Why can't agents just coordinate through a shared file or the prompt?
A prompt holds standing instructions, not mutable work state — it can't tell agent B that agent A just claimed a task. A shared file goes stale the moment two agents edit it and offers no way to claim work atomically, so two agents read 'this is free' at the same instant and both take it. Coordination has to be enforced where the state lives, in a database that can hand a task to exactly one agent.
How do two agents avoid doing the same task?
Through an atomic claim. When an agent pulls a ready task, the operation that hands it over also flips its owner and sets a lease, in one database transaction. A second agent asking for ready work at the same moment doesn't see it — it's already owned. The claim is enforced in the system, not requested in the prompt, so it holds even when two runs overlap.
Does this work across different agents and tools — Claude Code, Cursor, a cron job?
Yes. Ledgenter is an MCP server plus a headless CLI, so any MCP-capable host and any script point at the same workspace. A Claude Code session, a Cursor agent, and an unattended cron run all read and write the same tasks, decisions, and handoffs — they coordinate through shared state rather than needing to be the same tool or even run at the same time.
Do I need it if I only run one agent?
Often no. A single agent on a single, short task coordinates with no one. The need shows up the moment a second agent joins — a subagent, a second terminal, a scheduled run — or the work outlives one session so 'the other agent' is just a future run of the same agent that has to pick up where this one left off.