Get Started

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. A workflow is a DAG of typed nodes (tool calls, AI prompts, conditions, loops, approval gates, sandboxed Python, and more) that passes data node-to-node. Run it instantly, invoke it as a !command, or put it on a schedule. Human-in-the-loop nodes suspend the run until someone responds, so approvals and manual input are first-class.

Key capabilities

  • Visual builder canvas plus an AI assistant that generates and refines the graph from natural language (generated live)
  • 17 node types including Tool, AI Prompt, Condition, Transform, Loop, Filter, Delay, Notification, Script, Sub-workflow, Parallel Fork/Join, and Error Handler
  • Tool nodes wired to any registered AI tool, with {{ref}} data-passing from upstream node outputs and workflow params
  • Approval gate and Prompt nodes that suspend the run for human approval or input, then resume from where they left off
  • Sandboxed Python Script nodes (pandas, numpy, openpyxl, reportlab) with AI code generation and an automatic security scan
  • Three trigger modes: manual !command, scheduled (cron / interval / event), 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 AI-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-node states and durable execution that survives restarts
  • Static graph validation and AI auto-fill of node parameters from upstream context

How it works

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

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

How to use it

  1. Open Workflows (the /workflows panel) and click New to launch the builder.
  2. Describe the automation to the AI assistant chat, or drag nodes from the library onto the canvas and connect them.
  3. Configure each node — pick the tool and params for Tool nodes, the prompt for AI nodes, the expression for Conditions, the approvers for Approval gates.
  4. Wire data between nodes using {{ref}} references; use auto-fill to let AI infer param values from upstream outputs.
  5. Use Test to dry-run the graph (writes are mocked) and watch per-node 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 cron, interval, or event trigger.
  8. Track outcomes in run history; respond to any suspended approval/prompt nodes to let runs continue.

Pro tips

  • Start from a single Tool node 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 nodes 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 node over a long Condition/Transform chain for heavy data crunching — it ships with pandas and accounting helpers like aging_buckets() and calc_dso().

In-depth guide

Trigger / condition / action model

A workflow combines triggers (how it starts), control-flow nodes (how it branches), and action nodes (what it does).

Concept Where it lives Examples
Trigger !command, schedule, or Run now !month_close, cron 0 9 * * MON, manual run
Natural-language triggers trigger phrases on the workflow phrases that let the assistant suggest the workflow
Condition / branch Condition, Filter, Loop, Parallel Fork/Join nodes route large items to review, iterate over invoices
Action Tool, Transform, Script, Notification, Sub-workflow create an entry, send an email, run Python, call another workflow
Human-in-the-loop Approval, Prompt nodes approve a payment, collect a missing date

Node types

Node Purpose
Tool Call a registered AI tool (read or write) with params
Prompt Collect human input via a form, or inject a prompt
Approval Suspend 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 sandboxed Python (pandas, numpy, openpyxl, reportlab)
Sub-workflow Invoke another workflow with mapped params
Parallel Fork / Parallel Join Run branches concurrently, then merge
Note Canvas annotation (non-executing)
Error Handler Catch failures and alert / branch

The workflow builder

The builder pairs a React Flow canvas with an AI assistant chat:

  • AI assistant — shows live progress updates and returns a complete graph you can keep editing; it can also generate a name, !command name, and description from the graph.
  • Auto-save vs. publish — drafts auto-save as you work (lenient validation), while Publish runs strict validation on the graph structure, node configs, tool references, and {{ref}} wiring.
  • Node-context panel — shows exactly which upstream outputs, workflow params, and loop variables are available at any node.
  • Auto-fill — uses AI to suggest param values from that context.

Durable & suspendable execution

  • Durable runs — a run keeps going and finishes cleanly even if your connection drops, so a disconnect never strands a run.
  • Scheduled runs — DayZero checks every minute for schedules that are due and runs them automatically, recording each run and updating the schedule's last and next run times.
  • Human-in-the-loop — approval and prompt nodes suspend the run and save its progress; the run resumes from the suspended node when someone responds. This is how the AP Approval workflow waits on each gate.

Execution statuses

Status Meaning
Running Actively executing nodes
Suspended Paused at an approval/prompt node awaiting human input
Completed Finished successfully
Failed A node failed under a fail policy, or the run errored
Cancelled Stopped by a user or client disconnect

Schedules

Type Config Notes
Cron cron expression + timezone e.g. 0 9 * * MON for Monday 9am
Interval interval in seconds (60–86,400) fixed cadence between runs
Event event type run when a system event fires

Each user gets at most one schedule per workflow; a schedule can be private (creator only) or shared business-wide, and tracks its run count, last status, and last error.

Guardrails & error policy

Every workflow carries a max cost (default $0.50), a max duration (default 60 seconds), and an error policy. The policy decides what happens when a step fails:

  • Fail — aborts the run.
  • Pause — suspends it for inspection.
  • Retry — re-attempts the step.
  • Skip — continues past it.

Tool nodes additionally support a per-node error action and a retry count.

Visibility, versioning & system workflows

  • Scoping — workflows are private, business, or firm, and the !command name is unique per scope (checked before publish).
  • Versioning — publishing snapshots a version, so you can browse history and revert the draft to any prior version (which un-publishes it).
  • System workflows — superusers can promote a published workflow to a read-only system workflow visible to everyone.
  • Access — Workflows requires the AI Pro add-on.
  • Privacy — deleted drafts are recoverable, and run history is scoped per user so teammates can't read each other's run inputs or outputs.

Edge cases

  • An empty graph can't be tested or run — add at least one node first.
  • Reverting to a version overwrites the current draft graph and marks the workflow unpublished until you publish again.
  • Test runs mock all write operations with AI-generated outputs, so they never mutate real data — only read-only tools execute for real.
  • Generated Script code is scanned for unsafe operations; flagged code is surfaced rather than silently run.

Start free and automate the multi-step work you repeat every week.