Automation rules
A rule = WHEN something happens in the map → IF the conditions hold → DO the actions. The map then handles part of the work itself: hands over goals, watches deadlines, creates steps, launches agents. Runs are never counted or billed — use as many rules as you like.
Where to find rules
Fastest in the goal window: open a goal (pencil or double-click) and pick the Automation category on the left. The "Rules of this node" panel is there — + New rule pre-fills the open goal, and the clock icon next to each rule opens its run log in one click:
The Automation category keeps together everything a goal can do on its own: who performs the step (human / automation), the "I wish this were automated" switch, Wait for children with the "After unblocking" block — and rules:
The overview of all rules of the map (toggle, edit, delete, templates, log) lives under the ⚡ icon in the map toolbar — on a narrow screen inside the ⋮ menu.
What a rule can do
Triggers (WHEN): a goal's status changes (optionally to one specific status), a goal unblocks (its subtree is done), a new goal appears, a file is uploaded, on a schedule (daily/weekly) and deadline approaching / overdue. Deadline triggers are evaluated once a day in the background — not on save. "N days overdue" means at least N days past the deadline: it also catches deadlines that expired before the rule existed, and fires once per deadline (a changed deadline is a new agreement and may fire again).
Conditions (IF): status, responsible person, deadline, executor — all must hold at once. The "parent node" condition targets the cards UNDER a specific goal — the kanban building block below.
Actions (DO): set status · assign the responsible person · set a deadline · move the node (under a chosen goal, appended at the end of its row) · create sub-goals · send a notification · run an agent. The first three accept "On node" — the action's target: the node that fired the rule (default), the parent node, or any specific goal of the map. And instead of a specific person you can aim at a deputy or a position — resolved at run time:
Kanban: a finished card travels to the next column by itself
Got a permanent map with process steps side by side (say the 8D report disciplines) and work cards (complaints) under them? The Enable kanban button (in the ⚡ overview and in the Automation category) opens a wizard: pick the column row, optionally a person per column — and the wizard creates one rule per step: "a card under D1 marked Done → move it under D2, hand it to the column's person and return it to To do". Mark a complaint as done and it travels to the next discipline on its own, to the right person:
The generated rules are ordinary map rules — edit, disable or delete them individually in the overview. Moves show up in "What changed" under the Moved group (from → to).
You can tell a map runs in kanban mode from the toolbar too: the Arrange button turns into a Kanban indicator (alignment styles have nothing to rearrange on a kanban board — the move rules own the layout).
Good to know: a moved card is appended at the end of the row of its new column and the rest of the map stays put (manual layout is preserved). Under the last column the card simply stays done — the chain ends there and the case is closed. A colleague who has the map open at that moment sees the move after a short while via the "map has changed — reload" bar (a move is a structural change, which is never silently merged into unsaved work).
Kanban from a template: the project is born with its rules
You don't have to enable kanban by hand: the "8D Report — Kanban" and "FMEA — Kanban" templates (next to the classic versions) live in the New project → From template picker and in the template gallery, where they get their own Kanban section. The template carries the rule chain inside — you can tell by the "includes 7 automation rules" badge — and a project created from it opens straight as a kanban board (columns in one row): create cards under the first column, a finished card travels to the next step by itself and returns to To do. People per column are yours to add (the template carries none — edit the rules in the ⚡ overview):
Rules travel with the map: export and import
Exporting a project to JSON now bundles the map's rules and import creates them again — a kanban board survives being passed between instances. The import summary honestly reports how many rules made it; whatever cannot be created on the new map is openly skipped (counted, nothing vanishes silently). Older exports without rules keep working unchanged.
Both directions respect privacy: the "without people" export leaves out actions that target a specific person (assign a person, notify an e-mail) — roles like "node owner" or positions stay. And import never lets an e-mail unknown to your instance into the rules.
Chaining: a finished sub-step starts the step above it
An action may fire another rule (up to depth 3 — a loop safeguard). A popular cascade: a rule on the sub-step "status → Done, set In progress on the parent node" plus a rule on the parent "status → In progress, assign the position holder". A task never "lights up" for anyone before it is actually next — and then it lights up by itself, for the right person, even if the people on the positions have changed in the meantime.
The run log — what the rules really did
Every run is recorded honestly: ok (and which actions), failed (why — and the map owner gets a one-off message), skipped (a safeguard stopped it, or a dynamic target could not be resolved — the reason is written in plain language). The log opens from the ⚡ overview and from the clock right next to a rule in the goal window:
Templates
Save a proven rule with the bookmark button as a template — the library is shared by the whole instance and "From template" loads it into any map as an independent copy.