Run two coding agents on the same backlog for an afternoon and there is a fair chance you will watch both of them fix the same bug. Neither did anything wrong. Each read the to-do list, saw an open item and started work, because nothing told the second agent that the first had already begun.

Once you run more than one agent, the work needs one list everyone can see and a rule that only one worker holds a task at a time. Everything below follows from that sentence.

The pattern

On 18 November 2026 Vercel launched Vercel Board as "an experimental agentic primitive". Its description of the problem is refreshingly plain: "A single agent can track its work in a Markdown file, but there isn't a purpose-built primitive for tracking tasks, delegation, statuses, logs, and completed work across many agents and subagents." Vercel says it ran into this internally, first with a swarm of security agents scanning its codebases and then with v0's software factory, which it rebuilt on Board and which, it says, now merges over 50% of PRs. That figure is Vercel reporting on its own system, with no detail on what counts or how the work was chosen. Read it as a sign the company uses the thing every day, and nothing more.

The idea underneath is older than Vercel and simpler than the product. Work lives as tasks on one shared board. A worker, human or agent, claims a task. The claim is a lease: it lasts a fixed time, and the worker has to renew it while it keeps working. Progress goes into the task's thread, where anyone can read it. When the worker finishes, it closes the task with a result, such as a pull request link. If the worker crashes or stalls, the lease runs out and the task goes back on the board for someone else.

Most of the safety comes from that expiry. Read "lease" as a lock with a use-by date. A plain lock fails badly when its holder dies, because the task stays locked until a human notices. A lease fails gently, because the worst case is a short wait before another worker picks the task up.

When to use it, and when not

Use a shared board when more than one agent, or a mix of agents and people, pull from the same backlog. Use it when work arrives from somewhere else, such as a Slack message or a GitHub issue, and you want it picked up without you acting as the dispatcher. And use it when you want a record of who claimed what and what they said they finished, because the day an agent ships something odd, that record will be the first thing you want to read.

Skip it when one agent does one job. Vercel concedes a Markdown file is enough there, and in one agent per job we argued for building one agent for each recurring job; a single agent working through its own queue rarely needs to lock anything. Skip it too when tasks are so short and harmless that the bookkeeping costs more than the odd duplicate. If a task takes ten seconds and running it twice hurts nobody, let two agents race.

As for Board itself, it is experimental, and the docs say "Behavior, APIs, and limits may change." The same page says Board is free while it is experimental and that Vercel may charge for it in future (as of 20 November 2026). Building on it today means accepting both. One more honest note: the animated demo on the launch page is, in Vercel's words, "a scripted run" in which "no models ran".

How it works

Follow one task through its life, as input, step and output.

  1. Create. Input: a piece of work, written as instructions. Step: someone posts it to the board with labels such as kind=bug. Output: a task in the ready state. In Board that is vercel board tasks create work "fix the flaky deploy test".

  2. Claim with a lease. Input: a worker looking for work. Step: it asks for the oldest ready task that matches its labels, and the board hands it over with an expiry time. Output: a claimed task with one holder. Vercel's example, vercel board tasks claim --ready dev --label kind=bug --wait 10m, waits up to ten minutes for a matching task. The task docs say that when two workers claim the same task, one succeeds and the other fails with task_claimed.

  3. Heartbeat and renew. Input: a worker that is still busy. Step: it renews the lease before it runs out and posts progress to the thread. Output: a fresh expiry and a log a person can follow. In Board a lease lasts up to five minutes, renewing extends it from now, and the tasks run command renews automatically at a third of the lease while your command runs.

  4. Post the result. Input: finished work. Step: the worker completes the task with a result message. Output: a closed task whose thread holds the request, the progress notes and the result. Vercel's example closes a task with "Can I get a review? <pr-url>".

  5. Release on expiry. Input: a worker that went quiet. Step: nothing happens, and the clock runs out. Output: the task is ready again for another worker.

