Automations — when this happens, do that
Tick "Done" and watch the Stage flip to done by itself. An automation is a small rule you (or your AI) write once, and your Collection follows it from then on.
You tick the checkbox on a task. The Stage changes to done and the card slides out of your board — and you never clicked the Stage.
That's an automation: a small "when this happens, do that" rule that lives on a Collection. You didn't wait for us to build it. You asked your AI for it, and it wrote the rule.
The three parts
Every rule has the same three parts. Read them out loud and it's a sentence:
| Part | Means | Example |
|---|---|---|
| when | the thing that sets it off | when Done becomes ticked |
| if (optional) | an extra check before it runs | …and only if the Stage isn't already done |
| then | what happens | set Stage to done |
when — the trigger
Two things can set a rule off:
changed— a property's value changed. You can narrow it to a particular new value, a particular old value, or leave it open so any change fires the rule.created— a brand-new entry was just made. Handy for "every new task starts in do today".
A useful thing to know: dragging a card between columns on a Board is a change to whatever property the board groups by. So a rule like "when Stage becomes done, tick the Done box" works from a drag with nothing extra.
if — the optional gate
A check that has to pass before the rule runs. Same set of comparisons you already use for conditional card styling: is / is not, greater / less than, contains, empty, has a value. You can require all of them, or any of them.
Most rules don't need one. Reach for it when you want "…but only when".
then — the actions
What actually happens. A rule can do up to eight things in a row:
- set a property to a value
- set now — stamp a date or time property with this moment
- clear a property
- toggle a checkbox
- increment a number (counting attempts, streaks, retries)
- add tag / remove tag — one tag, leaving the others alone
Why this is safe
Everything an automation does is something you could have done yourself by tapping. It writes values, exactly like the app does when you edit a field — no hidden powers, nothing that reaches the internet, nothing that can delete an entry.
Three more things keep it calm:
- You always get a toast. When a rule fires you see "Stage → done · by 'Close out a finished task'" with an Undo button. Undo puts everything back, including the tick that started it.
- Loops are rejected before they save. If rule A would set off rule B which would set off rule A, Kaizendex refuses to save it and tells you exactly which action closes the loop.
- Rules cascade only a little. One rule can set off another — ticking Done sets the Stage, which stamps a date — but the chain stops after three steps, always.
Writing one
The easy way is to ask:
"When I tick Done on a task, set the Stage to done."
Your AI will describe the rule back to you in plain words and ask before saving it — an automation changes your data quietly and repeatedly, so it checks first.
To see or edit your rules by hand, open the Collection, click the ⋯ menu in the top bar, and choose Edit automations (JSON). That opens the same kind of editor you use for card layouts. The full grammar is in Automations reference, and there are ready-made rules to copy in Automation recipes.
Turning one off
Every rule has an on/off switch — in the JSON, that's "enabled": false. Flipping it off keeps the rule around without running it, which is the right move when you're not sure yet.
What it doesn't do (yet)
- Rules only run on your own edits — on any of your devices. A change your AI assistant makes in a chat doesn't set them off.
- Rules act on one entry — the one that changed. A rule can't reach into a different Collection.
- Rules can't send email, call a website, or do anything outside your own data.
Where to next
- Automations reference — every trigger, every check, every action, with copy-pasteable JSON.
- Automation recipes — worked examples you can lift.
- Customizing the card — the other half: what happens when you tap, rather than when a value changes.