Automations

Automations are triggers + actions. When something happens (state change, SLA breach, comment added, AI decision), run one or more actions. Every automation is declared in YAML and lives with the workflow it belongs to.

Creating a recipe

From the Automations page:

1. Click New recipe. Pick a name, trigger (case.created, sla.breach, etc.), and a primary action (notify, webhook, assign, transition, add_comment).
2. Save. The recipe is active by default — toggle the enable pill on the card to pause it.
3. Fine-tune the action payload (channel, webhook URL, predicate) by opening the recipe's YAML in the workspace editor.

Cards expose Edit (re-opens the name/trigger/action dropdowns), Delete (stops firing immediately; audit log retained), and an enable/disable pill for quick pauses.

Where automations live

Two places:

1. Inside a workflow file (.kiket/workflows/*.yaml), scoped to one state:

states:
  legal_review:
    on_enter:
      - notify: { channel: slack:#contracts }
      - ai_analyze: { agent: legal.risk_scorer }
    on_sla_breach:
      - escalate: { to: oncall }

2. As a standalone automation file (.kiket/automations/*.yaml), scoped to a workspace:

key: notify-on-high-priority
name: Notify on high-priority cases
trigger:
  event: case.created
  when: "priority == 'high'"
actions:
  - notify: { channel: slack:#urgent }
  - assign: { to: "@oncall" }

Use in-workflow for state-specific actions (on-enter, on-breach). Use standalone for cross-process patterns ("notify on anything with security label, anywhere").

Triggers

Every trigger supports a when: predicate, evaluated against the event payload. Predicates are JMESPath-lite; they're sandboxed and don't execute arbitrary code.

Actions

Built-in actions:

• notify — send a notification (in-app, email, or via an extension like Slack).
• webhook — POST to an arbitrary URL with the event payload.
• transition — move the case to another state.
• assign — set the assignee.
• set_field — mutate a field.
• add_comment — post a comment as a system user.
• escalate — page the on-call rotation.
• ai_analyze — call an AI agent; the result attaches as a comment with reasoning.
• create_case — create a related case in another monitored process.

Custom actions come from installed extensions (Slack, Teams, Twilio, etc.). Each extension declares which actions it exposes.

Examples

Re-assign based on a field

trigger:
  event: case.created
  when: "fields.team == 'security'"
actions:
  - assign: { to: "@security-oncall" }

Auto-escalate overdue contracts

trigger: { event: sla.breach }
actions:
  - notify: { channel: slack:#contracts-escalations }
  - set_field: { priority: critical }

Weekly summary

trigger:
  event: schedule.cron
  cron: "0 9 * * MON"
actions:
  - webhook:
      url: https://hooks.example.com/kiket-weekly
      body: |
        {
          "stuck_cases": {{ query("state == 'in_review' && sla.breached") }}
        }

Safety rails

• Rate-limited per action type (configurable per org; default 60/minute per action).
• Idempotent retries for transient failures (webhook, AI calls).
• Audit log entry for every automation run, with input, output, and duration.
• No arbitrary code execution — predicates and templates are sandboxed.

Editing surfaces

The workflow visual editor has an Automations tab on every state's inspector. The standalone .kiket/automations/*.yaml files are edited in the workspace editor or your IDE.

What's next?