Workflow Nodes

Start → API Call → Transform → Condition → End
                                   ↓
                              Error Handler

​

Node Types

​

Start Node

​

Key Capabilities

• Input variables: Define the data the workflow accepts at runtime.
• Output variables: Specify variables to capture workflow results.
• Event triggers: Automatically run the workflow when a specific event occurs in a connected app (for example, a new Gmail message).
• Scheduled execution: Run the workflow at a fixed time or on a recurring schedule.

​

Add Event-Based Triggers

• Set up an integration connection in Settings > Integrations.
• Create an authorization profile in Settings > Security & Control > Authorization Profiles.

1. Click Add Trigger in the Start node panel.
2. Select the integration app.
3. Enable the trigger and select a connection.
4. Choose the trigger event and configure its parameters.
5. Save and test the workflow.

​

Supported Third-Party Services for Triggers

​

Configure a Schedule

1. Click the Schedule icon in the Start node panel and enable the scheduler.
2. Set the frequency.
3. Configure the start date, start time, and time zone.

​

Accessing Inputs in Downstream Nodes

​

Troubleshooting

​

End Node

​

Configuration

1. Click the + icon on any node or drag End from the Assets panel onto the canvas.
2. Click the node to open its properties.
3. Enter a Custom Name.
4. In Name (key), select a key from the Manage Output section.
5. In Value, enter the context variable to map. Example: {{context.steps.summarization.output}}.

• At least one output variable is required for every End node.
• To return multiple outputs, click Add a Key and configure each additional key-value pair.

​

Delay Node

​

Configuration

​

API Node

​

Key Capabilities

• Protocols: REST and SOAP.
• Methods: GET, POST, PUT, DELETE, PATCH.
• Auth: Pre-authorized tokens or per-user runtime authorization.
• Modes: Synchronous or asynchronous.
• Body formats: JSON, XML, Form URL Encoded, Custom.
• Testing: Preview API responses before finalizing the setup.

​

Common Use Cases

• Data enrichment — fetch user, order, or product details.
• Document retrieval from third-party storage.
• Webhook triggers based on workflow decisions.
• Approval checks — identity verification, fraud checks, compliance validation.
• Sending alerts or updating external dashboards.

​

Configuration

• Pre-authorize the integration — Use system-level credentials shared across all users.
• Allow users to authorize — Each user authenticates at runtime (for example, Google Drive access).

​

Accessing Output

{{context.steps.APINodeName.output}}
{{context.steps.APINodeName.output.status}}

​

Integration Node

​

Key Capabilities

• No-code integration: Embed prebuilt third-party actions without custom code.
• Secure connections: Uses tested and authenticated service connections.
• Auto-generated JSON: Prebuilt payloads from action parameters.
• Visual configuration: Configure directly on the canvas.

​

Common Use Cases

• CRM and marketing automation — trigger campaigns when a lead is captured.
• Workflow automation across apps — create a project task when a ticket is raised.
• Payment gateway processing.
• SaaS tool integrations (CRM, email, e-commerce).

​

Prerequisites

​

Configuration

1. Click Integration > + New Integration in the Assets panel, or drag the node onto the canvas.
2. Search or select the required service.
3. Click the node to open its properties. Enter a Node Name (letters and numbers only).
4. Select an active Connection Name.
5. Click Add Action and select one action (only one action per node is supported).
6. Fill in the action parameters and click Save.
7. Set On Success and On Failure paths under Connections.

​

Managing Actions

​

Accessing Output

{{context.steps.IntegrationNodeName.output}}

​

Function Node

​

Key Capabilities

• Write Code: Author inline scripts in the built-in editor.
• Custom Function: Invoke a function from a deployed script library.
• Languages: JavaScript (supports async/await) and Python (synchronous).
• Memory access: Read and write Agent Memory stores for stateful logic.

​

Common Use Cases

• Data transformation and format conversion.
• Custom validation and business rule logic.
• Mathematical calculations and statistical analysis.
• String manipulation and regex operations.

​

Option 1 — Write Code

1. Select Write Code and click the Expand icon to open the script editor.
2. Select JavaScript or Python.
3. Use context variables for dynamic inputs.
4. Click Run to test the script.

• Static inputs: Type values directly in the script editor.
• Dynamic inputs: Use context variable syntax to reference inputs from the Start node or previous nodes.

const order = context.steps.FetchOrder.output;
const transformed = {
  id: order.order_id,
  total: order.items.reduce((sum, item) => sum + item.price, 0),
  itemCount: order.items.length,
  formattedDate: new Date(order.created_at).toLocaleDateString()
};
return transformed;

