Steps

Overview

Steps run in order, following the lines down the pipeline from the trigger. Each step reads from and writes to a shared context object that carries data through the pipeline.

The Pipeline Canvas

Opening an automation shows its pipeline as a flow diagram you can zoom and pan: the trigger card at the top, then one card per step, joined by lines. A condition splits into two side-by-side branches labelled Then and Otherwise.

Add a step — click the Add step placeholder at the end of the pipeline or of any branch, or the + on a connecting line (Insert step here) to put a step between two others. Then choose the step type.
Configure a step — click its card to open its settings. The hint in the top-left corner reads “Click a step to configure it. Drag it onto a + to move it.”
Move a step — drag its card onto a highlighted + or Add step and drop it there.
Duplicate or delete — each card has Duplicate step and Delete step buttons. You can also select a card and press Delete or Backspace. Deleting a condition asks you to confirm and says how many steps inside its branches go with it. “The change is kept once you save.”
Minimap — once a pipeline has more than five steps, a minimap appears in the bottom-right corner for getting around.

A card that isn’t fully set up shows a warning icon, and Save is blocked until it’s fixed. The message names the problem, for example:

“Select a script in the Create Call step before saving.”
“Add at least one recipient to the email destination.”
“Add a subject to the email destination.”
“Complete the condition step before saving.”

Step Types

Transform

Reshape and map data from one format to another. Transforms are typically used to:

Map incoming webhook fields to contact fields before an Upsert Contact step
Map call results to CRM column identifiers before a Destination step

Configuration: Add one or more field mappings. Each mapping has:

Field	Description
Source	The field to read from (e.g., `trigger.phone`, `call.call_summary`)
Target	The field to write to (e.g., `contact.phone_number`, `long_text_7`)
Transform	Optional transformation: `uppercase`, `lowercase`, `truncate:100`, `date:YYYY-MM-DD`, `to_string`, `to_number`

Example — mapping webhook fields for a contact:

Source	Target
`trigger.phone`	`contact.phone_number`
`trigger.first_name`	`contact.first_name`
`trigger.last_name`	`contact.last_name`

Transform results are written to mapped.* in the context and are available to all subsequent steps.

Code

Reshape data with a small piece of Python when field mappings are not enough — splitting a name, building a list, tidying a date, or deciding what to write based on several fields at once. Choose Code from the transform dropdown. The Code step is only available to team members with the manage settings permission. Configuration:

Field	Description
Code	Your Python. It starts pre-filled with a `def run(): ... return True` skeleton
Timeout (ms)	How long the code may run. Default 2000, maximum 30000

Your code goes inside one top-level def run():. Return True to carry on, False to stop the branch. Reading and writing the context:

Function	What it does
`get_context(path, default)`	Read any value in the pipeline context, e.g. `call.duration`
`get_mapped(key, default)` / `set_mapped(key, value)`	Read and write `mapped.*`, the same place a Transform writes to
`get_variable(ref, default)` / `set_variable(ref, value)`	Read and write a variable
`scope()`	The current execution’s scope
`now()` / `today()` / `now_iso()`	The run’s date and time. `now_iso()` gives it as an ISO-8601 string
`epoch_iso(value)`	Turn a Unix timestamp into an ISO-8601 UTC string. Returns nothing when the value cannot be read
`{{call.transcript}}`	Placeholders work in code, the same as elsewhere in the pipeline

Doing work:

Function	What it does
`upsert_contact(...)`	Create or update a contact
`upsert_object(type_name, fields, contact_id, match_on, merge)`	Create or update a custom variable record. See below
`upsert_list(...)` / `route_to_list(...)` / `remove_from_list(...)`	Manage list membership
`observe_batch(...)` / `prioritise_batch(...)`	Read a batch’s progress, or push a contact up its queue
`list_batches(statuses)`	List your team’s batches — id, name, status, scheduler status and created date, oldest first. Pass a list of statuses to narrow it down. Read-only
`set_call_result(data)`	Write your own verdict back onto the call. See below
`requeue_callback(...)`	Book a callback for the contact
`integration_request(integration_id, endpoint, body, method)`	Read from a connected integration. See below
`enqueue_automation(automation_id, payload)`	Hand a job to another automation. See below

set_call_result(data) — pass a dictionary of your own fields and they are stored on the call, in a field of their own, separate from the AI’s summary and structured data. Use it when the automation, not the model, is the authority on how a call turned out. The values are returned with the call by the API, so reporting can read them directly instead of picking apart a summary. The step must be running on a call — that is, the automation’s trigger is Call Completed or Call Scheduled. Fields are merged in, so a second call adds to what is there rather than replacing everything.

