our904.com

📱 Outbound Setup — Dialer Types

A field guide to the three most common Genesys Cloud outbound dialer modes: Preview, Agentless, and Predictive. Each section explains what the mode does, when to use it, the key settings that matter, and the gotchas that trip people up. At the bottom of each dialer page is a 3-question quick-check so you can confirm the concepts stuck.

Preview

Agent-initiated · Lowest abandonment risk · No minimum agent count

What it is

In Preview mode, an agent pulls up (or is assigned) a contact record, reviews it on their screen, and then manually clicks Dial to place the call. An optional countdown timer can auto-dial the record after N seconds if the agent doesn't act. Preview is the only Genesys Cloud dialing mode where the agent sees the contact before the call is placed.

Because the agent is reserved before the number is dialed, there is effectively zero chance of call abandonment — the agent is already there waiting. This is why Preview is the go-to mode for high-value, compliance-sensitive, or manual-review campaigns.

When to use it

High-value contacts where the agent should research the record before dialing (VIP customers, enterprise sales, collections on large accounts)
Strict compliance environments where abandoned calls carry regulatory or reputational risk (healthcare, legal, TCPA-sensitive collections)
Small agent pools (under 7 agents) — automated modes don't pace well at low agent counts
Agent-owned records (Precise Dialing) where a specific agent must handle a specific contact — only possible in Preview
Any campaign where the agent needs to see call history, notes, or prior dispositions before placing the call

Key settings

Setting	Notes
Script	Required. The agent sees this script during the preview and call. Must contain any custom screen-pop fields the agent needs to review.
Queue	Required. Determines which agents are eligible to receive preview records.
Contact List	Required. The pool of records that will be assigned to agents.
Edge Group	Required. The SIP path used when the call is actually placed.
Preview Time Seconds	Optional. 0 = agent must click Dial manually. Any positive number = auto-dials after that many seconds. Common values: 10–30 seconds.
Always Running	Optional. When true, the campaign auto-refills records as agents finish them.
Agent Owned Columns	Optional. Used with Precise Dialing to route specific records only to specific agents.
Call Analysis Response Set	NOT used in Preview. There's no call analysis because the agent places the call themselves and hears the full pre-connect audio (ringing, answer, voicemail) directly.
Compliance Abandon Rate	NOT applicable. No abandonment is possible in Preview.
No-Answer Timeout	NOT applicable. Preview is the only mode where this setting doesn't exist, because the agent controls the call lifecycle.

Gotchas

Preview has the lowest agent efficiency of any dialing mode. Agents spend time reviewing records before every call. Don't use Preview for high-volume outreach where per-contact review isn't adding value — you'll burn agent hours.
Preview dialing is non-ACD. In a blended environment, an agent in Preview mode can still be assigned an inbound ACD interaction at the same time a preview record arrives, causing a collision. Plan your agent routing accordingly.
The agent hears everything. No call analysis means the agent hears ringing, the customer's "hello," and if it's voicemail, they hear the whole greeting. This is actually desired in Preview — agents can leave voicemails — but it's a shift from automated modes.
If you set Preview Time Seconds too low, agents won't have time to actually preview the record. If you set it too high (or 0), campaigns slow down to agent click speed.
Precise Dialing (agent-owned records) only works in Preview. If you need specific-agent-to-specific-contact routing, you cannot use Predictive/Power/Progressive.

Agentless

No agents · IVR / messaging · Line-based pacing

What it is

Agentless mode runs an outbound campaign without any agents involved at all. When a contact answers, the call is routed into an outbound Architect flow — essentially an IVR that plays a message, collects digits, offers opt-outs, or does whatever the flow is programmed to do. The agent pool is irrelevant because no humans are waiting on the other end.

Instead of pacing based on agent availability, Agentless mode paces based on the number of outbound lines you allocate to the campaign. If you give it 20 lines, it will place 20 calls in parallel, and as each call finishes, a new one starts. Agentless is the mode you use for automated notifications, appointment reminders, survey invitations, payment reminders, and any broadcast-style outbound.

When to use it

Appointment reminders ("Hi, this is a reminder of your appointment tomorrow at 2 PM, press 1 to confirm")
Outage / emergency notifications — broadcast a recorded message to a customer list
Payment reminders where no agent conversation is expected
Survey invitations or NPS collection via IVR
Compliance disclosures that must be delivered verbatim from a recording
Any campaign where the entire interaction is automated and no human agent needs to handle the call

Key settings

