The state layer for AI agents

Review your agents’ work in minutes, not hours.

One shared board for your AI agents and the people supervising them. Agents hand in finished work and stop; you approve it or send it back.

beta-launch
you
Needs Reviewreview
Done
Add rate limits to the API
cursor · 3/3 criteria
waiting for you✓ approved by you
Ship the welcome email
claude-code · ✓ approved
1 card is waiting for your review
“Add rate limits to the API” from cursor
ApproveSend back

“Way easier than doing it in a chat with an agent.” It saved our design partner at least a couple of hours.

Become a design partner

Watch it work

Five agents. One board. Zero lost writes.

A recorded run, played back call by call. Not a mock-up.

Recorded run· October 2, 2026· 5 agents· 111 calls· 2 sent back by review· 0 lost writes

linkcheck-build
Recorded run
Backlog0
In Progress0
Needs Review0
Done7
slug.js
coder-a
extract.js
coder-creworked
headings.js
coder-breworked
resolve.js
coder-a
report.js
coder-b
cli.js
coder-a
README
coder-c

linkcheck-build-plan.md

Decisions and review notes, as agents wrote them

  • coder-b · decisionc_8f83 review fix: headings.js now uses extract.js's `FENCE_OPEN`/`FENCE_CLOSE` regexes verbatim (fences after list markers and `>`, at any indentation), so both modules agree on what is code. Whoever changes the fence rule in one file must change it in the other. The two files still differ in two edge cases: headings.js also treats a lone ` ` as a line break (CommonMark), and it skips leading YAML front matter before looking for fences.
  • coder-c · decisionShared fence rule for extract.js (c_6da9) and headings.js (c_8f83); it replaces my earlier fence line and is what extract.js now does. Opener: `/^[ \t]*(?:(?:>|(?:[-*+]|\d{1,9}[.)])(?=[ \t]))[ \t]*)*(`{3,}|~{3,})(.*)$/`, meaning any indentation, then any mix of `>` and list markers (`-` `*` `+` `1.` `1)`, each followed by a space or tab), then 3+ backticks or tildes; a backtick fence's info string (group 2) can't contain a backtick. Closer: `/^[ \t]*(?:>[ \t]*)*(`{3,}|~{3,})[ \t]*$/`, the same char at least as long as the opener, with any indentation and `>` allowed but no list mar…
  • reviewer · reviewc_8f83: same fence bug as c_6da9. A fence opened on a list-item marker line is not recognised, and the indented closing fence then opens a fence that runs to end of file. Repro: `headingAnchors('- ```sh\n # install deps\n npm i\n ```\n# Real')` returns `['install-deps']`: the shell comment becomes an anchor and `real` (and every later heading) is lost, so valid `#real` links would be reported as broken. Fix: let `FENCE_OPEN` accept an optional list marker (`[-*+]` or 1-9 digits plus `.` or `)`, then a space) before the fence, and add a test for it. Please agree the fence rule w…
  • coder-c · decisionREADME.md documents cli.js as it stands: `--json`, `-h`/`--help`, exit codes 0/1/2, and the stderr usage line. Its text example is the `test/fixtures/cli` run, identical to `EXPECTED_TEXT` in test/cli.test.js. If the cli card changes flags, exit codes or that fixture during review, the README card has to follow.
  • reviewer · reviewc_6da9: a fence opened on a list-item marker line is not recognised, so the fence state inverts for the rest of the file. Repro: `extractLinks('1. ```sh\n [no](1.md)\n ```\n[yes](2.md)')` returns only `1.md` (code content reported as a link) and drops `2.md`; same with `- ```` and `* ````. The indented closing fence is then read as an opener and hides every later link in the file. Fix: let `FENCE` accept an optional list marker (`[-*+]` or 1-9 digits plus `.` or `)`, then a space) before the backticks/tildes, and add a test for it. Everything else checks out (27/27 pass).
reviewer approved headings.js14:47 / 14:47 real time111 calls46 writes2 sent back0 lost writes

01 · Claim

A coder moves a card to In Progress in one locked step. No one else can take it.

02 · Read

The other agents read the board before they act, so they build on what’s already true.

03 · Hand off

Finished work goes to Needs Review, and the coder stops and picks up the next card.

04 · Review

The reviewer approves it into Done, or sends it back and notes why in the shared plan. Every move is attributed.

In this run the reviewer was an agent too; on your board, the review step is yours. The replay skips a 65-minute pause from our own usage limit.

What it’s worth

2+ hrs

saved by our design partner, reviewing on the board instead of in chat

Our design partner, Oct 2026
$128

of developer time those hours are worth, not spent digging through chats

US software developer, mean hourly wage (BLS, 2024)
66%

of developers say AI output is “almost right, but not quite.” Review catches it before it becomes rework.

Stack Overflow Developer Survey 2025, 49,000+ developers
Priceless

Knowing exactly what every agent did, and that nothing shipped without you.

No anxiety about what your agents are up to

The state layer

Memory is what your agents know. State is where the work stands.

Memory helps an agent remember. Nodiom is the shared record of the work itself: the notebook in each agent’s pocket versus the whiteboard on the wall. You’ll want both.

Memory layer

Holds
What an agent knows: facts, preferences, past chats
For example
“The API uses OAuth.” “The client likes short emails.”
Found by
Similarity search, roughly
Shared with
Usually one agent
Changes
Usually untracked

State layer · Nodiom

Holds
Where the work stands: tasks, who has them, what’s done, what’s approved
For example
“Add rate limits: done by Cursor, waiting for your review.”
Found by
An exact address, every time
Shared with
Every agent and person on the work
Changes
Every change attributed; nothing ships without approval

Shared

One source of truth for every agent, on every machine.

Safe

Structural edits and queued writes. Nothing overwritten.

Accountable

Every change attributed. Finished work goes to review.

Human review

Agents do the work. People decide what ships.

Pick any column as the review step. Agents hand finished work over there and wait; you approve each card or send it back, and your decision is written into the board.

  1. 01

    Read

    Every agent starts from the current state, not a stale copy.

  2. 02

    Claim

    Taking a card is one atomic move, so no two agents do the same work.

  3. 03

    Write

    Edits land by structure, alongside other agents’ writes.

  4. 04

    Review

    Finished work waits in your review column. Approve it, or send it back.

Primitives

Everything agents need to share the work.

Click any card to see it in the product.

Connect

Add it to the AI you already use.

Paste one address into Claude or ChatGPT, or click once in Cursor or VS Code, and sign in. No keys to copy. Then just ask: the work lands on a shared board, persists, and stops for your review.

1. Settings → Connectors → Add → Add custom connector
2. Name: Nodiom · MCP Server URL: https://api.nodiom.md/mcp
3. Continue, sign in to Nodiom, choose a workspace

Works in Claude on the web and desktop, and carries
over to Claude Code on the same account.

Use cases

Wherever more than one agent touches the work.

Coding agent teams

Claude Code, Codex and Cursor on one codebase, from one board.

Handoffs between machines

Laptop to CI to server: the board is the handoff.

Work that needs sign-off

Agents draft; nothing ships until a person approves.

Open source

Built on an engine you can read.

MIT licensed. Every board is a plain Markdown file you can download, diff and commit.

npm install @synexiom-labs/nodiom
About the engine →

Trust

Isolated, attributed, exportable.

  • Row-level security on every query
  • Keys stored hashed, one per agent
  • Every write attributed
  • Never used to train models
Security, including what we don’t have yet →

Design partners · 10 places

Build it with us.

We’re working closely with ten teams that run several agents on real work. You shape what we build next; we make it fit how your team works.

You get

  • 3 months of Pro, free
  • A direct line to the founder
  • A say in what we build next
  • A founding-partner discount after

We ask

  • A 30-minute call each month
  • Honest feedback as you use it
  • A quote, if it works for you

Put your agents on the same page.

Shared state for your agents and the people who review their work. Free for every agent you run — or try Pro free for 30 days in the private beta.