Workflow Nodes

Workflow nodes are the building blocks of your automation pipelines. The Strongly platform provides 480 nodes and tools across 11 categories, covering data ingestion, transformation, AI processing, control flow, evaluation, and output delivery. The sections below list notable nodes in each category; the full catalog is available in the workflow builder's node palette.

Node Categories Overview

Category	Count	Purpose
Tools	152	General-purpose utilities and integration tools for agents and pipelines
Sources	123	Read data from external systems and services
Destinations	66	Write data to external systems and services
Transform	51	Parse, extract, reshape, and process data
Control Flow	23	Manage execution paths, loops, and branching
Agents	16	Orchestrate multi-step AI reasoning and task execution
Triggers	16	Initiate workflow execution from events or schedules
Evaluation	10	Assess AI output quality and enforce guardrails
AI	9	Connect to language models, embeddings, vision, and speech
Memory	7	Store and retrieve context, state, and knowledge
Operators	7	Helper nodes that provide capabilities to agents and pipelines

Streaming nodes

The counts above cover the standard (batch) workflow palette. Streaming workflows use a separate palette of 120 streaming nodes for real-time audio, video, and conversational pipelines, with their own triggers, processors, and responders.

---

Sources

Source nodes read data from external systems and services. The category contains 123 nodes; notable ones are listed below. Configure connection credentials once in Data Sources and reuse them across multiple workflows.

Common Configuration:

• Connection credentials (via Data Sources)
• Query or filter parameters
• Response data mapping
• Error handling and retries

Databases -- Relational

Node ID	Display Name	Description
clickhouse	ClickHouse	Real-time analytics database operations on ClickHouse
cockroachdb	CockroachDB	Execute queries on CockroachDB
cratedb	CrateDB	Execute queries on CrateDB distributed databases
greenplum	Greenplum	Query data from Greenplum MPP database
mssql	Microsoft SQL Server	Execute queries on Microsoft SQL Server databases
mysql	MySQL	Query data from MySQL database
oracle	Oracle Database	Execute queries on Oracle databases
postgresql	PostgreSQL	Query data from PostgreSQL database
questdb	QuestDB	Execute queries on QuestDB time-series databases
redshift-source	Amazon Redshift	Query data from Amazon Redshift
singlestore	SingleStore	Execute queries on SingleStore distributed databases
snowflake	Snowflake	Execute queries on Snowflake data warehouse
timescaledb	TimescaleDB	Execute queries on TimescaleDB time-series databases

Databases -- NoSQL and Document

Node ID	Display Name	Description
arangodb	ArangoDB	Execute operations on ArangoDB multi-model databases
couchbase	Couchbase	Execute operations on Couchbase databases
couchdb	CouchDB	Execute operations on Apache CouchDB
dynamodb	DynamoDB	AWS NoSQL database operations on DynamoDB
firestore	Google Cloud Firestore	Execute operations on Google Cloud Firestore
mongodb	MongoDB	Document database operations on MongoDB
surrealdb	SurrealDB	Query data from SurrealDB

Databases -- Graph

Node ID	Display Name	Description
neo4j	Neo4j	Query data from Neo4j graph database
neptune	Amazon Neptune	Execute queries on Amazon Neptune graph databases
tigergraph	TigerGraph	Execute operations on TigerGraph graph databases

Databases -- Vector

Node ID	Display Name	Description
chroma	Chroma	Vector database operations on Chroma
marqo	Marqo	Execute operations on Marqo tensor search engines
milvus	Milvus	Vector similarity search with Milvus
pgvector	pgvector	Vector operations using PostgreSQL pgvector extension
pinecone	Pinecone	Vector database operations on Pinecone
qdrant	Qdrant	Vector database operations on Qdrant
vespa	Vespa	Execute operations on Vespa search engines
weaviate	Weaviate	Vector database operations on Weaviate

Databases -- Search and Cache

Node ID	Display Name	Description
elasticsearch	Elasticsearch	Search and analytics on Elasticsearch
memcached	Memcached	Execute operations on Memcached caching systems
redis	Redis	In-memory database operations on Redis

Databases -- Low-Code and Spreadsheet

Node ID	Display Name	Description
airtable	Airtable	Database operations on Airtable
baserow	Baserow	Execute operations on Baserow tables and databases
grist	Grist	Execute operations on Grist documents and tables
nocodb	NocoDB	Execute operations on NocoDB tables and databases
seatable	SeaTable	Execute operations on SeaTable bases and tables
supabase	Supabase	Query a Supabase project's PostgreSQL database

Cloud Storage and File Systems

Node ID	Display Name	Description
azure-blob-source	Azure Blob Storage	Read files from Azure Blob Storage
dropbox	Dropbox	Execute operations on Dropbox files and folders
ftp	FTP	Execute file operations on FTP and SFTP servers
google-cloud-storage	Google Cloud Storage	Execute operations on Google Cloud Storage buckets
google-drive	Google Drive	Execute operations on Google Drive files and folders
minio	MinIO	Execute operations on MinIO and S3-compatible storage
onedrive	OneDrive	Execute operations on Microsoft OneDrive files and folders
s3	Amazon S3	List or download files from Amazon S3
sftp	SFTP	Download files from SFTP server. Supports file patterns, recursive downloads, and file filtering
sharepoint	SharePoint	Execute operations on Microsoft SharePoint sites and lists

