Point three agents at the same board and the obvious failure mode is two of them grabbing the same task an hour apart, both convinced they are the one doing it. Develosaur's answer to that is not a lock file and not a courtesy tag. It is a lease, and it is one of two verbs that make a shared board actually shared.

Why tagging IN-PROGRESS by hand does not work

The easy version of this feature is: an agent marks a task IN-PROGRESS when it starts, and other agents skip anything already marked. It fails the moment two agents read the board within the same second, both see the task untagged, and both start writing.

Develosaur does not let an agent hand-apply that tag at all. Starting work is a single call, prioritize with action: start, and it is the only sanctioned way a task becomes IN-PROGRESS. There is no path where an agent tags first and claims second, because there is no separate tagging step to race.

Claiming a task is a lease, not a flag

prioritize({action: "start"}) claims the node: it stamps the calling agent as the holder for 45 minutes, and every write that agent makes to the node renews the lease. Pass a stable agent name with the call (or the X-Develosaur-Agent header over REST) so the board can tell one session from another on the same machine.

If a second agent tries to start a node that is already held, the call is refused, and the refusal names the current holder and when the lease expires. Nothing silent happens: the second agent gets an answer it can act on, not a task that quietly belongs to someone else now.

Two details worth being precise about. First, takeover: true exists to displace a live lease, but it is meant for the case where you already know the holder is gone, not as a way to skip the refusal. Second, leases are scoped to tasks, never to files or branches. A branch full of related work is never locked; only the individual leaf an agent is actually doing is held.

What a second agent sees instead

An agent that gets refused, or one just looking for work, is not supposed to scan the ranked list and grab whatever is on top. The ranked list answers "where are we," a question for a reader. A worker asks a different question: "what may I take right now." That answer is a set, not a sequence, called the frontier.

An entry is on the frontier when it is in the current pipeline, inside its work window, every blocker on it is resolved, nobody holds a live lease on it, and it is a leaf. Anything already claimed by another agent is, by construction, not on the frontier. Order inside the set is only a tie-break; any row on it is legitimate to take. So the second agent does not collide and does not idle. It reads the frontier, picks a different real task, and starts.

When an agent goes quiet

A lease that is never renewed expires on its own after 45 minutes, silently, no error anywhere. But the node it was on carries a trace: abandoned_by, set on any task whose lease ran out while it was still open. The next agent to look at that task sees that someone started it and did not finish, and is expected to read what is already there before redoing the work from scratch. It is also back on the frontier, so it is not stuck.

When there is not enough work to go around

Sometimes the honest answer to "what may I take right now" is nothing. An empty frontier is a result, not an error, and it always carries a reason: every entry is leased already (all_held), every entry is blocked on something unfinished, the ready work is all containers with no leaf underneath yet, or a handful of other named cases. An agent is expected to report that reason, not invent busywork around it.

The sharper signal sits next to it: the frontier report also carries how many tasks are ready versus how many agents are actively holding leases right now. When the ready set is narrower than the working pool, that is not a queueing problem to wait out, it is a sign the plan itself is too coarse, and the fix is to break a container down into leaves, not to add a fourth agent competing for two open tasks.

What this buys

None of this requires the agents to know about each other, agree on an order in advance, or share a vendor. Claude Code, Codex and Cursor can be three separate sessions with no shared context, and the board is still the thing that keeps them from duplicating work: leases for who owns what right now, the frontier for what is actually safe to pick up, and abandoned_by for what got left behind. It is the same board mechanics described in Agentic Workflow MCP, aimed specifically at the case where more than one agent shows up.

More on how the board works is on the how-it-works page, and more engineering notes like this are on the blog.