Setting	Notes
Outbound Flow	Required. An Architect outbound call flow that runs on every answered call. This is where your IVR logic lives: prompts, menus, data collection, opt-outs. If the flow doesn't exist, the campaign cannot start.
Call Analysis Response Set	Required. Must include a Transfer to Flow response action. Agentless response sets cannot include Transfer to Agent actions — if you try to assign one, the campaign will reject it.
Lines	Required. The number of simultaneous outbound calls the campaign is allowed to place. Effectively the campaign's pacing knob. Shares from the total Edge group line pool.
Contact List	Required. The records to dial.
Edge Group	Required. Provides the SIP path. Edge group's total line pool is divided across all active campaigns.
No-Answer Timeout	Applicable. 15–60 seconds, default 30. How long a ringing call stays active before auto-disconnect.
Callable Time Sets	Strongly recommended. Enforces legal-hours calling windows per time zone.
DNC Lists	Strongly recommended. Prevents the campaign from dialing opted-out numbers.
Queue	Not used. No agents are involved.
Script	Not used. No agent is there to see a script.
Compliance Abandon Rate	Not applicable. There are no agents, so there's nothing to abandon.

Gotchas

The response set MUST have Transfer to Flow, cannot have Transfer to Agent. This is the #1 reason agentless campaigns fail validation. Build a dedicated response set specifically for agentless usage; don't try to share one with your agent-based campaigns.
Agentless does not mean "no compliance." You still need callable time sets, DNC list integration, and proper opt-out handling in the IVR flow. Automated calls are still subject to TCPA and equivalent regulations.
Always include an opt-out option in the outbound flow. "Press 9 to be removed from future calls" is standard. Your flow should write that contact back to a DNC list immediately.
Lines pacing is hard pacing. If you give an agentless campaign 100 lines, it WILL try to place 100 parallel calls. Start conservative and scale up based on actual telephony capacity and customer experience.
Agentless campaigns count against your Edge group's total line pool. Running a 200-line agentless campaign can starve other campaigns on the same Edge of available lines.
Because there's no agent, you cannot gather subjective dispositions or notes. All outcomes must be driven by wrap-up codes triggered by flow logic or by what the IVR collected.

Predictive

Highest efficiency · Requires large agent pools · Stage-based pacing

What it is

Predictive mode is Genesys Cloud's most aggressive and efficient automated dialing mode. A patented stage-based pacing algorithm watches what your agents are doing in real time — how long they spend on each call, how long wrap-up takes, how often calls connect — and uses those statistics to predict the exact moment each agent will become available. It then places calls before that moment, so that by the time the customer answers, an agent is just finishing their prior call and is ready to take the new one with minimal idle time.

This is dramatically more efficient than Progressive or Power mode, because agents aren't waiting for calls to be placed — the calls are already in flight. However, it also means the dialer sometimes places calls before an agent is actually available, and if no agent opens up by the time the customer answers, that call is abandoned. Predictive mode trades a small amount of abandon rate for a large increase in agent productivity.

When to use it

Large agent pools — Genesys recommends a minimum of 15 agents for accurate predictions; 7 is the technical minimum but the statistics get noisy
High-volume outreach where agent efficiency is the primary metric (sales campaigns, mass collections, lead follow-up)
Stable call patterns — Predictive learns from historical data, so campaigns with consistent handle times and connect rates get the best results
Environments where you have tolerance for a small abandon rate (typically capped at 3–5% by regulation)
Campaigns where the cost of agent idle time is higher than the cost of occasional abandons

Key settings

Setting	Notes
Script	Required. *Must contain at least one Set Stage* action.** The stage-based pacing algorithm depends on these stage markers to measure how long agents spend in each phase of a call. No stages = no predictive pacing. This is the #1 setup mistake.
Queue	Required. The pool of agents who will receive connected calls.
Contact List	Required. The records to dial.
Call Analysis Response Set	Required. Must route live answers to an agent via Transfer to Agent. Typically also handles answering machines, busy signals, and SIT tones.
Edge Group	Required. Provides outbound lines.
Compliance Abandon Rate	Default 5.0%. Maximum percentage of calls that can be abandoned before the dialer self-throttles. Regulatory ceilings are typically 3% (UK Ofcom) or 5% (US TCPA interpretations) — set yours based on your jurisdiction.
Max Calls Per Agent	Default 15. How many parallel calls the dialer is allowed to have in flight per idle agent. Higher values = more aggressive pacing = higher productivity but higher abandon risk.
No-Answer Timeout	15–60 seconds, default 30. How long a ringing call stays active before auto-disconnect.
Priority	When multiple campaigns share an Edge group's line pool, higher-priority campaigns get first allocation.
Outbound Line Count / Weight	How many lines this campaign gets from the Edge group's total pool. Can be fixed or weight-based.