CRM and Sales

Node ID	Display Name	Description
dynamics	Microsoft Dynamics 365	Interact with Microsoft Dynamics 365 CRM
freshdesk	Freshdesk	Interact with Freshdesk support platform
hubspot	HubSpot	Interact with HubSpot CRM
pipedrive	Pipedrive	Interact with Pipedrive Sales CRM
salesforce	Salesforce	Interact with Salesforce CRM
zendesk	Zendesk	Interact with Zendesk support

Project Management and Productivity

Node ID	Display Name	Description
asana	Asana	Interact with Asana project management
clickup	ClickUp	Interact with ClickUp project management
jira	Jira	Interact with Jira project management
linear	Linear	Interact with Linear project management
monday	monday.com	Interact with monday.com boards
notion	Notion	Execute operations on Notion workspaces
trello	Trello	Interact with Trello boards

Communication and Messaging

Node ID	Display Name	Description
discord	Discord	Interact with Discord servers
gmail	Gmail	Interact with Gmail API
microsoft-outlook	Microsoft Outlook	Interact with Microsoft Outlook via Graph API
microsoft-teams	Microsoft Teams	Interact with Microsoft Teams
microsoft-exchange	Microsoft Exchange	Read emails from Microsoft Exchange and save as .eml files with embedded attachments
slack	Slack	Interact with Slack workspaces
telegram	Telegram	Interact with Telegram Bot API
twilio	Twilio	Send SMS, make calls, and interact with Twilio
whatsapp	WhatsApp Business	Send and receive messages via WhatsApp Business Cloud API

Social Media

Node ID	Display Name	Description
facebook	Facebook Graph API	Interact with Facebook Graph API for pages and ads
linkedin	LinkedIn	Interact with LinkedIn professional network
twitter	Twitter/X	Interact with Twitter/X API
youtube	YouTube	Interact with YouTube Data API

Analytics and Monitoring

Node ID	Display Name	Description
google-ads	Google Ads	Manage Google Ads campaigns and reporting
google-analytics	Google Analytics	Interact with Google Analytics 4
grafana	Grafana	Interact with Grafana monitoring
metabase	Metabase	Interact with Metabase BI platform
posthog	PostHog	Interact with PostHog product analytics
segment	Segment	Interact with Segment customer data platform
sentry	Sentry	Interact with Sentry error tracking

Google and Microsoft Workspace

Node ID	Display Name	Description
excel-online	Excel Online	Execute operations on Microsoft Excel 365 workbooks
google-calendar	Google Calendar	Interact with Google Calendar
google-docs	Google Docs	Interact with Google Docs
google-forms	Google Forms	Interact with Google Forms
google-meet	Google Meet	Interact with Google Meet
google-sheets	Google Sheets	Read and write data to Google Sheets

DevOps and CI/CD

Node ID	Display Name	Description
cloudflare	Cloudflare	Interact with Cloudflare infrastructure
github	GitHub	Interact with GitHub repositories
gitlab	GitLab	Interact with GitLab repositories
jenkins	Jenkins	Interact with Jenkins CI/CD

Identity and Access Management

Node ID	Display Name	Description
entra-id	Microsoft Entra ID	Interact with Microsoft Entra ID (Azure AD)
ldap	LDAP	Query and manage LDAP directories
okta	Okta	Interact with Okta Identity Management

Message Queues and Streaming

Node ID	Display Name	Description
kafka	Kafka	Execute operations on Apache Kafka topics
mqtt	MQTT	Execute operations on MQTT brokers
nats	NATS	Execute operations on NATS messaging system
pulsar	Pulsar	Execute operations on Apache Pulsar
rabbitmq	RabbitMQ	Consume messages from RabbitMQ
sns	SNS	Execute operations on AWS Simple Notification Service
sqs	SQS	Execute operations on AWS Simple Queue Service

E-Commerce and Payments

Node ID	Display Name	Description
paypal	PayPal	Interact with PayPal payments
quickbooks	QuickBooks Online	Interact with QuickBooks Online accounting
shopify	Shopify	Interact with Shopify stores
stripe	Stripe	Interact with Stripe payments
woocommerce	WooCommerce	Interact with WooCommerce stores

IT Service Management

Node ID	Display Name	Description
pagerduty	PagerDuty	Interact with PagerDuty incident management
servicenow	ServiceNow	Interact with ServiceNow ITSM platform
workday	Workday	Interact with Workday HR and Finance platform

APIs and General Connectivity

Node ID	Display Name	Description
api	REST API	Fetch data from REST API endpoints with authentication and flexible configuration
bigquery	Google BigQuery	Execute queries on Google BigQuery
exec	Execute Command	Execute shell commands and scripts
graphql	GraphQL	Execute GraphQL queries and mutations
ssh	SSH	Execute commands and transfer files via SSH

Other Integrations

