Model the domain on a canvas, then let an agent author and check it

You run an Event Storming or C4 session before a build, the board fills up with events and open questions — and then it dies on a Miro tile disconnected from the plan. Nobody catches the broken causal chain, the hotspots get lost, and the diagram ends up a screenshot no agent can read or edit.

My Architect makes the board a real, gated part of the plan: a canvas an agent can author over MCP, a check that reads its grammar, and hotspots that turn into blockers gating "done".

Model the domain on a real canvas

Open a project and switch the canvas to Event Storming. It's a first-class diagram type, not a freeform sticky wall — it carries the canonical DDD taxonomy: Domain Event, Command, Policy, Read/Query Model, Actor, Aggregate, External System and Hotspot, each with the standard color and shape, plus bounded-context frames that move their cards as a group and causal arrows between cards.

The board is driven by a line-based DSL that is the source of truth — group opens a bounded context, [command] "…" / [event] "…" place typed cards, and connect "A" -> "B" draws a causal arrow. Because the DSL is the source of truth and the canvas is a view over it, an agent can author the whole board over MCP with create_diagram / update_diagram — no dragging, no screenshots. Drag a card by hand and its position round-trips back into the same text.

For structure diagrams, switch to Box (C4-style). Nested containers lay themselves out with ELK — layered or nested, six presets across three algorithms and two directions — so you never hand-place a box.

Check the board against Event Storming grammar

A whiteboard never tells you when a causal chain is broken. This one does. A pure sequence analyzer reads the board against ES grammar — Command → Aggregate → Event, Policy bridging one event to the next command, a Read Model feeding the actor's decision — and reports the gaps: a command with no effect, an event nothing produces, a dangling policy.

The same pass returns every Hotspot as an open question. On a Miro board a hotspot is a pink sticky someone eventually stops looking at. Here it becomes durable.

Turn hotspots into blockers that gate "done"

Call sync_diagram_hotspots on the node that owns the diagram. Each Hotspot becomes a per-node OQ (Open Question) requirement with a stable id — re-run it and nothing duplicates; remove a hotspot from the board and its question is marked deprecated, not silently dropped. A recorded decision closes it: set the OQ to approved and write the decision into its description. You never lose the original question.

These open questions join the node's blocker list alongside any blocks dependencies. And the blocker list gates completion: complete_task refuses to close a node while an OQ is still open, and validate_project flags any node marked done while it still owns a blocker. The status dropdown hard-disables done in the UI for the same reason. A green check can no longer mean nothing.

Hand the board to an agent — and read it inside the doc

Because the whole model — canvas, requirements, blockers, docs — is one tree over the same files, an agent works it through the standard loop: get_next_task → start_task → complete_task, with the status cascade rolling completion up the hierarchy on its own. The agent authors the Event Storming board, runs sync_diagram_hotspots, and hits the blocker gate exactly where a human would — it can't fake a done past an unanswered question.

And the diagram doesn't live in a separate tool. Drop an ```event-storming fenced block into any Markdown doc on a node and the board renders live inside it — the source-of-truth doc for that feature and its domain model in one place.

The aha

Run the sequence check and it flags the command that produces no effect. Sync the hotspots and the "which service owns the deposit-confirmed event?" sticky becomes an OQ that hard-blocks the node until someone decides. Your workshop board is now an executable, gated part of the plan — not a screenshot that drifts the moment the session ends.

The whiteboard is a record of a conversation. The gated board is a source of truth.

How to try it

  1. Create a project and open the getting-started guide — it walks you through sign-in and scaffolding.
  2. Switch the canvas to Event Storming, drop in a few bounded contexts and cards, and wire the causal arrows.
  3. Connect an AI agent over MCP and let it author the board, sync the hotspots, and work the tasks against the same gated model you see.