Gotchas

No Set Stage action = broken pacing. If the campaign script doesn't include at least one Set Stage action, the predictive algorithm has nothing to measure and falls back to worse-than-Progressive behavior. Verify your script.
Running Predictive with fewer than 15 agents produces wildly unstable pacing. Genesys documents 7 as the floor, but statistical noise dominates below 15. If you only have 5–10 agents, use Progressive or Power instead.
Abandon rate compliance is hard-enforced. If the rolling abandon rate approaches your configured Compliance Abandon Rate, the dialer throttles automatically. This protects you legally but also means your productivity can drop unexpectedly when abandon rate spikes. Monitor it.
Stage timing matters. If agents don't consistently hit the same stages in the same order, the algorithm's predictions degrade. Train agents to follow the script's stage flow — it's not just decorative, it's operational.
Max Calls Per Agent is a trap. Cranking it up feels like free productivity but abandons spike nonlinearly. Start at the default and tune down (not up) if you have abandon issues.
Predictive mode uses your agents' current queue state to decide who's "available," so agents on break, lunch, or in wrap-up correctly count as unavailable — but if you have routing rules that make agents appear available when they're actually not ready for calls, your abandon rate will climb. Queue config matters.
Predictive does NOT preview records. Agents see the screen pop when the call is already connecting. If your workflow requires agent prep before the call, use Preview instead.

Check	What it catches
Balanced `(` and `)`	Missing or extra parentheses — the #1 cause of "expression invalid" errors.
Balanced `{{` and `}}`	Single curly braces, missing closing braces, or mismatched variable wrappers.
Balanced quotes	Unterminated string literals.
Known function names	Flags typos and unrecognized functions. Compares against the full built-in list.
`math.` prefix	Flags math examples copied without dropping the `math.` prefix — a common mistake.
Boolean keywords	Warns when using `&&` / `\|\|` / `!` where `AND` / `OR` / `NOT` are the documented keywords.
Variable syntax	Flags bare `{Variable}` with single braces instead of `{{Variable}}`.
Empty arguments	Detects empty function arguments like `concat( , )`.

Name	Email	Role	Completed	Revealed	Total XP	Last login
Loading roster…

Variable Types

The 5 variable types in Genesys Cloud scripts

Type	Description	Supports expressions?
Dynamic String ⚡	Computed text value. Expression must return a string. Recalculates automatically when referenced variables change.	Yes — full expression body
Dynamic Number ⚡	Computed numeric value. Expression must return a number.	Yes — full expression body
Dynamic Boolean ⚡	Computed true/false. Expression must return a boolean.	Yes — full expression body
Basic Variable	String, Number, or True/False. Assigned via the Set Variable action — not computed continuously.	Partial — via Set Variable action only
List Variable	Stores multiple comma-separated values in one field. Cannot be dynamic.	No — use getIndexValue() or indexOf() inside a Dynamic var

Variable Syntax & Built-in Variables

How to reference variables in expressions

Syntax / Variable	Description
{{VarName}}	Inserts the runtime value of any script variable. Always double curly braces. Never add spaces inside the braces.
{{Scripter.Agent Name}}	Logged-in agent's display name — read-only
{{Scripter.Agent Email}}	Agent's email address
{{Scripter.Agent ID}}	Agent's unique system identifier
{{Scripter.Interaction Id}}	Unique conversation ID — identical to conversationId in the REST API
{{Scripter.Customer Formatted Number}}	Customer's formatted phone number
{{Scripter.Interaction Type}}	Channel type: call, chat, email, callback, etc.
{{Scripter.Interaction State}}	Current state: alerting, connected, disconnected
{{Scripter.Customer Call Duration}}	How long the customer has been connected (raw duration string)
{{Scripter.Raw Customer Call Start Time}}	Raw call start time as a number in milliseconds — pass directly to formatDate(), no dateToMilliseconds() wrapper needed
{{Scripter.Raw Agent Call Start Time}}	Raw agent start time as a number in milliseconds — pass directly to formatDate()
{{Scripter.Queue Name}}	Name of the queue this interaction is in
{{Scripter.Queue ID}}	ID of the queue — useful for callback actions
{{Scripter.Script ID}}	ID of the current script
{{Scripter.Is Coaching}}	true if the agent is being coached on this interaction
{{Scripter.Is Barging}}	true if a supervisor is barging in on this interaction
{{Outbound.FirstName}}	Contact list first name (outbound campaigns)
{{Outbound.LastName}}	Contact list last name (outbound campaigns)
{{Outbound.Salutation}}	Contact list salutation — e.g. Mr., Ms., Dr.

