The canvas where
teams think together.

An infinite shared canvas with live cursors, conflict-free CRDT sync, and per-node access control — plus an AI layer that quietly turns every team discussion into a structured, shareable task list.

canvas · room/demo · live
3 active

Design review

3 open comments

API schema v2

alice · 2m ago

Ship by friday?

↳ AI: 3 tasks

Q3 roadmap

carol · 1m ago

User flows

bob · 8m ago

crdt · y.js∞ × ∞ canvasrbac · per-node<100ms syncai · task layer
3 online
∞ × ∞Canvas size
<100msSync latency
Y.jsCRDT engine
Per-nodeAccess control

Four ways teams already use the canvas.

01open a room URL
02drop nodes · invite team
03AI extracts intent
04tasks land in board
Real-time pairing

Two minds, one canvas, zero merge conflicts.

Sit beside a teammate without sitting beside them. Cursors glide in real time. Edits resolve at the CRDT layer before they ever conflict. The room behaves the way a whiteboard would, if a whiteboard were also instant, infinite, and remembered everything.

sessiony.js awarenesslive
session · y.js awareness · live
pair

auth.ts

alice editing

session middleware

open question →

JWT refresh flow

ben · 12s ago

race condition?

↳ 2 comments

extract to hook

agreed · ship

alice
ben
crdt · y.js · <100ms sync5 nodes · 2 live

Three moves from URL to shipped.

Enter01

A room, not a workspace.

Share a URL. That's the entire onboarding. No admin queues, no seat licenses, no per-user provisioning. The room is the unit of collaboration — its own permissions, its own history, its own identity. You're thinking together before anyone opens a settings page.

Auth·JWT · zero-config
Latency·first paint < 400ms
Identity·cursor + display name
Work02

Edits that don't conflict.

Two people type into the same node. Three people move the same block. Y.js resolves every operation at the data structure level before a conflict can form. No save button. No merge step. The canvas stays consistent the way physics stays consistent — as a property of the system, not a feature.

Engine·Y.Doc · CRDT
Transport·WebSocket · delta sync
Awareness·cursors + selections
Decide03

Thinking becomes work.

The intent layer reads what your team agreed to — across nodes, connections, comments, and decisions — and surfaces a clean task list. You approve, edit, or discard. The canvas remains the source of truth. The task list is just a fast, careful reader sitting on top of it.

Model·configurable · per-room
Output·structured task list
Loop·canvas → tasks → canvas

What makes it work differently.

Two editors, one truth.

Most collaboration tools resolve conflict through luck — last write wins, or a human picks the winner. Ligma resolves it through math. Y.js's CRDT model treats every operation as a permanent, order-independent fact. Any two clients that exchange the same set of operations will converge to an identical state. Always.

No version numbers. No conflict modals. No "someone else edited this" warnings. The canvas simply stays correct.

Y.Docdelta opsconvergenceWebSocket

Lock the node, not the document.

Document-level permissions are a blunt instrument. Either everyone can edit, or no one can. Real teams need something finer — the architecture decision node should be owner-only, the brainstorm cluster open to all, the payment config gated to seniors.

Per-node ACL gives you exactly that. Each node carries its own permission record. Change it without touching anything else on the canvas.

per-node ACLrole scopeowner / senior / viewerJWT

The canvas reads itself.

The intent layer classifies every node as it's typed — action, decision, question, or reference — and assembles a live task board in the sidebar. When the meeting ends, the task list is already structured. No manual transcription, no Notion export, no slack message summarising what was agreed.

You own the output. Approve, edit, or discard any item. The AI proposes; the team decides.

intent classificationaction · decision · question · reftask boardper-room model

Four convictions we shipped on.

Ligma is not a generic whiteboard. It encodes a specific opinion about how teams should think together — what should be fast, what should be local, what should be permissioned, and where the AI belongs.

I

The room is the unit.

Most tools start with the workspace and bury the work. We start with the room. Each canvas is a self-contained piece of context — its own permissions, its own history, its own URL. The team forms around the work, not the other way around.

II

Conflict is a data structure problem.

Locking, last-write-wins, manual merges — these are workarounds for tools that were never designed for simultaneity. We chose CRDTs because the math is honest: when two people edit at the same time, both edits are real, and the structure should know how to keep them.

III

Permissions belong on the node.

A document-level role model is too coarse. The senior architect should be able to lock a single decision node while leaving the rest of the canvas open. Per-node access control is not a feature — it is a position on what trust between collaborators actually means.

IV

AI assists, never authors.

The AI layer reads the canvas. It proposes a structured task list. It does not write your decisions for you, and it does not replace the discussion. The team remains the source of truth; the model is just a fast, careful reader.

Stop coordinating. Start thinking.

Open a canvas and invite your team in seconds. No setup. No seat licenses. Just a shared surface where the work actually happens.

no credit card · no workspace setup · open a room in <5s