order = context["steps"]["FetchOrder"]["output"]
transformed = {
    "id": order["order_id"],
    "total": sum(item["price"] for item in order["items"]),
    "item_count": len(order["items"]),
    "status": order["status"].upper()
}
return transformed

​

Option 2 — Custom Function

1. Select Custom Function and choose a deployed script from the Script name list. Only deployed scripts are listed.
2. Choose a function from the Function name list (one function per node).
3. Map input arguments — assign static or dynamic values to each argument. Select the correct data type (String, Number, JSON, Boolean). Type {{ to trigger context variable suggestions.
4. Click Test, enter values in the Input panel, then click Execute.

• Output: Shows the result key from the function and the function run ID.
• Error: Shows stderr logs if the execution fails.
• Logs: Shows stdout and stderr for debugging.

• On import, the Function node’s configuration is fetched automatically.
• If the same script is already deployed in the target environment, the node links automatically.
• If the script isn’t deployed, validation errors appear listing unresolved scripts.
• On export, the node configuration is included in callflow.json.

​

Extending the Context Object

// JavaScript
context.userTier = "premium";
context.enrichedOrder = {
  orderId: context.steps.FetchOrder.output.id,
  isHighValue: context.steps.FetchOrder.output.total > 1000,
  processedAt: new Date().toISOString()
};

# Python
context['userTier'] = 'premium'
context['enrichedOrder'] = {
    'orderId': context['steps']['FetchOrder']['output']['id'],
    'isHighValue': context['steps']['FetchOrder']['output']['total'] > 1000
}

​

Agent Memory Access

# Read from memory
retrieved = memory.get_content(memory_store_name="my-notes", projections={"note": 1})

# Write to memory
memory.set_content(memory_store_name="my-notes", content={"note": "Updated.", "timestamp": "2025-05-15T10:00:00Z"})

# Delete
memory.delete_content(memory_store_name="my-notes")

​

Accessing Output

{{context.steps.FunctionNodeName.output}}
{{context.steps.FunctionNodeName.error}}

​

Supported Script Libraries

​

Condition Node

​

Key Capabilities

• Condition types: IF, ELSE IF, and ELSE.
• Operators: ==, !=, >, <, >=, <=, contains, startsWith, endsWith.
• Logic combinators: AND or OR for multi-criteria conditions.
• Dynamic references: Context variables and previous node outputs.

​

Common Use Cases

• Route based on classification, type, or priority.
• Fallback logic when no match is found.
• Validate data before proceeding.
• Multi-step filtering with combined conditions.

​

Configuration

1. Add the Condition node to the canvas.
2. Enter a descriptive Node Name.
3. Set the IF condition:
   • Enter a context variable (example: {{context.ambiguous_sub_categories}}).
   • Choose an operator.
   • Enter a value or another variable (example: {{context.steps.NodeName.output}}).
   • Optionally combine criteria with AND / OR.
4. Set routing:
   • Go To: Node to execute if the IF condition is met.
   • ELSE: Node to execute if no condition is met.

// AND
context.steps.Order.amount > 100 && context.steps.Order.status === "pending"

// OR
context.steps.User.tier === "premium" || context.steps.Order.amount > 500

​

Loop Node

​

Key Capabilities

• Array iteration: Execute child nodes once per item in an input array.
• Flexible child nodes: Add Function, API, AI, and Condition nodes inside the loop.
• Output aggregation: Collect per-iteration results into an output array.
• Three error handling strategies: Continue, Terminate, or Remove Failed.
• Debug support: Per-iteration inspection in the Debug panel.

​

Common Use Cases

• Batch processing — invoices, documents, records.
• API calls on multiple inputs — fetch data per customer ID.
• Bulk notifications — personalized messages to a list.
• Report generation per item in a dataset.
• Automated testing across multiple input variations.

​

Configuration

• Click the + on the loop start node.
• Drag nodes into the loop block on the canvas.
• Reference the current iteration item using {{currentItem}}.

​

Error Handling Options

​

Accessing Output

{{context.steps.LoopNodeName.output}}
// Returns: [result1, result2, result3, ...]

​

Debug Logs

​

Troubleshooting

​

AI Nodes

​

Text to Text Node

​

Key Capabilities

• Prompt options: Write your own prompt, or choose from the Prompt Hub with version selection.
• Model selection: Choose from pre-configured LLM models.
• Hyperparameter tuning: Temperature, Top-p, Top-k, Max Tokens.
• Structured output: Optional JSON schema for parseable responses.
• Workflow calling: Enable the model to call up to 3 workflows during execution.
• Timeout: 30–180 seconds (default: 60s).

​

Common Use Cases

• Summarization — transcripts, logs, documents.
• Tone or style adjustment.
• Keyword-based content generation.
• Content rewriting and reformatting.
• Error explanation and log analysis.

​

Configuration

• System Prompt: Sets the model’s role. Example: “You are a helpful assistant.”
• Human Prompt: The task or question. Example: “Summarize this error log.” Use {{context.variable_name}} for dynamic values.

• If the prompt includes variables, map them in the Map Variables field.
• If the prompt has no variables, customize it manually — the Map Variables field does not appear.
• Importing a prompt also loads the preferred model and connection if specified at commit time.

​

Accessing Output

{{context.steps.AINodeName.output}}

​

Text to Image Node

​

Key Capabilities

• Positive Prompt: Define what the image should include — style, elements, setting.
• Negative Prompt: Specify what to exclude from the image.
• Aspect Ratio: Up to 2048 × 2048 pixels (GPU-dependent).
• Steps: Refinement iterations — 25–30 recommended for quality and performance.
• Batch Count: Up to 5 image variants per run, generated sequentially.
• Output: PNG format returned as URLs (no expiry).

​

Supported Models

​

Common Use Cases

• Marketing banners, ads, and promotional visuals.
• Content illustration for blogs or newsletters.
• Visual prototyping — UI mockups, storyboards.
• A/B testing with multiple image variants.

​

Configuration

​

Accessing Output

{{context.steps.TextToImageNodeName.output}}
// Returns PNG image URL(s)

​

Audio to Text Node

​

Prerequisites

​

Key Capabilities

• Model: OpenAI Whisper-1.
• Multilingual: Transcribes multiple languages; translates non-English audio to English.
• Input: Audio file URL only — direct file uploads are not supported. Max file size: 25 MB.
• Timestamps: Optional; records when each dialog segment was spoken.
• Structured output: Optional JSON schema.

​

Supported Formats

​

Configuration

• Files larger than 25 MB must be split at logical points — avoid mid-sentence breaks.
• Inverse translation (English to other languages) is not supported.
• Only URLs are supported as input — direct file uploads are not supported.
• Whisper automatically removes offensive and banned words during transcription.

​

Accessing Output

{{context.steps.AudioToTextNodeName.output}}

​

Image to Text Node

​

Prerequisites

​

Key Capabilities

• OCR: Extract embedded text from scanned documents, screenshots, and photos.
• Image understanding: Answer questions or generate descriptions from images using prompts.
• Multi-model: OpenAI and Anthropic models supported.
• Structured output: Optional JSON schema for parseable responses.

​

Supported Models

• OpenAI: gpt-4o, gpt-4o-mini
• Anthropic: Claude Sonnet Vision

​

Supported Image Formats

​

Configuration

• Anthropic: binary, base64-encoded.
• OpenAI: binary, base64-encoded, and image URLs.

​

Accessing Output

{{context.steps.ImageToTextNodeName.output}}

​

DocSearch Node

​

Key Capabilities

• RAG-powered: Combines document retrieval with LLM-generated responses.
• Search AI integration: Connects to a configured Search AI app to query indexed content.
• Dynamic queries: Accepts static text or context variables as input.
• Meta filters: Optionally narrow search scope to specific documents or sources.
• User redirection: Optionally redirect users to the full Search AI app for a more comprehensive search experience.

​

Common Use Cases

• Retrieve relevant policies, manuals, or help articles based on user queries.
• Context-aware Q&A grounded in indexed documents.
• Internal knowledge base search — wikis, technical docs, training material.

​

Setup Prerequisites

• Configure a Search AI application and enable the Answer Generation API scope. See Create and Manage JWT Apps.

• Go to Settings > Integrations > Search AI > Add Connection.
• Enter the Search AI app credentials (use https://platform.kore.ai for the Search AI URL).
• Click Test to verify the connection, then click Save.

​

Configuration

​

Accessing Output

{{context.steps.DocSearch.response.response.answer}}
// Path may vary — check the sample Search AI response for the correct key.

​

Human Node

​

Key Capabilities

• Inbox-based routing: Sends approval requests to the reviewer’s Inbox (Personal or Group tab).
• Reviewer assignment: Route to all workspace members or specific users.
• Timeout handling: Set a timeout duration or wait indefinitely.
• Four outcome paths: On Approval, On Decline, On Timeout, On Failure.

​

Common Use Cases

• Approval workflows — expenses, leave requests, procurement.
• Quality assurance checkpoints before publishing AI-generated output.
• Compliance review for sensitive or regulated steps.
• Exception handling and escalation for edge cases.

​

How It Works

• Sync mode: Workflow pauses and waits for a reviewer response within the endpoint timeout.
• Async mode: Workflow sends an immediate acknowledgement, continues execution, and resumes once the reviewer responds or the timeout is reached.

​

Configuration

• Everyone — sends the request to all workspace members.
• Specific Users — enter the email addresses of specific members within the current workspace.

• No timeout — waits indefinitely until the reviewer responds.
• Set timeout — default 120 seconds; configurable in seconds, minutes, hours, or days.

​

Testing the Flow with Inbox Approvals

1. Click Run Flow in the workflow builder. The Debug Panel opens.
2. When the workflow reaches the Human node, an approval request is sent to the reviewer’s Inbox:
   • Personal tab — requests assigned to yourself.
   • Group tab — requests assigned to a set of users or the whole workspace. Group members must assign the request to themselves before acting on it.
3. In the Inbox, find the request under Pending for Approval. Review the details and click Approve or Decline.
4. Verify results in Workflow Monitor — confirm the Human node shows the correct approval status and the flow followed the expected path.

​

Accessing Reviewer Responses

// Full response payload
{{context.steps.NodeName.output}}

// Specific field
{{context.steps.NodeName.output.Approval}}
{{context.steps.NodeName.output.Comments}}

​

Agentic App Node

​

Key Capabilities

• Native integration: Connect workflows to any Agentic App within the same workspace.
• Contextual data exchange: Pass workflow inputs to the Agentic App and retrieve its response dynamically.
• Single-turn execution: Performs one turn of communication per execution. For multi-step interactions, add multiple Agentic App nodes.

​

Common Use Cases

• Incident triage: Pass incident details to the Agentic App to identify probable root causes and return remediation steps.
• Invoice processing: Send invoice details to determine the expense category, detect duplicates, or route for approval.

​

Prerequisites

• The Agentic App must be deployed.
• The Agentic App must belong to the same workspace as the workflow.
• The user configuring the node must have access to the Agentic App.

​

Configuration

• On Success: Node to execute after the Agentic App responds.
• On Failure: Node to execute if the Agentic App call fails.

​

Accessing Output

{{context.steps.AgenticAppNodeName.output}}

​

Browser Automation Node

​

Key Capabilities

• Run deployed automations: Select from the list of published browser automations in your workspace.
• Input and output mapping: Provide static values or map context variables. Outputs are stored automatically in the workflow context.
• Built-in reliability: Retries, timeouts, and visual validation for consistent execution.
• Secure credential handling: Uses secure browser sessions without exposing sensitive data.

​

Common Use Cases

• Form filling and data entry across web-based systems.
• Portal-based processes — claims submission, onboarding, invoice updates.
• Web data extraction — capturing tables and values from pages.
• File uploads and downloads across internal or external websites.
• Routine account actions — login, status checks (MFA not required).

​

Setup Overview

1. Deploy the hardware in Settings > Browser Automation > Deployment. This pod is the execution environment for both Playground testing and workflow runtime.
2. Create the automation in Settings > Browser Automation > Playground. Validate the flow step by step, then publish the automation to a pod.
3. Integrate in a workflow using the Browser Automation Node.

​

Configuration

• In Automation name, choose from the list of published browser automations in your workspace.
• Only one automation per node. If none are deployed, you are prompted to create one first.

• After selecting an automation, the required input fields appear based on the automation’s design.
• Each field accepts a static value or a mapped context variable from the workflow.

​

Accessing Output

{{context.steps.BrowserNodeName.output}}

​

Testing the Flow

1. Test in Playground first: Go to Settings > Browser Automation > Playground, run the automation, and validate browser actions and outputs.
2. Run the workflow: Verify inputs are passed correctly, the automation triggers, and outputs are captured in the context.
3. Review Debug Logs: Check the Browser Automation Node section for step-by-step execution details, output values, and errors.

​

Doc Intelligence Node

​

Key Capabilities

• Engine selection: Choose between Docling, OpenAI, Anthropic, or Azure.
• File input flexibility: Static URL or dynamic workflow context variable.
• Async processing: Processes documents in the background without blocking the workflow (engine support may vary).
• Structured data extraction: Generates machine-readable output for downstream nodes (engine support may vary).

​

Common Use Cases

• Invoice and receipt processing — extract amounts, dates, and vendor information.
• Identity document verification — extract data from IDs, passports, or business cards.
• Contract analysis — identify key clauses, dates, or parties.
• Compliance checks — ensure sensitive documents are analyzed and key fields are captured.

​

Configuration

1. Give the node a descriptive name (example: InvoiceProcessing, IDExtraction).
2. Enter the File URL — a static URL or a context variable from an upstream step.
3. Select the Engine.
4. Configure engine-specific options.

​

Accessing Output

{{context.steps.DocNodeName.output}}

​

Related Topics

• Supported Libraries - List of supported libraries in the script editor of the Function node.