Workflow Nodes
Prompt Node
The prompt node gives you access to any prompt that has been made available to you - either prompts you've created yourself or ones shared within your organization. This is one of Aisle's most powerful features, allowing you to build prompts as reusable "Lego blocks" that can be shared across multiple workflows.
When you add a prompt node, you'll select from your available prompts and connect it into your workflow, making complex AI operations modular and maintainable.
Condition Node
Condition nodes create branches in your workflow with true/false paths based on whether your specified condition is met. You set conditions by evaluating a variable against either a static value or a reference to another variable.
Full Operator Reference
The Condition node supports the following operators by data type:
| Type | Operator | Description |
|---|---|---|
| String | Equals | Exact match |
| String | Does not equal | Not an exact match |
| String | Contains | String includes the value |
| String | Does not contain | String does not include the value |
| String | Is null | Value is null |
| String | Is not null | Value is not null |
| Number | Equals | Exact numeric match |
| Number | Does not equal | |
| Number | Greater than | |
| Number | Less than | |
| Boolean | Equals | true or false match |
| Array | Includes value | Array contains the specified item |
| Array | Does not include value | Array does not contain the specified item |
| Array | Is empty | Array has no items |
| Array | Is not empty | Array has at least one item |
Additional options — shown depending on the operator:
- Check empty — when using Is null or Is not null (string or array), this option also treats empty strings or empty arrays as matching (so null and empty both match for "Is null"; both fail for "Is not null").
- Check null — when using Is empty (array), this option also treats null arrays as matching (so both empty and null arrays match).
Switch Node
The Switch node routes workflow execution to one of several branches based on the value of a variable. Where the Condition node handles true/false logic, Switch handles multi-path routing — useful when a variable can take several distinct values and each one requires different handling.
Example: A workflow receives a support ticket. A Switch node reads the category variable and routes to separate branches for billing, technical, and general — each with its own prompt and response handling.
Configuration
Source variable — the variable whose value determines which branch executes.
Cases — a list of value/output pairs. Each case specifies a string value to match and an output handle to route to when that value is found. If no case matches, execution continues on the default output handle.
Case sensitive — when enabled, matching is case-sensitive (e.g. Hello and hello are different values). When disabled, values are compared ignoring case.
Return Node
The Return node ends the current branch of execution and passes a value back to the caller. Use it inside loops or conditional branches to exit early and return a specific value without continuing through the remaining nodes.
Configuration
Return variable — the value to return. Can be a static value or a reference to a variable in the workflow context.
Return param type — the data type of the returned value.
Transforms — optional pipeline to apply to the value before returning.
For Loop Node
The For Loop node repeats a set of connected nodes a fixed number of times. Use it when you know the iteration count upfront — processing a fixed number of retries, generating N variations of a prompt output, or paginating through a known number of results.
The For Loop differs from the Collection Loop in one key way: it iterates by count, not by items. If you have an array to process, use Collection Loop. If you need to repeat something a specific number of times regardless of data, use For Loop.
Configuration
Iterations — how many times to run the loop body. Can be a static number or a reference to a variable.
Count variable name — the name of the variable that tracks the current iteration number, available inside the loop body (zero-indexed).
Output modes
None — the loop runs but produces no collected output.
Map — returns an array of the last output value from each iteration.
Flat Map — flattens nested arrays from iterations into a single array.
Reduce — combines iteration results into a single accumulated value. Requires an accumulator variable name and an initial value.
Execution options
Sequential — iterations run one at a time in order.
Parallel — iterations run simultaneously. Configure maxConcurrency to cap how many run at once, timeoutPerIteration to set a per-iteration limit (in seconds), and continueOnError to keep running if an iteration fails. When Continue Other Iterations is enabled, you can set Error Result Format: Simple (failed iterations yield null in the collected result) or Structured (failed iterations include error details in the result).
Collection Loop Node
The Collection Loop node iterates over an array, running the connected nodes once for each item. Use it when you have a list — search results, tickets, records, file pages — and need to process each item individually.
If you need to iterate by count instead, use For Loop.
Configuration
Collection — a variable containing the array to iterate over.
Item variable name — the name given to each item as it's processed inside the loop body.
Output modes
None — processes each item but produces no collected output.
Map — returns an array of the last output value from each iteration.
Flat Map — flattens nested arrays from iterations into a single array.
Reduce — combines results into a single accumulated value across all iterations.
Execution options
Same sequential/parallel options as the For Loop node, including Error Result Format (Simple vs Structured) when continuing on error in parallel mode. Parallel execution is useful when loop iterations are independent and you want to reduce total runtime.
Memory Node
Read more on the Memories Page for how to use memories in workflows.
Variable Node
Variable nodes provide powerful data transformation capabilities across different data types. With 40+ operations available, you can manipulate strings, perform calculations, transform arrays and objects, and work with dates - all without writing custom code. All operations create new output variables without modifying the original data.
Basic Operations
| Action | Description |
|---|---|
| Set/Update Variable | Create new variables or update existing ones with static values or references to other variables. The foundation of data flow in workflows. |
| Pluck Value | Extract specific keys from JSON objects using dot notation for nested properties (e.g., "user.profile.name"). Returns the value at that path or empty if not found. |
String Operations
String operations help you manipulate and analyze text throughout your workflow.
| Action | Description |
|---|---|
| Concatenate | Merge multiple strings together with an optional separator. Add as many strings as needed - useful for building full names, addresses, or formatted messages. |
| Split String | Break strings into arrays based on delimiters (commas, spaces, etc.). Essential for parsing CSV data or splitting comma-separated lists. |
| Join Array | Combine array elements into a single string using a specified delimiter. The inverse of Split String. |
| Uppercase | Convert all characters to uppercase. Useful for standardizing text before comparisons or creating attention-grabbing headers. |
| Lowercase | Convert all characters to lowercase. Commonly used for normalizing email addresses or usernames. |
| Trim | Remove whitespace from both ends of a string. Cleans up user input that might have extra spaces. |
| Replace Text | Find and replace all occurrences of text within a string. Includes a case-sensitive option for precise control - perfect for template substitution or data cleanup. |
| String Contains | Check if a string contains a specific substring. Returns true/false with optional case-sensitive matching. Use this to filter or route data based on content. |
| String Starts With | Check if a string begins with a specific prefix. Returns true/false with optional case sensitivity. Helpful for categorizing items by naming conventions. |
| String Ends With | Check if a string ends with a specific suffix. Returns true/false with optional case sensitivity. Useful for file extension checks or URL validation. |
| String Is Empty | Check if a string is empty or contains only whitespace. Returns true/false - valuable for validating required fields. |
Math Operations
Perform calculations and numeric analysis without custom code.
| Action | Description |
|---|---|
| Add Numbers | Add two or more numbers together. Supports both static values and variable references - perfect for calculating totals or combining quantities. |
| Subtract Numbers | Subtract the second number from the first. Useful for calculating differences, remaining balances, or time deltas. |
| Multiply Numbers | Multiply two or more numbers together. Essential for price calculations, scaling values, or computing areas. |
| Divide Numbers | Divide the first number by the second. Returns null if dividing by zero to prevent errors. Use for averages, percentages, or rate calculations. |
| Sum Array | Calculate the sum of all numbers in an array. Non-numeric values are treated as zero. Great for totaling order items or aggregating scores. |
| Average Array | Calculate the average of all numbers in an array. Returns zero for empty arrays. Useful for finding mean values across datasets. |
Array Operations
Transform, analyze, and manipulate arrays of data.
| Action | Description |
|---|---|
| Add to Array | Append items to existing arrays. Creates a new array if the target doesn't exist - perfect for building lists dynamically. |
| Slice Array | Extract a portion of an array using start and end indices. Supports negative indices (e.g., -1 for last element). End index is optional - omit it to slice to the end. |
| Chunk Array | Split an array into smaller arrays of a specified size. Essential for batch processing or pagination (e.g., [1,2,3,4,5] with size 2 becomes [[1,2], [3,4], [5]]). |
| Array Length | Get the number of items in an array. Returns a count you can use in conditions or calculations. |
| Array Includes | Check if an array contains a specific value. Returns true/false - useful for membership tests or filtering logic. |
| Array Unique | Remove duplicate items from an array. For arrays of objects, specify a key to determine uniqueness (e.g., "id"). For primitive arrays, leave the key empty. |
| Array Flatten | Flatten nested arrays by one level. Example: [[1, 2], [3, 4]] becomes [1, 2, 3, 4]. Useful after operations that create nested structures. |
| Array Sort | Sort an array in ascending or descending order. For object arrays, specify the sort key (e.g., "created_at"). Choose sort type: string, number, or date. For primitive arrays, leave sort key empty. |
Object Operations
Manipulate and analyze structured JSON data.
| Action | Description |
|---|---|
| Set Object Key | Update or create keys in JSON objects using dot notation for nested properties (e.g., "user.profile.email"). Intermediate objects are created automatically if they don't exist. |
| Object Merge | Deep merge two or more objects into one. Later objects overwrite keys from earlier ones. Add as many objects as needed - perfect for combining data from multiple sources. |
| Object Pick | Create a new object containing only the specified keys from the source object. Useful for extracting just the fields you need from large objects. |
| Object Omit | Create a new object excluding the specified keys from the source object. Perfect for removing sensitive fields (like passwords) before logging or display. |
| Object Keys | Extract all keys from an object as an array. Returns top-level keys only - useful for iterating over object properties. |
| Object Values | Extract all values from an object as an array. Returns top-level values only - useful for aggregating or analyzing object data. |
| Object Has Key | Check if an object has a specific key. Supports nested paths with dot notation (e.g., "user.profile.email"). Returns true/false. |
| Flatten Array to Object | Merge an array of objects into a single object. Similar to Ruby's array.reduce({}, :merge). Later objects overwrite keys from earlier ones. |
JSON Operations
Convert between JSON strings and native objects.
| Action | Description |
|---|---|
| Parse JSON | Convert a JSON string into a native object or array. Essential when receiving stringified JSON from APIs or databases. Returns the parsed structure. |
| Stringify JSON | Convert an object or array into a JSON string. Useful for logging, storage, or sending data to external systems that expect JSON strings. |
Date/Time Operations
Work with dates and times without complex date libraries.
| Action | Description |
|---|---|
| Format Date | Format dates using token-style patterns. Supports patterns like YYYY-MM-DD, MMMM DD, YYYY, dddd, MMM DD, or HH:mm:SS. Also accepts standard strftime patterns like %Y-%m-%d. Handles ISO8601 strings, Date objects, and DateTime objects. |
| Calculate Date | Add or subtract time from a date. Choose operation (add/subtract), amount (number), and unit (seconds, minutes, hours, days, weeks, months, years). Returns ISO8601 datetime string. Handles month/year edge cases (e.g., Jan 31 + 1 month = Feb 29). |
Common Date Format Patterns:
YYYY-MM-DD→ 2024-01-15MMMM DD, YYYY→ January 15, 2024MMM DD, YYYY→ Jan 15, 2024dddd, MMMM DD→ Monday, January 15YYYY-MM-DD HH:mm:SS→ 2024-01-15 10:30:45
Chat Action Node
Chat action nodes enhance responses when workflows are triggered from within a chat interface. These nodes are safe to include in any workflow - they simply won't execute if the workflow isn't being run from a chat context. These enhancements help provide context and additional resources without cluttering the main chat response.
Available Chat Enhancements
Links
Add clickable tabs with custom names and URLs at the bottom of messages, perfect for references to external or internal systems
Modals
Create tabs that open detailed information windows with titles and body content when clicked, ideal for expansive references
Accordions
Design collapsible sections for organizing additional information
Script Node
Script nodes allow you to run custom code within your workflow. These scripts are managed in the Tools and Scripts section and provide a way to execute arbitrary code that receives defined variables and returns an output.
When to Use Script Nodes
Data Transformations
Run basic data transformations
HTTP Requests
Make HTTP requests
Data Formatting
Format data in specific ways
Custom Logic
Execute any custom logic where you know exactly what code you need
This node type lets you write the code you need while keeping the UI out of your way.
HTTP Request Node
The HTTP Request node calls any external API endpoint directly from a workflow. Use it to push data to external systems, fetch data from APIs without a dedicated connector, or trigger webhooks.
Configuration
Method — GET, POST, PUT, DELETE, PATCH, HEAD, or OPTIONS.
URL — the endpoint to call. Can be a static URL or a reference to a variable.
Headers — key/value pairs to include in the request headers. Common uses: Content-Type, Authorization, custom API keys.
Body — the request body for POST, PUT, and PATCH requests. Reference variables to include dynamic values.
Timeout — how long to wait for a response before failing, in milliseconds (e.g. 30000 for 30 seconds).
Authentication
None — no authentication.
Basic — HTTP Basic Auth. Provide username and password.
The response is available as an output variable for subsequent nodes. You can optionally apply a Transform pipeline to the response (e.g. parse JSON, pluck a key) before it is stored in the output variable.
Create Chat Node
The Create Chat node opens a new chat thread programmatically from inside a workflow. Use it to surface workflow outputs as a persistent, interactive chat conversation — for example, when a scheduled workflow completes analysis and you want the result accessible as a chat thread a user can continue.
Configuration
userEmail — the Aisle user the chat is created for.
title — the name of the new chat thread.
message — the initial user message in the thread.
responseMessage — the assistant's opening response in the thread.
promptId (optional) — attach a specific prompt to the chat thread.
renderSystemMessage — whether to display the system message in the chat UI.
The node outputs the new chat's ID, available for reference in subsequent nodes.
Transform Node
The Transform node extracts and reshapes data from a variable without setting a new variable directly. Use it when you need to pull a specific field out of a complex object, parse a nested JSON structure, or reformat data before passing it to the next node.
For basic variable manipulation — setting values, doing math, string operations — see the Variable node. The Transform node is specifically for pipeline-style extraction from an existing variable.
Configuration
Source variable — the variable to transform.
Transforms — a pipeline of operations applied in order (for example: parse JSON, then pluck a key).
Output — either a single outputKey, or enable multi-output to map results to multiple named output variables.
Document Splitter Node
The Document Splitter node takes a multi-page file and splits it into individual single-page files. Use it when you need to process a document page by page — for example, passing each page to a prompt node individually, or extracting data from pages in a loop.
Configuration
File — a reference to the file variable to split. Must be a file type. Supported formats: PDF, Word (.doc, .docx), PowerPoint (.ppt, .pptx), OpenDocument (.odt, .odp), and RTF. Non-PDF files are converted to PDF before splitting. Only a single file is accepted; to split multiple documents, use a Collection Loop to process each file separately.
The node outputs an array of files, one per page, available for use in a Collection Loop or other subsequent nodes.
File Operations Node
The File Operations node reads metadata about a file variable or renames a file. Use it when you need to inspect a file's properties before deciding how to process it, or when you need to rename a file before passing it to an output.
Operations
| Operation | Description |
|---|---|
| Get filename | Returns the file's current name |
| Get content type | Returns the MIME type (e.g. application/pdf, image/png) |
| Get byte size | Returns the file size in bytes |
| Rename | Returns a new file with the specified filename |
Configuration
File — a reference to the file variable.
New filename (rename only) — the name to assign to the file.
The result is available as an output variable for subsequent nodes.
Template Node
The Template node renders a text string with variable substitution. Use it to construct dynamic text — formatted messages, email bodies, filenames, API request bodies — from workflow variables without writing a script.
Reference variables inside the template using double curly braces:
Hello {{customer_name}},
Your request ({{ticket_id}}) has been updated.
When the node runs, every {{variableName}} placeholder is replaced with the current value of that variable from the workflow context.
Configuration
Template — the text content with {{ variableName }} placeholders.
The rendered string is available as an output variable for subsequent nodes.
Custom Fields Node
The Custom Fields node reads values from your organization's custom fields — admin-defined fields that store org-level or user-level data. Use it when a workflow needs to pull configuration or metadata that varies by user or organization without hardcoding it into the workflow.
Custom fields are configured under Organization Settings.
Operations
| Operation | Description |
|---|---|
| List field values | Returns all values for a given custom field across the org |
| Get user field value | Returns the value of a custom field for a specific user |
Configuration
Field name — the name of the custom field to query.
userEmail (Get user field value only) — the email address of the user whose field value you want.
Fetch Content Node
The Fetch Content node retrieves the text content of a URL. Use it to pull live web content into a workflow — a webpage, a public document, an RSS feed — so subsequent prompt nodes can analyze, summarize, or extract data from it.
Configuration
URL — the URL to fetch. Can be a static URL or a reference to a variable.
The page content is returned as a string and available as an output variable. You can optionally apply a Transform pipeline to the fetched content (e.g. parse JSON, pluck a key) before it is stored in the output variable.