Skip to content
IsoKron

Open source · MCP server

A work queue that keeps parallel coding agents out of each other’s way

sea-lite gives each agent a fenced, leased claim on a ticket and the paths it will edit, and refuses anyone else’s write.

Run as an MCP server (stdio)
npx -y sea-lite serve --core --actor agent
Add the git pre-commit guard
npx sea-lite precommit --install

For developers running several coding agents against one backlog and one repository.

Apache-2.0 · TypeScript · Node.js 20 or later · Built and maintained by IsoKron

What it does

  • Fenced claims. sea_next picks the best eligible ticket and claims it in one step. Every write must present the claim token it returns; a write from anyone else is refused, with who holds the ticket and until when.
  • Leases, not locks. Claims last 15 minutes by default (up to an hour) and renew on each of the holder’s sea-lite calls, or from a heartbeat hook while it edits. A ticket held by an agent that died becomes free again, with no sweeper or cron.
  • Path scopes. A claim can lock the paths the holder will edit. Overlapping scopes are refused, and an edit hook or the git pre-commit guard can refuse an edit or a commit inside someone else’s scope.
  • Typed links and all-or-nothing batches. depends_on, blocks and parent_of links stay acyclic, and sea_apply writes up to 50 tickets and 100 links as one unit or not at all.
  • Hash-chained history. Every change is an event on the same hash chain kronicle-lite keeps, in the same SQLite file. sea-lite verify recomputes it.
  • Light on context. serve --core publishes the nine day-to-day tools in about 12 KB of tools/list.

What it looks like

From the README’s tour, with no MCP client and no model: agent-a claims a ticket and locks src/auth, agent-b is refused a claim on a file inside it and takes the other ticket instead, and the board shows who holds what.
Claims, and a refused claim
$ sea-lite next --paths src/auth --actor agent-aclaimed f4ed5732  Add rate limiting to login  as agent-a until 22:45:12Z (15m00s left); locks src/auth$ sea-lite next --paths src/auth/session.ts --actor agent-bscope_conflict: scope overlaps a live claim: "agent-a" holds src/auth on ticket f4ed5732-477f-4335-aa20-0fa05f8fa2b4 ("Add rate limiting to login") until 2026-11-14T22:45:12.890Z$ sea-lite next --paths src/billing --actor agent-bclaimed eef6f5ca  Fix session expiry  as agent-b until 22:45:14Z (15m00s left); locks src/billing
sea-lite board
ID        STATUS   PRI     TITLE                       HOLDER   LOCKS        LEASE
eef6f5ca  triaged  medium  Fix session expiry          agent-b  src/billing  14m59s left
f4ed5732  triaged  medium  Add rate limiting to login  agent-a  src/auth     14m58s left

Run on 14 November 2026 in a new git repository with a fresh store, after creating the two tickets. The refused claim exits with code 1. The board’s first line, which names the project directory, is left out.

Used in our audits

In our audits, sea-lite tracks each finding through its gates. It is also our reference implementation of write safety: in our retry test, a create sent again with an idempotency key replayed the first result in 30 of 30 trials, and the same retry without a key duplicated the ticket in 30 of 30.

To have your own server tested this way, see MCP server audits.

The retry test and what it means for your server

Questions

What stops an agent that ignores its claim?

A claim token stops a well-behaved agent from writing a ticket it does not hold. It does not stop a process that edits the SQLite file directly; the hash chain makes that detectable (sea-lite verify), not impossible. The git pre-commit guard refuses a commit that stages files inside someone else’s live claim, whichever agent or person makes it, unless the commit skips hooks with --no-verify.

Can several agents share one queue?

Yes. Several server processes, one per agent or one shared, can point at the same file, and SQLite’s write lock keeps claims exclusive across them. For clients that cannot start a process, serve --http serves the queue on loopback with a token per actor.

Where this fits

An IsoKron audit tests whether your MCP server’s writes change the right data under concurrency, stale data, retries and partial failure, plus a targeted security review and the tool catalog’s token cost.

Request an audit or a build

Tell us which server and what you need. We reply to confirm the scope, the price and the dates.