Most home-made versions miss one detail in that last step. In Board, once a lease runs out, the old holder's renew, complete and fail calls fail with claim_lost and change nothing. A worker that wakes up late cannot overwrite the work of the worker that took over. Without that rule, a slow agent that comes back late can quietly undo a finished task.

Two extras earn their place once you have several kinds of task. Dependencies let one task wait for another: with --needs <id>, a review task stays waiting until its fix completes, while independent fixes run in parallel. A hold lets a worker park a task for a person ("approve the prod deploy?"); blocking ends the worker's claim, the person answers in the thread, and once the task's owner lifts the hold the task goes back in the queue. Both fit the design below with a column or two more.

The components

Strip away the product and you need five things.

  • A task store with a status for each task (open, claimed, done, failed) and the fields that describe a claim: who holds it, and when the lease expires.

  • An atomic claim, so that two workers asking at the same instant cannot both win. In a database that means one conditional update, never a read followed by a separate write.

  • A renewal call that succeeds only for the current holder while the lease is still live.

  • A thread or event log for each task, where workers post progress and people can reply.

  • A completion call that refuses to close a task without a result, and refuses any caller whose lease has gone.

Vercel layers a good deal on top: two-way sync with Slack and GitHub, watchers that run agents when a new reply is posted or a label changes, schemas that validate structured posts, per-channel grants that decide who can read, post and manage, an event log that records every change, and scheduled follow-ups, such as an agent reminding itself to check CI in 5 minutes after opening a pull request. It also calls Board "harness agnostic" and lists Claude Code, Codex, Pi, OpenCode, eve, fx, Mastra and LangChain. Those additions help a team with many tools. A solo builder can start without any of them.

The board also fits neatly with a lead agent. Vercel's docs describe the split directly: "A lead agent plans work as tasks, and a pool of workers claims and completes them." If you already run a planner like the one in read before you commit, the board becomes the place its plan lands, and the workers stop needing to talk to the planner at all.

A minimal version you can build this weekend

You do not need Vercel for any of this. A Postgres database is enough, and a free Supabase project gives you one in a few minutes. Two tables carry the whole pattern: one for tasks and one for the events in each task's thread.

create table tasks (
  id               bigserial primary key,
  title            text not null,
  instructions     text not null,
  status           text not null default 'open'
                   check (status in ('open','claimed','done','failed')),
  claimed_by       text,
  claim_token      uuid,
  lease_expires_at timestamptz,
  attempts         int not null default 0,
  result           text,
  created_at       timestamptz not null default now(),
  check (status <> 'done' or length(coalesce(result,'')) > 0)
);

create table task_events (
  id         bigserial primary key,
  task_id    bigint not null references tasks(id),
  actor      text not null,
  kind       text not null,   -- claimed, progress, result, failed, expired
  body       text,
  created_at timestamptz not null default now()
);

The last check on tasks means the database itself will refuse to mark a task done with an empty result. Now the claim. This one query has to be right:

update tasks
set status = 'claimed',
    claimed_by = $1,                       -- worker name
    claim_token = gen_random_uuid(),
    lease_expires_at = now() + interval '5 minutes',
    attempts = attempts + 1
where id = (
  select id from tasks
  where (status = 'open'
         or (status = 'claimed' and lease_expires_at < now()))
    and attempts < 3
  order by created_at
  for update skip locked
  limit 1
)
returning id, title, instructions, claim_token;

Three parts of that query do the work. The inner where accepts either an open task or a claimed one whose lease has expired, which is how abandoned work comes back. for update skip locked tells Postgres to lock the row it picks and lets a second worker skip past it to the next one, so two workers asking at once get two different tasks. And returning hands the worker its task in the same statement, so there is no gap between deciding and taking. The attempts < 3 condition stops a task that keeps killing workers from being retried forever.

Renewing and completing both check the token, so a stale worker cannot touch a task someone else now holds:

-- renew (heartbeat)
update tasks
set lease_expires_at = now() + interval '5 minutes'
where id = $1 and claim_token = $2
  and status = 'claimed' and lease_expires_at > now()
