Start free trial

Workflows

Build multi-step automations on a drag-and-drop canvas — or describe what you want and let the AI assistant generate the graph for you. Each step passes its output to the next. Run it instantly, invoke it as a !command, or put it on a schedule. Approval and prompt steps pause the run until someone responds, so human checkpoints are built in.

Key capabilities

  • Visual builder canvas plus an AI assistant that generates and refines the graph from natural language
  • 17 step types including Tool, AI Prompt, Condition, Transform, Loop, Filter, Delay, Notification, Script, Sub-workflow, Parallel Fork/Join, and Error Handler
  • Tool steps wired to any registered AI tool, with data passed from upstream outputs and workflow parameters
  • Approval and Prompt steps that pause the run for human approval or input, then resume from where they left off
  • Script steps for custom calculations, with AI-assisted drafting and a security review before they run
  • Three trigger modes: manual !command, scheduled (recurring or interval), or Run now on demand
  • Visibility scoping per workflow — private, business-wide, or firm-wide — plus read-only built-in system workflows
  • Dry-run test mode using live read-only tools and mocked outputs for any write operation
  • Per-workflow guardrails: max cost (USD), max duration, and an error policy (fail / pause / retry / skip)
  • Publish-and-version model with full graph version history and one-click revert
  • Run history with per-step states and background execution that survives disconnects

How it works

Build the graph (by hand or with the AI assistant), publish it, then trigger it. Each step runs in order and passes its output downstream. When the run reaches an approval or prompt step, execution pauses and saves its state; once a human responds it resumes from that exact step.

flowchart TD
  build["Build graph (canvas / AI assistant)"] --> publish["Publish (snapshots a version)"]
  publish --> trigger{"Trigger: !command / schedule / Run now"}
  trigger --> run["Run steps in order"]
  run --> gate{"Approval or prompt step?"}
  gate -->|"Yes"| suspend["Pause + save progress"]
  suspend --> resume["Human responds -> resume"]
  gate -->|"No"| done["Complete + log run"]
  resume --> done

How to use it

  1. Open Workflows and click New to launch the builder.
  2. Describe the automation to the AI assistant chat, or drag steps from the library onto the canvas and connect them.
  3. Configure each step — pick the tool and params for Tool steps, the prompt for AI steps, the expression for Conditions, the approvers for Approval gates.
  4. Link steps to pass data between them; use auto-fill to let AI infer parameter values from upstream outputs.
  5. Use Test to dry-run the graph (writes are mocked) and watch per-step results stream in.
  6. Publish the workflow — this validates the graph, assigns its !command name, and snapshots a version.
  7. Trigger it: type the !command in chat, click Run now, or open the Schedule modal to set a recurring or interval trigger.
  8. Track outcomes in run history; respond to any paused approval or prompt steps to let runs continue.

Pro tips

  • Start from a single Tool step and test often — the dry-run uses live read-only tools so you see real data without touching the books.
  • Set a realistic max cost and max duration per workflow (defaults are $0.50 and 60s); AI-heavy graphs need higher limits or they will be cut off.
  • Choose the right error policy: Pause is safest for multi-step financial workflows (it suspends instead of aborting), while Skip keeps best-effort steps from failing the whole run.
  • Use Approval steps for anything that moves money or posts entries — they create an auditable human checkpoint and the run survives restarts while it waits.
  • Set visibility to business or firm only after publishing a tested version; !command names must be unique within each scope.
  • Prefer a Script step over a long Condition/Transform chain for heavy data crunching — it includes accounting helpers like aging buckets and days-sales-outstanding calculations.

In-depth guide

Triggers, branches, and actions

Concept Where it lives Examples
Trigger !command, schedule, or Run now !month_close, every Monday at 9am, manual run
Branch Condition, Filter, Loop, Parallel Fork/Join route large items to review, iterate over invoices
Action Tool, Transform, Script, Notification, Sub-workflow create an entry, send an email, run a custom calculation, call another workflow
Human checkpoint Approval, Prompt approve a payment, collect a missing date

Step types at a glance

Step Purpose
Tool Call a registered AI tool (read or write) with parameters
Prompt Collect human input via a form, or inject a prompt
Approval Pause for an approve / reject / modify / skip decision
Condition Branch true/false on an expression
Transform AI transform of upstream data into an output variable
Loop Iterate over a collection (capped, default 50 items)
Filter Keep items from a collection matching an expression
Delay Pause for a fixed number of seconds
Notification Send an email or webhook message
Variable / Template Set a value or render a text template
Script Run a custom calculation step with accounting helpers
Sub-workflow Invoke another workflow with mapped parameters
Parallel Fork / Parallel Join Run branches concurrently, then merge
Note Canvas annotation (non-executing)
Error Handler Collect errors from upstream steps into one result for alerting or branching

Schedules and guardrails

  • Recurring schedule — pick days and times with your timezone (e.g. every Monday at 9am).
  • Interval — fixed cadence between runs (minimum 60 seconds, maximum 24 hours).
  • Each user gets at most one schedule per workflow; schedules can be private or shared business-wide.
  • Every workflow carries a max cost (default $0.50), a max duration (default 60 seconds), and an error policy: Fail (abort), Pause (suspend for inspection), Retry (re-attempt), or Skip (continue past the failure).

Versioning and testing

  • Drafts auto-save as you work; Publish runs strict validation on structure, step configs, and data links between steps.
  • Publishing snapshots a version — browse history and revert the draft to any prior version (which un-publishes it until you publish again).
  • Test runs mock all write operations, so they never mutate real data — only read-only tools execute for real.
  • An empty graph can't be tested or run — add at least one step first.