def run():
    duration = get_context("call.duration", 0)
    set_call_result({"qualified": duration > 120, "reviewed_by": "automation"})
    return True

integration_request(...) — read data from a connected integration using the credentials and address already stored against it. You give it a path, not a full web address; an absolute URL is refused, so the stored credentials can never be pointed at another site. It is read-only and paginated, so large collections come back a page at a time. An error from the far end comes back as data rather than stopping the step, which lets a loop set one record aside and keep going. enqueue_automation(automation_id, payload) — start another automation and hand it a payload, which arrives there as trigger.*. Use it to give each record its own run, so one bad record fails and retries on its own instead of taking the whole batch down with it. You cannot enqueue the automation that is running, an automation in another team, or a disabled one. Writing the code:

One top-level def run():. No nested definitions, no classes, no decorators, no lambdas.
No imports.
Indent with spaces, not tabs. The editor converts pasted tabs for you and the Tab key inserts four spaces.
Errors show as you type, each with its line number — for example Line 12 — Tabs are not allowed, indent with spaces.
There is no attribute access in the sandbox, so build lists by joining them together rather than with .append.

Limits:

Limit	Value
Timeout	2 seconds by default, 30 seconds maximum
Code length	50,000 characters
Data passed to or returned by any one function above	2 MB
Function calls per run	2,000
Calls that change data, per run	500

Going over the 2 MB limit fails that one function call, not the whole run — so page through large reads rather than asking for everything at once. Going over the call or change limits stops the run.

LLM

Ask an AI model to read some data and give you a structured answer — classifying a call, tidying free text, or pulling a few fields out of a long note. Choose LLM from the transform dropdown. Configuration:

Field	Description
Reasoning	How much thinking the model does: Low, Medium or High
System Prompt	The instruction, for example “Classify the following data…”
Output Schema	The fields you want back. Each one has a name, a description of what it means, and optionally a list of allowed options
Response Map	Where each answer is written, as Variable path and Extracted path pairs

Placeholders in the prompt are filled in from the run’s live context before the model sees it — call.*, contact.* and trigger.* all work — so the prompt can quote the actual transcript, the contact’s details, or the incoming webhook payload rather than being written in the abstract. Each field in the Output Schema needs a description. It is what tells the model what you actually want, so write it as though you were explaining the field to a new team member.

Upsert Contact

Create a new contact in Voxworks or update an existing one. The step matches on either phone number or email to determine whether to create or update. Configuration:

Field	Description
Match on	How to find existing contacts: `phone_number` or `email`
Field mappings	Map context fields to contact fields (phone_number, first_name, last_name, email, address, location)

After this step runs, contact.* is available in the context for all subsequent steps. Example: Match on phone_number, with mappings:

Source	Target
`trigger.phone`	`phone_number`
`trigger.first_name`	`first_name`
`trigger.last_name`	`last_name`

If a contact with that phone number already exists, their name fields are updated. If not, a new contact is created.

Upsert Object

Create or update a typed data object and optionally link it to the contact. Objects store CRM identifiers and external data that your automation needs to reference later — for example, a Monday.com item ID or a HubSpot deal ID. Configuration:

Field	Description
Object type	The type of object to create (e.g., `monday_item`, `hubspot_deal`)
Match on	The field within the object data to match against (e.g., `CRM_ID`)
Match value	The source path for the match value (e.g., `trigger.crm_id`)
Link to contact	Whether to link this object to the current contact in context
Field mappings	Map context fields to object data fields

After this step runs, the object’s data is available at objects.{type_name}.*. Merge or replace. By default the fields you supply are merged into the record, leaving anything you did not mention untouched. From a Code step you can ask for replace instead, which writes exactly the fields you supply and drops the rest — use it when the incoming data is the whole truth about that record. The name field updates the record’s display name. Example: Object type: monday_item, match on CRM_ID = trigger.crm_id, link to contact: yes.

Source	Target
`trigger.crm_id`	`CRM_ID`
`trigger.board_id`	`board_id`
`trigger.source`	`source`

Create Call

Trigger an outbound call using a specific Script. This step creates a call record and schedules it for immediate execution (or at a specified time). Configuration:

Field	Description
Script	The Script to use for the call
Phone field	Context path to the phone number (e.g., `contact.phone_number`)
From number	The outbound phone number to call from (optional, uses default if not set)

Important: Pipeline split. Any steps placed after Create Call become post-call steps. They do not execute until the call finishes and the AI has generated the summary and structured data. On the canvas, the line into the Create Call step is labelled Call started and the line out of it Call completed. After the call completes, call.* is populated with the full call record including summary, transcript, structured data, and objectives.

Destination

Push data to an external system. There are four destination types:

Integration Sync