String Functions

Manipulating text values — valid in Dynamic String variables

Function	Example & Notes
concat(a,b,...)	`concat({{FirstName}}, " ", {{LastName}})` — joins unlimited arguments left to right into one string
upper(s)	`upper({{Status}})` — converts every letter to UPPERCASE
lower(s)	`lower({{Input}})` — converts every letter to lowercase
trim(s)	`trim({{CustomerInput}})` — removes leading and trailing whitespace only; middle spaces untouched
replace(s,find,rep)	`replace({{PhoneNumber}},"-","")` — replaces every occurrence; leave rep empty to delete
substring(s,start,end)	`substring({{Phone}},0,3)` — extracts by position; end position not included
slice(s,start,end)	`slice({{Phone}},-4)` — like substring but supports negative positions from the right end
substr(s,start,len)	`substr({{Account}},0,4)` — extracts by start position and character count (not end position)
indexOf(s,search)	`indexOf({{FullName}},"Smith")` — returns 0-based position; -1 if not found
length(s)	`length({{Notes}})` — returns the character count as a number

Conditional & Logic

Branching, comparisons, and boolean expressions

Function / Operator	Example & Notes
ifElse(cond,t,f)	`ifElse(equal({{Tier}},"Gold"),"VIP","Standard")` — ternary branching function
equal(a,b)	`equal({{Status}},"active")` — strict type + value check; more reliable than ==
==, !=	`{{Status}} == "active"` — value-only equality; can produce unexpected results with mixed types
<, >, <=, >=	`{{Score}} >= 90` — numeric comparison operators
? :	`{{Score}} > 80 ? "Pass" : "Fail"` — compact JavaScript-style ternary; alternative to ifElse()
AND	`equal({{IsVIP}},true) AND {{Score}} >= 90` — both conditions must be true
OR	`{{Type}} == "call" OR {{Type}} == "callback"` — at least one condition must be true
NOT	`NOT equal({{Status}},"closed")` — inverts the result of a condition

Pattern Matching (Regex)

match() and matchAll() — regular expressions in script variables

Function	Example & Notes
match(s,pattern)	`match({{ZipCode}},"^\\d{5}$")` — in a Dynamic Boolean returns true/false; in a Dynamic String returns matched text
match(s,pat,flags)	`match({{Name}},"smith","i")` — use `i` flag for case-insensitive matching
match(s,pat,flags,group)	`match({{Phone}},"^(\\d{3})", "", 1)` — capture group: 0 = whole match, 1 = first () group
matchAll(s,pat,flags,idx)	`matchAll({{Notes}},"\\d+","",1)` — finds all matches; returns the one at index 1 (second match)

Common regex validation patterns

Pattern	What it validates
^\d{5}$	Exactly 5 digits — US ZIP code
^\d{10}$	Exactly 10 digits — phone number (no dashes or spaces)
^[^@]+@[^@]+\.[^@]+$	Basic email address format
^\d+$	Numbers only — any length
^[a-zA-Z]+$	Letters only — A–Z, no numbers or symbols
^[a-zA-Z0-9]{8}$	Exactly 8 letters or digits — common for account IDs
^\d{1,4}$	Between 1 and 4 digits — short codes or agent IDs
^[A-Z]{2}\d{4}$	2 uppercase letters followed by 4 digits
^$\d{3}$ \d{3}-\d{4}$	US phone in (555) 867-5309 format

Date & Time Functions

💡 Important: Date variables come in two flavors. The Raw variants (e.g. {{Scripter.Raw Customer Call Start Time}}) are already numbers in milliseconds — pass them directly to formatDate(), formatDateISO(), and formatLocaleDate() with no wrapper. The non-Raw variants (e.g. {{Scripter.Customer Call Start Time}}) are locale-formatted strings — those need dateToMilliseconds() wrapped around them first. Don't mix the two — wrapping a Raw variant in dateToMilliseconds() will fail because that function expects a string, not a number.

Formatting dates and working with timestamps

