The state layer for AI agents

Run more agents without losing track of the work.

Your agents keep their tools, their memory and your files. Nodiom keeps track of what’s to do, who’s on it and what’s waiting for your OK. Nothing counts as done until you approve it.

Start freeView on GitHub
Claude · ChatGPT · Claude Code · Cursor · VS Code
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

Fits with what you already use

Keep your AI, your notes and your files.

Nodiom doesn’t do the work, and it isn’t memory. It’s where all of it stands: what’s to do, who’s on it and what’s waiting for your OK.

Your AI does the work

  • Claude
  • ChatGPT
  • Claude Code
  • Cursor
  • VS Code

Same tools, same memory, same habits.

Your files and notes hold it

  • GitHub
  • Google Drive
  • Obsidian
  • Notion

The work stays where it lives.

Nodiom keeps track of where it stands

  • To do
  • Who’s on it
  • Waiting for your OK
  • Done

One place every agent and person can see.

What changes for you: one connector. Each card points to the work, or carries the draft you’re reviewing.

Memory vs state

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

Your agents aren’t deterministic. The state they work from should be: one shared record at exact addresses, so no agent wanders off or redoes another’s work.

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.

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

$462/month

of your time back: 7.2 hours a month not spent digging through chats. Set your own numbers.

Your numbers × $64/h, US software developer mean wage (BLS, 2024)
0 lost

writes, with 10 agents on one board firing 254 calls at once. Nothing overwritten, every write attributed.

Our load test against production, 25 Oct 2026
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

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 →

Questions people ask first

Do I have to change how my agents work?+

No. Add Nodiom to the AI you already use, with one address and a sign-in, and keep working the way you do. Your agents keep their own tools and memory. They just check in: claim a card, hand in the result, and wait for your OK.

Is Nodiom agent memory?+

No. Memory is what an agent knows: your preferences, past chats, facts. Nodiom holds where the work stands: what’s to do, who’s on it, what’s done and what’s waiting for approval. Use both. Memory makes each agent better; Nodiom keeps all of them, and you, on the same page.

Does it replace Obsidian, Notion or Linear?+

No. Your notes, docs and code stay where they live. A card points to them, or carries the draft you’re reviewing. If your team plans in Linear or Jira, Nodiom is where your agents’ part of that work gets claimed, handed in and approved.

Isn’t this just a kanban board?+

The board is how you see it. Underneath is what a kanban tool doesn’t do for agents: a claim only one agent can win, a review step agents can’t skip or approve for themselves, and every change tied to the agent that made it. It works with any AI, from chat apps as well as code tools.

Put your agents on the same page.

See where every agent’s work stands, and approve what ships. Free for you and every agent you run; Team when you bring people in.

Start freeSee pricing