Sync data to a connected CRM (e.g., Monday.com). Uses field mappings to map call outputs and object data to integration-specific column identifiers.

Source	Target
`call.call_summary`	`long_text_7`
`call.status`	`status_1`
`call.duration`	`numbers_3`
`objects.monday_item.CRM_ID`	`item_id`
`objects.monday_item.board_id`	`board_id`

The target field names correspond to column IDs in your CRM. You’ll find these in your CRM’s column settings.

Email

Send an email to the contact, your team members, or a specific address. Email subjects and bodies support {{variable}} interpolation.

Field	Description
Email template	Which design to send. Choose a team template, a Voxworks system template, or One-off custom email to write the subject and body in this step. See below.
To	`contact` (uses contact.email), `team` (sends to selected members), or a specific email address
Subject	Email subject with variable support (e.g., `Your call summary - {{contact.full_name}}`)
Body	HTML email body with variable support (e.g., `Hi {{contact.first_name}}, here is your call summary: {{call.call_summary}}`)
From name	Display name for the sender (defaults to your team name)
Reply to	Reply-to address (defaults to team owner email)

Email template. The list has three groups:

Voxworks system templates — each shown as “<name> — Add to team”. Picking one adds the latest version to your team as an editable copy and uses that copy.
Team templates — your team’s own designs; the team default is marked — Default.
One-off custom email — write the subject and body for this step only.

As the hint under the field says: “Selecting a system template adds the latest version to your team as an editable copy. Manage team templates in Settings → Email templates.” Only Post-call templates are offered here. Choosing a template fills the step’s subject and body from it. See Email Templates. Placeholders in the subject and body are filled from the call, the contact and your team, so a post-call email can carry the summary, the collected fields and the contact’s details without any extra mapping. Values that run to several lines keep their line breaks in the branded HTML email, and any characters that would otherwise break the layout are handled for you. Dates and times are shown in your account’s timezone rather than UTC. A placeholder that has no value comes out as an empty string.

SMS

Send a text message to the contact or to team members.

Field	Description
SMS type	`contact` (sends to the contact) or `team` (sends to selected team members)
To	Phone field path for contact SMS (e.g., `contact.phone_number`)
Template	Message text with `{{variable}}` interpolation
Members	For team SMS, which team members to notify

Webhook

Send an HTTP request to any URL. Useful for integrating with systems that don’t have a native integration.

Field	Description
URL	The destination URL (must be HTTPS)
Method	`POST` or `PUT`
Headers	Custom HTTP headers (optional)
Body template	JSON body with `{{variable}}` interpolation

Condition

Branch the pipeline based on a field value. If the condition is true, the steps in the Then branch run. If false, the steps in the optional Otherwise branch run (or nothing happens). Configuration:

Field	Description
Field	Context path to evaluate (e.g., `call.status`, `call.end_reason`, `call.structured_data.fields.rating.value`)
Operator	`eq`, `neq`, `gt`, `lt`, `gte`, `lte`, `in`, `exists`
Value	The value to compare against

Example — notify team on low rating:

Field: call.structured_data.fields.rating.value
Operator: lt
Value: 3
Then: SMS to team — “Low rating call: {{contact.full_name}}”
Otherwise: (skip)

A branch can hold another Condition, so conditions can be nested. See Conditions.

Source

Fetch data from an external API or connected integration. The response is written to source.* in the context. Configuration (HTTP):

Field	Description
URL	The API endpoint (supports `{{variable}}` interpolation)
Method	`GET` or `POST`
Headers	Custom HTTP headers (optional)
Body template	Request body for POST requests (optional)

Configuration (Integration Fetch):

Field	Description
Integration	The connected integration to fetch from

The fetched data is resolved at runtime using object identifiers from the context (e.g., the contact’s linked CRM item ID).

Limits

Limit	Value
Max field mappings per transform	50
Max execution time per step	30 seconds
Max total execution time	5 minutes

Get Started & Build

Calls, Contacts & Batches

Numbers & Routing

Tools, Automations & Integrations

Account, Billing & Security

Overview

The Pipeline Canvas

Step Types

Transform

Code

LLM

Upsert Contact

Upsert Object

Create Call

Destination

Integration Sync

Email

SMS

Webhook

Condition

Source

Limits

​Overview

​The Pipeline Canvas

​Step Types

​Transform

​Code

​LLM

​Upsert Contact

​Upsert Object

​Create Call

​Destination

​Integration Sync

​Email

​SMS

​Webhook

​Condition

​Source

​Limits

Overview

The Pipeline Canvas

Step Types

Transform

Code

LLM

Upsert Contact

Upsert Object

Create Call

Destination

Integration Sync

Email

SMS

Webhook

Condition

Source

Limits