Function	Example & Notes
formatDate(ms)	`formatDate({{Scripter.Raw Customer Call Start Time}})` — readable string in agent's timezone. Default output: `01/01/2000 12:00:00 am (+00:00)`. Pass the Raw variant directly, no wrapper.
formatDate(ms, fmt)	`formatDate({{Scripter.Raw Customer Call Start Time}}, "MM/dd/yyyy")` — custom format tokens: `MM` `dd` `yyyy` `HH` `mm` `ss` `eeee` `MMMM`
formatDateISO(ms)	`formatDateISO({{Scripter.Raw Customer Call Start Time}})` — ISO 8601 output e.g. `1999-12-31T19:00:00-05:00`; ideal for APIs
formatLocaleDate(ms)	`formatLocaleDate({{Scripter.Raw Customer Call Start Time}})` — uses each agent's own system locale (US vs UK vs EU formats automatically)
dateToMilliseconds(s)	Converts a string date variable to ms. Use with the non-Raw variants — e.g. `dateToMilliseconds({{Scripter.Customer Call Start Time}})`. Don't use this with Raw variants — they're already numbers.
Add 5 minutes (Raw)	`formatDate({{Scripter.Raw Customer Call Start Time}} + 5 * 60 * 1000)` — Raw is a number, so you can do arithmetic on it directly
Compare two Raw dates	`{{Scripter.Raw Customer Call Start Time}} > {{Scripter.Raw Agent Call Start Time}}` — compare numerically, no conversion needed

Duration functions

Function	Example & Notes
formatDuration(ms)	`formatDuration(durationToMilliseconds({{Scripter.Customer Call Duration}}))` — readable e.g. `00:04:32`
durationToMilliseconds(d)	Converts a raw duration string into milliseconds. Use for comparisons or arithmetic.
Countdown timer	`formatDuration(5601000 - durationToMilliseconds({{Scripter.Customer Call Duration}}))` — time remaining until 5-minute mark
Duration > threshold?	`durationToMilliseconds({{Scripter.Customer Call Duration}}) > 300000` — true if call exceeds 5 minutes

Math & Arithmetic

💡 Numeric functions: Functions like round(), floor(), ceil(), abs(), min(), max(), sqrt(), pow(), and mod() are called directly in Genesys Cloud expressions — no prefix needed.

Operators and numeric functions

Operator / Function	Example & Notes
+, -, *, /	`{{CallCount}} + {{TransferCount}}` — standard arithmetic operators
% (modulo)	`{{Total}} % 2` — remainder after division; 0 = even, 1 = odd
^ (power)	`{{Base}} ^ 2` — raises to a power; e.g. 2^3 = 8
round(n,places)	`round({{Score}}, 2)` — rounds to specified decimal places; 0 = whole number
abs(n)	`abs({{ScoreDelta}})` — absolute value; removes the negative sign
min(a,b)	`min({{WaitTime}}, 300000)` — returns the smaller of the two values
max(a,b)	`max({{WaitTime}}, 0)` — returns the larger of the two values
floor(n)	`floor({{Score}})` — rounds down to nearest whole number
ceil(n)	`ceil({{Score}})` — rounds up to nearest whole number
length(s)	`length({{AccountNumber}})` — number of characters in a string (result is a number)
indexOf(s,v)	`indexOf({{FullName}},"Smith")` — 0-based position; -1 if not found (result is a number)

List Variable Operations

Working with List variables

Operation	Example & Notes
getIndexValue(list,idx)	`getIndexValue({{OptionsList}}, 0)` — retrieves item at position; 0 = first item. Error if index out of range. Use in a Dynamic String.
indexOf(list,value)	`indexOf({{OptionsList}}, "Gold")` — finds position of a value; returns -1 if not found. Use in a Dynamic Number.
Push (Set Variable)	No expression syntax — use the Set Variable action in the script editor, choose Push to append a value to the end of the list.

Ready-to-Use Expression Patterns

Full customer name

concat({{Outbound.Salutation}}, " ", {{Outbound.FirstName}}, " ", {{Outbound.LastName}})

Produces: Mr. John Smith — from outbound contact list columns. Dynamic String.

Agent greeting

concat("Hello, ", {{Scripter.Agent Name}}, "!")

Personalized greeting displaying the logged-in agent's name. Dynamic String.

Full call summary

concat("Call: ", {{Scripter.Interaction Id}}, " | Agent: ", {{Scripter.Agent Name}}, " | Type: ", {{Scripter.Interaction Type}}, " | Duration: ", formatDuration(durationToMilliseconds({{Scripter.Customer Call Duration}})))