returning id;

-- complete
update tasks
set status = 'done', result = $3, lease_expires_at = null
where id = $1 and claim_token = $2
  and status = 'claimed' and lease_expires_at > now()
returning id;

If either query returns no row, the worker has lost its claim and should stop. The token matters because a worker's name is not enough: if you run two copies of the same agent, both are called "writer", and only a fresh random token per claim tells them apart. Engineers call this a fencing token.

The worker loop is short. In pseudo-code:

loop:
  task = claim(my_name)
  if none: sleep 30s; continue
  log(task, "claimed")
  start a timer that calls renew(task) every 100 seconds
      if renew returns nothing: cancel the agent run, stop
  output = run_agent(task.instructions)
      (post progress with log(task, "progress", note) as it goes)
  if output has a link, file or commit:
      if complete(task, output) returns nothing: discard output
      else log(task, "result", output)
  else:
      mark failed with the reason, log(task, "failed", reason)

Renewing every 100 seconds against a five-minute lease follows the same rhythm Board's tasks run uses, a third of the lease, which leaves room for two missed heartbeats before the task is released. The event table doubles as a step journal, so a worker that picks up a reclaimed task can read what the last holder got through before it died; we covered that idea in more depth in the durable step journal.

If you live in n8n, an n8n Data Table with the same columns works for a single scheduled worker. Once two workers run at the same time, move the claim into Postgres and call the query above from n8n's Postgres node. A lookup in one node followed by an update in another leaves a gap in which a second worker can take the same row, and that gap is exactly the bug this whole design exists to prevent.

Failure modes, and the evals that catch them

Three failures account for most of the pain, and each has a query that finds it.

Double work. Two workers produce results for the same task. With the claim above this should never happen, so test it rather than trust it: count tasks with more than one result event. The target is zero, and any non-zero number means a worker is skipping the token check.

select task_id, count(*) from task_events
where kind = 'result' group by task_id having count(*) > 1;

Stuck leases. Tasks sit in claimed long after their lease expired. Expiry alone does not move work; a live worker has to come along and claim it. If this query returns rows for more than a few minutes, your workers have stopped polling, or every remaining task has hit the attempts limit and needs a person.

select id, title, claimed_by, attempts from tasks
where status = 'claimed' and lease_expires_at < now() - interval '10 minutes';

Closing without a result. An agent marks a task done and leaves nothing behind. The check constraint blocks empty results, but an agent can still write "Done!" and move on. Once a week, pull ten completed tasks at random and check that each result points at something you can open: a link, a file or a commit. Our estimate is ten minutes a week, and nothing cheaper tells you whether "done" means done.

Two further risks come straight from Vercel's own warnings. Its docs say "Agents read messages as instructions", so anyone who can add a task can tell your agents what to do; keep the task table writable only by you and your planner. They also say to keep secrets off the board, which applies equally to a result column that agents fill with whatever they like.

Then run one deliberate test, the one that proves the lease works. Start two workers, give one a long task, and kill it with kill -9 halfway through. Within about six minutes the other worker should claim the task, and if you then replay the dead worker's complete call with its old token, the query should return nothing.

Build it this weekend

  1. Create a Postgres database (a free Supabase project is fine) and run the two create table statements.

  2. Seed 20 small tasks you would happily hand to an agent, such as "summarise this support email in three lines and suggest a reply" with the email pasted in.

  3. Write the worker loop in whatever language you use, with the claim, renew and complete queries above, and have it call your agent of choice.

  4. Run three copies of the worker with different names and watch the task_events table fill up.

  5. Do the kill test, then run the double-work and stuck-lease queries.

  6. Only then point your real agents at it.

Use one decision rule to judge whether you need any of this. If a task done twice would cost you real money, or a customer would see it twice, put your agents on a board with leases; if not, a shared Markdown file will do for now. Our estimate is an afternoon for the tables and the worker, and if the kill test passes you have the core of what Vercel shipped this week, in two tables you own.