Node ID	Display Name	Description
intercom	Intercom	Interact with Intercom customer messaging platform
typeform	Typeform	Interact with Typeform forms and surveys
wordpress	WordPress	Interact with WordPress REST API
zoom	Zoom	Interact with Zoom video conferencing

Data Sources

Configure connection credentials once in Data Sources and reuse across multiple workflows. This avoids embedding secrets in workflow definitions.

---

Transform

Transform nodes parse, extract, reshape, and process data between source and destination nodes. They handle format conversion, aggregation, filtering, and custom logic. The category contains 55 nodes.

Before writing a Code node, look for a node that already does the step: search the builder's node panel for what the step does (for example "parse JSON", "aggregate", "look up", "compare", "chunk text"). Input mappings and Set Fields cover most reshaping with no extra node, and parsing an LLM's JSON reply is the JSON Parser node (map its text input to the LLM's data.response). Use Code only when no node does the step.

Node ID	Display Name	Description
aggregate	Aggregate	Aggregate data with sum, average, count, and more
ai-transform	AI Transform	Transform data using AI
audio-emotions	Audio Emotions	Add expressive TTS audio tags to dialogue via an LLM so synthesized speech is expressive instead of flat
client-node	Client Node	Run a task on the workflow owner's own machine through Strongly Bridge
code	Code	Execute custom Python code for data transformation
combine-documents	Combine Documents	Concatenate an ordered array of files (currently PDFs) into a single combined file
compare	Compare Datasets	Compare two datasets to find differences
compression	Compression	Compress and decompress data
crypto	Crypto	Encryption, hashing, encoding, and cryptographic operations
csv-to-pdf	CSV to PDF	Convert delimited-text files (.csv, .tsv, .psv) into paginated PDF tables
data-aggregator	Data Aggregator	Aggregate, flatten, filter, and transform array data from loop results
data-lookup	Data Lookup	High-performance in-memory lookup. Supports cached mode (O(1) hash lookups from file) or inline mode (reference array). Perfect for database lookups in row loops.
data-standardizer	Data Standardizer	Standardize common data-type values (address, phone, date, state, etc.) to canonical forms, code-first with an optional LLM fallback
datetime	Date/Time	Date and time parsing, formatting, and arithmetic
dedupe	Remove Duplicates	Remove duplicate items from arrays
email-parser	Email Parser	Parse email files and extract content, attachments, and metadata
excel-parser	Excel Parser	Parse Excel files and extract data as structured JSON
excel-report	Excel Report	Generate a multi-sheet Excel workbook from grouped data
excel-to-pdf	Excel to PDF	Convert Excel workbooks (modern and legacy) into PDF documents
file-cacher	File Cacher	Cache file content so downstream nodes like PDF Parser can load it
file-extractor	File Extractor	Extract files from ZIP, TAR, GZ, and other archive formats. Supports nested archives and file filtering
filter	Filter	Filter data based on conditions and rules
html-extract	HTML Extract	Extract data from HTML content
html-to-pdf	HTML to PDF	Convert HTML files into PDF documents
image-to-pdf	Image to PDF	Convert raster images (PNG, JPEG, TIFF, and more) into PDF so scanned documents can flow through PDF-only pipelines
json-parser	JSON Parser	Parse a JSON file or string into a value
jwt	JWT	Create, verify, and decode JSON Web Tokens
limit	Limit	Limit the number of items in an array
markdown	Markdown	Parse and convert Markdown content
merge-data	Merge Data	Merge data from multiple sources using various strategies like concatenation, object merge, or combine
number-format	Number Format	Format, round, convert, and transform numeric values
pdf-generator	PDF Generator	Generate PDF documents from templates, data, or HTML/markdown content
pdf-page-split	PDF Page Split	Cut a PDF into part PDFs by explicit 1-based page ranges
pdf-parser	PDF Parser	Extract data from PDF files
pdf-parser-ocr	PDF Parser OCR	Extract text from PDFs with dual-parser + OCR fallback for image-heavy pages
pdf-redactor	PDF Redactor	Redact or obfuscate sensitive content in PDF documents. Supports row-based redaction and keyword/pattern modes with S3-cached indexing for faster processing
pdf-splitter	PDF Splitter	Split a multi-document PDF into one item per document
pptx-report	PowerPoint Report	Generate a themed PowerPoint (.pptx) report deck
redaction-list-builder	Redaction List Builder	Build a list of values to redact from all rows EXCEPT the current/matched row. Perfect for creating per-row redacted PDFs
rename-keys	Rename Keys	Rename object keys and transform naming conventions
report-builder	Report Builder	Generate formatted reports (HTML, PDF, Markdown) with tables, sections, grouping, and master-detail layouts
set-fields	Edit Fields	Set, edit, rename, and delete data fields
sort	Sort	Sort arrays of data by specified fields
string-transform	String Transform	Transform string values with trim, case conversion, regex replace, padding, and more
summarize	Summarize	Create statistical summaries of data
table-parser	Table Parser	Extract structured data from tables with optional filtering, validation, and repair
text-chunker	Text Chunker	Split text into chunks for embedding and RAG pipelines. Supports multiple chunking strategies with overlap
to-file	Convert to File	Convert data to file format
totp	TOTP	Generate and verify Time-based One-Time Passwords
txt-to-pdf	Text to PDF	Convert plain text and log files into PDF documents
value-map	Value Map	Map and translate values using lookup tables, defaults, and regex patterns
video-assembly	Video Assembly	Assemble an ordered list of video clips into a single program with transitions, captions, music bed, and intro/outro
word-report	Word Report	Generate a themed Word (.docx) report
word-to-pdf	Word to PDF	Convert Microsoft Word documents into PDF, preserving formatting, lists, tables, and images
xml-parser	XML	Parse XML to JSON or convert JSON to XML

---

Destinations

Destination nodes write processed data to external systems and services. The category contains 66 nodes; notable ones are listed below.

Common Configuration:

• Destination credentials (via Data Sources)
• Data mapping and field selection
• Success/failure handling
• Delivery confirmation

Node ID	Display Name	Description
chat-response	Respond to Chat	Send response to chat interface
discord	Discord	Send messages and interact with Discord
greenplum	Greenplum	Write data to Greenplum MPP database
mailchimp	Mailchimp	Email marketing and automation with Mailchimp
milvus	Milvus	Store vectors in Milvus
mongodb	MongoDB	Save data to MongoDB
microsoft-exchange	Microsoft Exchange	Send emails via Microsoft 365/Exchange with attachments support
mysql	MySQL	Save data to MySQL database
neo4j	Neo4j	Store data in Neo4j graph database
notification	Notification	Send multi-channel notifications (email, Slack, webhook, SMS)
postgresql	PostgreSQL	Save data to PostgreSQL database
rabbitmq	RabbitMQ	Publish messages to RabbitMQ
redis	Redis	Write data to Redis
s3	Amazon S3	Upload files to S3 bucket
sendgrid	SendGrid	Send email via SendGrid API with support for templates, attachments, and scheduling
slack	Slack	Send messages and interact with Slack
smtp	Send Email	Send email via SMTP server with support for HTML, attachments, and templates
sns	AWS SNS	Send notifications via AWS Simple Notification Service
streaming-response	Streaming Response	Stream data chunks to clients
surrealdb	SurrealDB	Write data to SurrealDB
teams	Microsoft Teams	Send messages to Microsoft Teams
webhook-response	Respond to Webhook	Send HTTP response to webhook caller

Most database, warehouse, vector, spreadsheet, and queue systems available as sources also have a matching destination node (with a -dest node id), including Snowflake, Google BigQuery, Amazon Redshift, ClickHouse, Microsoft SQL Server, Oracle Database, DynamoDB, Firestore, Elasticsearch, Pinecone, Qdrant, Weaviate, Chroma, pgvector, Google Sheets, Airtable, Apache Kafka, Apache Pulsar, Amazon SQS, Google Cloud Storage, MinIO, and Azure Blob Storage.

---

Control Flow

Control flow nodes manage execution paths, looping, branching, and data routing within workflows. The category contains 23 nodes:

Node ID	Display Name	Description
backtrack	Backtrack	Checkpoint and restore workflow state for backtracking
conditional	Conditional	If/Else conditional branching
consensus	Consensus	Multi-agent voting and decision-making
event-wait	Event Wait	Wait for events from multiple sources before continuing
goal-loop	Goal Loop	Loop until LLM determines the goal is achieved
human-checkpoint	Human Checkpoint	Pause workflow for human review, approval, or input. Essential for AI safety and human oversight in agentic workflows
human-feedback	Human Feedback	Collect structured human input mid-workflow
loop	Loop	Iterate over arrays or repeat actions
map	Map	Process array items in parallel: the body hangs off Each Item and a Loop Accumulator on Completed closes it
merge	Loop Accumulator (Sink)	Accumulates a loop's per-iteration outputs into one array exposed on this node's own output
noop	No Operation	Pass-through node that does nothing
parallel-branch	Parallel Branch	Run the branches wired to its output at the same time; a node the branches share runs after them
priority-queue	Priority Queue	Queue items and process in priority order
retry	Retry	Re-run the node wired into it until it succeeds, with a backoff between attempts
split	Split Out	Split arrays into individual items for separate processing
start-streaming-session	Start Streaming Session	Start a streaming workflow session from a batch workflow, passing context data and optionally waiting for completion
stop-error	Stop and Error	Stop workflow execution with an error
streaming-call-await	Streaming Call Await	Wait until a streaming voice session reaches a terminal state before continuing
sub-workflow	Sub-Workflow	Execute another workflow
switch-case	Switch/Case	Multi-way branching based on value matching with support for patterns, ranges, and multiple cases
wait	Wait	Hold the workflow for a duration or until a date and time, then pass the data on
wait-for-input	Wait for Input	Pause workflow and wait for external input via REST API
while-loop	While Loop	Execute a branch repeatedly while a condition is true, with configurable limits and break/continue support

Conditional Node

Execute different branches based on conditions. Draw the matched branch from the If (True) handle and the other from Else (False):

Build each condition in the Conditions list as a field, an operator and a value. The field is a path into the node's own inputs (as mapped on its Input tab), not an expression. With the node's data input mapped to data:

Field	Operator	Value
data.status	equals	approved
data.amount	greater than	1000
data.tags	contains	urgent

Mode decides whether the first true condition wins (First Match) or every condition is evaluated; Case Sensitive applies to the string operators.

Supported Operators:

• Comparison: ==, !=, >, >=, <, <=
• String: contains, starts_with, ends_with, regex
• Null checks: is_null, is_not_null, is_empty, is_not_empty
• List: in, not_in
• Boolean: is_true, is_false

Loop Node

Iterate over array data with accumulator support. Draw the body from the Loop Body handle, connect the body's last node and the Completed handle to one Loop Accumulator, and continue from the accumulator:

On the Loop's Input tab, map its items input to the array, for example data.users. Each node on the body receives one item per run:

Path (in a body node's input mapping or Code)	Value
data.currentItem	The current item, for example data.currentItem.name
data.index	The item's position, from 0
data.total	How many items the loop runs

The node after the Loop Accumulator reads every iteration's result at data.data, in item order. See How Workflows Run.

Map Node

Transform each item in an array with parallel processing. Draw the body from the Each Item handle, connect the body's last node and the Completed handle to one Loop Accumulator, and continue from the accumulator:

Map the Map's items input to the array, for example data.products. Each body node reads its item at data.currentItem. For example, a Code node on the body that reprices each product:

p = item["currentItem"]
result = {"id": p["id"], "price": round(p["price"] * 1.1, 2)}

Instead of mapping items, you can map the Map's data input to an object and set Input Array Path to the array inside it, for example data.products. A path that holds no array stops the run with an error that names the inputs the Map has.

Setting	Default	What it does
Input Array Path	items	Path to the array in the Map's mapped inputs.
Max Parallel Workers	10	How many items run at once, in the workflow's pod (1 to 200). The same setting appears as Max Workers (Threads) on the Scaling tab.
Max Items	0	Run only the first N items; 0 runs them all. A map cut short shows truncated and unprocessedCount on its run details.

The node after the Loop Accumulator reads every item's result at data.data, in item order; an item whose body failed arrives as a record with _itemFailed: true. To spread items over several pods, use a Loop with Pod Scaling.

Goal Loop Node

Repeat a body until an LLM judges a goal met. Map goal (and data, what the first iteration works on) on the Input tab, connect an LLM node to its AI connector, draw the body from Continue, and connect the body's last node and the Complete handle to one Loop Accumulator. Nodes wired from Complete run once the loop ends: the goal was met at the Confidence Threshold, or Max Iterations ran. An evaluation that cannot reach the model, or gets a reply that is not the verdict, fails the run.

Wait Node

Hold the workflow, then pass the data input on unchanged. Wait Mode is Wait Duration (Duration, 0 to 86400 seconds) or Wait Until Time (Wait Until, a date and time with its zone such as 2026-12-31T09:00:00Z; a time already passed does not wait). Stopping the run ends the wait at once. To wait for an event or a person, use Event Wait or Human Checkpoint.

Retry Node

Re-run a node that can fail for a passing reason. Wire that node (the operation) into Retry's input, the next step from Success, and the failure path from Failed. The operation's failure does not stop the run; Retry judges each attempt. An attempt fails when the node fails, or its output has error or failed set, success: false, or a status other than success, completed, ok or 200.

Setting	Default	What it does
Max Retries	3	Times the operation runs again after its first attempt fails (0 to 10).
Retry Delay (seconds)	1	Wait before the first retry.
Backoff Type	Exponential	Fixed (same wait), Linear (delay x retry number) or Exponential (delay doubles).

Success carries the operation's output at data.data; Failed carries the reason at data.error.

Parallel Branch Node

Run independent branches at the same time. Map data to what the branches need, draw each branch's first node from Output, and join the branches in a node they all feed, such as a Loop Accumulator with its data input mapped to data (it collects every branch's output in one list). The join runs once every branch has ended. Max Parallel Workers (1 to 50, default 10) sets how many branches run at once. A branch cannot hold a Loop or Map; a branch failure fails the run once the other branches have ended.

Stop and Error Node

End the run as failed with your Error Message (it can use {{field}} from the node's inputs), Error Type and Error Code. It always stops the run, whatever Continue on Error says.

Data Aggregator

Process loop results with multiple operations:

// Operations
[
  {"type": "extract", "field": "pdfPath", "outputField": "allPdfs"},
  {"type": "flatten", "field": "errors", "outputField": "allErrors"},
  {"type": "filter", "condition": {"field": "status", "operator": "==", "value": "failed"}},
  {"type": "count", "outputField": "totalCount"}
]

---

Agents

Agent nodes orchestrate complex, multi-step AI workflows using specialized reasoning patterns for autonomous task execution. The category contains 16 nodes:

Node ID	Display Name	Description
agent-loop	Agent Loop	Configurable autonomous think-act-observe agent loop
column-mapper	Column Mapper Agent	Uses LLM to intelligently map source columns to a target schema. Handles varying column names across different data sources by understanding semantic meaning. Supports database caching for known mappings
data-cleanup	Data Cleanup Agent	Uses LLM to validate and fix malformed data rows from PDF extraction. Detects shifted columns, merged values, and data type mismatches
debate-agent	Debate Agent	Multi-agent debate pattern for reaching consensus through structured argumentation, critique, and synthesis
document-classification	Document Classification	Intelligent document classification agent
entity-extraction	Entity Extraction	Intelligent entity extraction agent
multi-agent-chat	Multi-Agent Chat	Multiple AI personas collaborate on a shared discussion thread
pii-detector-llm	PII Detector (LLM)	Detects PII spans in a text file via an LLM and outputs the unique values list for a downstream redactor
pii-redaction-validator	PII Redaction Validator	LLM-as-judge filter over upstream PII detections, confirming each candidate is real PII in context
pii-redactor	PII Redactor Agent	Detects PII in a file via a connected AI Gateway model and applies per-type actions (redact, mask, label, pseudonymize, and more)
pii-redactor-qwen	PII Redactor (Qwen Few-Shot)	Few-shot PII detector for the Qwen fine-tuned PII model, with user-supplied few-shot examples
planner	Planner	Decompose complex goals into ordered sub-tasks with dependencies
react-agent	ReAct Agent	Autonomous AI agent using the ReAct (Reasoning + Acting) pattern. Iteratively thinks, acts using tools, and observes results until the goal is achieved
reflection	Reflection	Self-review and iterative content improvement via critique-revise cycles
supervisor-agent	Supervisor Agent	Orchestrates multiple sub-agents to accomplish complex tasks. Creates execution plans, delegates work, and synthesizes results
web-agent	Web Agent	Autonomous web agent: given a natural-language task and a start URL, an LLM writes and runs browser automation code in a sandbox to complete multi-step web tasks

Agent Patterns:

• ReAct: Autonomous reasoning and acting loop with tool use
• Debate: Multiple AI perspectives argue and converge on conclusions
• Supervisor: Hierarchical task delegation and result synthesis
• Reflection: Self-critique and iterative improvement
• Multi-Agent Chat: Collaborative discussion between AI personas
• Planner: Goal decomposition into ordered sub-tasks

Learn more about AI Agents

---

Triggers

Triggers initiate workflow execution. Every workflow must start with exactly one trigger node. The category contains 16 nodes:

Node ID	Display Name	Description
agent-trigger	Agent Trigger	Send a message to an agent endpoint and stream the response
batch-subscribe	Batch Subscribe	Iterate archived streaming sessions and emit one record per session so a batch workflow can fan out processing across them
chat-trigger	Chat	Trigger workflows from chat/conversational interfaces
email-trigger	Email	Start a workflow when new emails arrive in an IMAP mailbox (checked every Poll Interval)
error-trigger	Error	Start a workflow when a run of another workflow in your organization fails
event	Event	Trigger workflow from platform events (workflow completed, model deployed, etc.)
file-trigger	File	Start a workflow when files are added or updated in an S3 data source (checked every Poll Interval)
form	Form	Accept public form submissions with file uploads and CAPTCHA protection
multi-modal-input	Multi-Modal Input	Accept mixed media types as workflow input (text, image, audio, file)
queue	Queue	Trigger workflow from a message queue (REST API enqueue endpoint)
rest-api	REST API	Expose workflow as authenticated REST API endpoint
rss-trigger	RSS Feed	Start a workflow when an RSS/Atom feed has new items (checked every Poll Interval)
schedule	Schedule	Trigger workflow on a schedule
sse-trigger	SSE	Trigger workflow on Server-Sent Events
task-due-trigger	Task Due	Fires when a platform task's due date is reached; the triggered workflow receives the full task object
webhook	Webhook	Trigger a workflow over HTTP, authorized by REST API key or external HMAC signature

Learn more about triggers

---

Evaluation

Evaluation nodes assess AI output quality, detect hallucinations, enforce guardrails, and enable systematic testing of AI workflows. All LLM-based evaluation nodes connect to an AI Gateway for assessment.

Node ID	Display Name	Description
answer-quality	Answer Quality	Evaluates overall answer quality using a composite of metrics: correctness, completeness, helpfulness, and coherence. Provides a holistic assessment of LLM response quality
cost-tracker	Token Tracker	Count token usage across a run, with an optional token limit (tokens carry no price)
faithfulness-checker	Faithfulness Checker	Detects hallucinations by checking if the generated response is grounded in the provided context. Essential for RAG systems to ensure answers do not contain fabricated information
guardrails	Guardrails	Content validation with PII detection, toxicity checking, and custom rules
llm-as-judge	LLM as Judge	Uses an LLM to evaluate outputs based on configurable criteria. Supports single scoring, multi-criteria evaluation, and chain-of-thought reasoning for reliable assessments
output-parser	Output Parser	Parse and validate LLM output into structured formats
pairwise-comparator	Pairwise Comparator	Compares two outputs/responses and determines which is better. Ideal for A/B testing, model comparison, prompt optimization, and relative quality assessment
rag-metrics	RAG Metrics	Comprehensive RAG pipeline evaluation with context precision, context recall, answer relevancy, and faithfulness metrics. Essential for optimizing retrieval-augmented generation systems
rate-limiter	Rate Limiter	Enforce rate limits with token bucket or sliding window
relevance-grader	Relevance Grader	Evaluates whether retrieved documents or context are relevant to the query. Essential for RAG pipeline evaluation and retrieval quality assessment

Use Cases:

• RAG pipeline quality monitoring
• Hallucination detection and prevention
• A/B testing prompts and models
• Automated quality gates in production
• Continuous evaluation of AI outputs
• Cost tracking and budget enforcement
• Content safety and PII detection

Configuration:

• Select evaluation criteria
• Configure scoring scales (0-1, 1-5, 1-10, binary)
• Set pass/fail thresholds
• Enable chain-of-thought reasoning
• Connect to AI Gateway for judge model

Metrics Logging

Evaluation nodes automatically log metrics (scores, pass rates) that can be viewed in the Workflow Monitor's execution trace and compared across runs.

---

Memory

Memory nodes store and retrieve context, knowledge, and workflow state for multi-turn and agent-based workflows. The category contains 7 nodes:

Node ID	Display Name	Description
context-buffer	Context Buffer	Manage working memory and context windows
episodic-memory	Episodic Memory	Store and retrieve past workflow experiences via MongoDB
knowledge-base	Knowledge Base	Store and query structured knowledge
memory-retriever	Memory Retriever	Query multiple memory sources and merge/rank results
semantic-memory	Semantic Memory	Vector store with embedding-based retrieval via Milvus
shared-blackboard	Shared Blackboard	Cross-agent shared key-value state via MongoDB
working-memory	Working Memory	Short-term key-value scratchpad with TTL support

Use Cases:

• Multi-turn conversations with context retention
• Context-aware AI responses
• RAG (Retrieval Augmented Generation) knowledge stores
• Long-term memory for autonomous agents
• Cross-agent state sharing in multi-agent workflows

---

AI

AI nodes connect to language models for inference, embeddings, vision, and speech processing. The category contains 9 nodes:

Node ID	Display Name	Description
avatar-render-batch	Avatar Render (Batch)	Render a photoreal talking-head video clip from an audio file using a deployed avatar, at higher quality than the real-time renderer
embeddings	Embeddings	Generate vector embeddings via AI Gateway
image-generation	Image Generation	Generate images via AI Gateway with async job-based processing
llm	LLM	Text and chat completion via AI Gateway
model-registry	Model Registry	Run inference against deployed ML models from the Strongly Model Registry: select a model, map input features, and get predictions
speech-to-text	Speech to Text	Transcribe audio to text
streaming-realtime	Streaming Realtime Model	Select a bidirectional realtime audio model for use by streaming realtime agents
text-to-speech	Text to Speech	Generate speech audio from text via AI Gateway
vision	Vision	Analyze images and visual content with AI models

Configuration:

• Select model from AI Gateway
• Set prompt template
• Configure parameters (temperature, max tokens)
• Define response format
• Token usage tracking

Advanced Features:

• Streaming responses
• Function calling
• Multi-turn conversations
• Prompt engineering
• Cost tracking

Learn more about AI in workflows

---

Tools

Tool nodes provide general-purpose utilities for code execution, HTTP calls, file operations, and web interaction, plus a large catalog of integration tools that can be wired to agent nodes. The category contains 152 nodes.

Core utilities:

Node ID	Display Name	Description
api-caller	API Caller	Make dynamic HTTP API calls with optional datasource authentication
calculator	Calculator	Safe mathematical expression evaluator (no eval, uses AST)
code-interpreter	Code Interpreter	Execute Python or JavaScript code in a sandboxed subprocess
fetch	HTTP Fetch	Fetch URLs, parse JSON, convert HTML to text/markdown, and make REST API requests
file-manager	File Manager	Read, write, and copy files via workflow storage
filesystem	Filesystem	Local file system operations: read, write, copy, move files, list and search directories
time	Time	Get current time, convert between timezones, parse/format datetimes, calculate time differences
web-browser	Web Browser	Chromium-based browser with full JS rendering, screenshots, and PDF generation
web-search	Web Search	Search the web using SerpAPI, Brave Search, Tavily, or a generic search API endpoint

Integration tools: the rest of the category covers named services and capabilities, including browser automation (Playwright, Puppeteer, HyperBrowser), web scraping and search (Firecrawl, Brave Search, DuckDuckGo, Exa Search, ScrapeGraph), developer platforms (GitHub, GitLab, Git, CircleCI, Docker Hub, Postman, SonarQube), productivity and business apps (Notion, Todoist, Box, Coda, Webflow, Xero, Zoho CRM, Stripe), data systems (MongoDB, Redis, Elasticsearch, Oracle Database, SingleStore, Neo4j), AI and language services (ElevenLabs, Whisper, DeepL, Google Translate, Wolfram Alpha), reasoning helpers (Sequential Thinking, Memory), and Library tools (Library Skills, Library Prompts, Library Rules, Library Memory, Library Preferences, Library Tasks).

---

Operators

Operators are helper nodes that provide capabilities to other nodes in the workflow, such as supplying tools to agents, building prompts, and handling cross-node plumbing. The category contains 7 nodes:

Node ID	Display Name	Description
agent-handoff	Agent Handoff	Package and transfer context between agent nodes
execution-errors	Execution Errors	Query errors from the current workflow execution so error data can be included in reports, alerts, or downstream processing
function-calling	Function Call Extractor	Extracts and parses function/tool calls from AI responses
mcp-tools-provider	MCP Tools Provider	Provides MCP server tools to agents. Connect to an agent's 'tools' connector
rag	RAG Prompt Builder	Builds RAG prompts by combining user queries with retrieved documents
s3-move	Amazon S3 (Move)	Move S3 objects from one S3 datasource to another using server-side copy and delete
tool-router	Tool Router	LLM-based dynamic tool selection for a given task

MCP (Model Context Protocol) servers can expose their tools to agent nodes through the MCP Tools Provider operator.

Learn more about MCP Tools

---

Node Configuration

Common Settings

All nodes share these basic settings:

Identity

• Name: Display name on canvas
• Description: Purpose and notes
• Enabled: Toggle execution on/off

Execution

• Retry Count: Number of retry attempts
• Retry Delay: Wait time between retries
• Timeout: Maximum execution time

Error Handling

• On Error: Continue, stop workflow, or branch
• Fallback Value: Default value on failure
• Error Output: Capture error details

Data Mapping

Node settings and mappings do not use {{ }} templates. A node gets data from the node directly connected before it, through the input mappings on its Input tab: drag a field from the upstream node's output onto one of the node's inputs. A path starts with data (the upstream node's output) and uses dots and [n] indexes:

Mapping	Reads
data.body.userId	A field of a webhook payload (webhook bodies arrive under data.body)
data.response	An LLM node's response text
data.items[0].name	A field of the first element of an array
data.file || data.files[0]	The first of several paths that has a value
data.data	The array a Loop Accumulator collected

A node sees only its directly connected upstream nodes. To carry a value further, pass it through each node in between (its pass-through values). To compute a value (a condition, a transform of every element), use a node for it: Conditional or Switch-Case to branch, Filter, Set Fields or Code to transform.

Some nodes fill {{name}} placeholders inside their own template settings, for example an email or notification body, a PDF Generator template or a String Transform template.

Best Practices

Node Organization

1. Left-to-Right Flow: Arrange nodes to show progression
2. Vertical Spacing: Group related processing paths
3. Descriptive Names: Use clear, purpose-driven names
4. Documentation: Add notes to complex nodes

Performance Optimization

1. Minimize Sequential Chains: Use parallel execution where possible
2. Cache Results: Store frequently accessed data
3. Batch Operations: Process multiple items together
4. Filter Early: Remove unnecessary data early in pipeline

Error Handling

1. Add Retries: Configure retries for network operations
2. Fallback Values: Provide defaults for optional data
3. Error Branches: Route errors to notification/logging
4. Validation: Check data format before processing

Security

1. Credentials: Use Data Sources for sensitive credentials
2. Input Validation: Sanitize user inputs
3. Output Filtering: Do not expose sensitive data
4. Access Control: Review workflow permissions

Node Examples

Example: Data Enrichment Pipeline

Webhook Trigger
  -> REST API (Fetch user data)
  -> AI Gateway (Analyze sentiment)
  -> MongoDB (Store results)
  -> Webhook Response (Notify completion)

Example: Document Processing

Schedule Trigger
  -> Amazon S3 (List new PDFs)
  -> Loop (For each PDF)
    -> PDF Parser (Extract text)
    -> Entity Extraction (Find entities)
    -> Neo4j (Store relationships)

Example: Batch Processing with Aggregation

Schedule Trigger
  -> SFTP Source (Download files)
  -> Loop (For each file)
    -> Conditional (Check file type)
      -> [.zip] File Extractor -> PDF Parser
      -> [.pdf] PDF Parser (direct)
    -> Table Parser (Extract data)
    -> MySQL (Lookup)
    -> PDF Redactor (Redact sensitive data)
  -> Data Aggregator (Collect results)
    -> [allPdfs] Amazon S3 (Upload batch)
    -> [allErrors] PDF Generator (Create report)
      -> Microsoft Exchange (Email report)

Example: Conditional Routing

Form Trigger
  -> Conditional (Check priority)
    -> [High Priority]
      -> AI Gateway (Urgent response)
      -> Gmail (Send immediately)
    -> [Normal Priority]
      -> MongoDB (Queue for later)

Example: Multi-Agent RAG Pipeline

Chat Trigger
  -> Embeddings (Generate query vector)
  -> Semantic Memory (Retrieve relevant documents)
  -> RAG Prompt Builder (Combine query with retrieved documents)
  -> LLM (Generate grounded response)
  -> Faithfulness Checker (Verify no hallucinations)
  -> Conditional (Check faithfulness score)
    -> [Pass] Chat Response (Return answer)
    -> [Fail] Reflection (Revise answer)
      -> Chat Response (Return revised answer)

Next Steps

• Configure workflow triggers
• Use AI agents in workflows
• Explore MCP tools
• See workflow examples