Complete call log string using 4 built-in Scripter variables. Dynamic String.

Score tier — nested ifElse

ifElse({{Score}}>=90,"Gold",ifElse({{Score}}>=70,"Silver","Bronze"))

Three-tier result from a numeric score. Dynamic String.

VIP + score combined

ifElse(equal({{IsVIP}},true) AND {{Score}}>=90,"Gold VIP","Standard")

Combines a boolean check and numeric comparison using AND. Dynamic String.

Validate US zip code

match({{ZipCode}},"^\d{5}$")

Returns true if ZipCode is exactly 5 digits. Dynamic Boolean.

Validate email address

match({{Email}},"^[^@]+@[^@]+\.[^@]+$")

Returns true if the value contains @ and a domain. Dynamic Boolean.

Remove all dashes from phone

replace({{PhoneNumber}},"-","")

Strips every dash from a phone number. Leave the 3rd arg empty to delete. Dynamic String.

Extract area code

match({{PhoneNumber}},"^(\d{3})", "", 1)

Extracts first 3 digits using a capture group. Dynamic String.

Trim + uppercase

upper(trim({{AccountNumber}}))

Removes edge spaces then converts to uppercase. Functions nest — innermost runs first. Dynamic String.

Format call start time

formatDate({{Scripter.Raw Customer Call Start Time}})

Readable call start time. The Raw variant is already in milliseconds — pass it directly. Dynamic String.

ISO date for API

formatDateISO({{Scripter.Raw Customer Call Start Time}})

ISO 8601 format — 1999-12-31T19:00:00-05:00 — for REST API calls. Dynamic String.

5-minute countdown

formatDuration(5*60*1000 - durationToMilliseconds({{Scripter.Customer Call Duration}}))

Readable time remaining until the call has been active 5 minutes. Dynamic String.

Call duration in milliseconds

durationToMilliseconds({{Scripter.Customer Call Duration}})

Raw number of milliseconds elapsed — use for comparisons or arithmetic. Dynamic Number.

Round score to 2 decimals

round({{RawScore}}, 2)

Rounds a numeric variable to 2 decimal places. Dynamic Number.

Call exceeds 5 minutes?

durationToMilliseconds({{Scripter.Customer Call Duration}}) > 300000

Returns true when customer has been on call more than 5 minutes. Dynamic Boolean.

Check account number length

equal(length({{AccountNumber}}), 8)

Returns true if the account number is exactly 8 characters long. Dynamic Boolean.

Get first item from List

getIndexValue({{OptionsList}}, 0)

Retrieves the first item from a List variable. Use in a Dynamic String.

Add minutes to call start

formatDate({{Scripter.Raw Customer Call Start Time}} + 5 * 60 * 1000)

Adds 5 minutes to the call start time and formats it as a readable date. Raw is a number, so arithmetic works directly. Dynamic String.

Interaction type check

equal({{Scripter.Interaction Type}}, "call")

Returns true if the interaction is a voice call. Dynamic Boolean.

Operator Precedence & Tips

How Genesys Cloud evaluates expressions

Rule	Detail
Parentheses first	Use parentheses to control evaluation order. e.g. `({{A}} + {{B}}) * {{C}}`
Last value assigned	In multi-line expressions, the value of the last evaluated line is assigned to the dynamic variable.
Type must match	Dynamic String → must return text. Dynamic Number → must return a number. Dynamic Boolean → must return true/false. Mismatches cause runtime errors.
equal() vs ==	`equal()` checks both value AND type. `==` checks value only and can give unexpected results with mixed types. Use equal() for reliable comparisons.
Numeric functions	Functions like `round()`, `floor()`, `ceil()`, `abs()`, `min()`, `max()`, `sqrt()`, `pow()`, and `mod()` are called directly with no prefix.
Raw date variables	`Scripter.Raw ...` date variants are already numbers in milliseconds — pass them directly to `formatDate()`. The non-Raw variants are locale-formatted strings and need `dateToMilliseconds()` first. Don't mix the two.
Semicolons or newlines	Multiple expressions can be separated by semicolons or newlines. The last one evaluated is what gets assigned to the variable.
Nested functions	Functions can be chained by nesting — `upper(trim({{Var}}))`. The innermost function always runs first and passes its result to the outer function.
Input/Output limits	Dynamic variables cannot be used as Input or Output variables. Use Basic variables for variables that need to be passed in from Architect or written to the conversation object.