AI Agents in Workflows

Strongly AI provides three categories of AI-powered workflow nodes: AI nodes for model inference, Agent nodes for autonomous reasoning and multi-agent patterns, and Memory nodes for persistent state and retrieval. Together these enable sophisticated AI workflows from simple LLM calls to fully autonomous multi-agent systems.

AI Nodes

AI nodes connect your workflows to language models and other AI capabilities through the AI Gateway.

LLM

Node type: llm. The primary node for calling language models for text generation, summarization, extraction, classification, and question answering. Model calls are routed through the AI Gateway.

Inputs:

Input	Type	Required	Description
userPrompt	string	Yes	The user message/prompt to send to the AI model
systemPrompt	string	No	System message to guide AI behavior
temperature	number	No	Temperature value (0-2) to control randomness
maxTokens	number	No	Maximum number of tokens to generate
responseFormat	string	No	Set to json_object for clean structured JSON extraction (no markdown fences)

Outputs:

Output	Type	Description
response	string	The AI model's text response
model	object	Model info: id, name, provider, type, contextWindow, maxOutputTokens
usage	object	Token usage: promptTokens, completionTokens, totalTokens
finishReason	string	Why generation stopped (stop, length, etc.)
responseTimeMs	number	Response time in milliseconds

Configuration:

Setting	Description
AI Model	Select from available models via model-selector (chat, multimodal, or realtime types)
Default Temperature	Default temperature if not provided via input (0-2, default: 0.7)
Default Max Tokens	Default max tokens if not provided via input (1-8000, default: 1000)
Default System Prompt	Default system message if not provided via input
Default User Prompt	Default user prompt if not provided via input mapping
Info Only	Return model capabilities without making an LLM call
Response Format	text (default) or json_object for parseable JSON output; overridden by the responseFormat input

Accessing Output: downstream nodes read LLM output through their input mappings using data.-prefixed paths, for example:

{
  "inputMappings": {
    "text": "data.response",
    "tokens": "data.usage.totalTokens"
  }
}

Learn more about AI Gateway models -->

Embeddings

Generate vector embeddings from text for semantic search and similarity operations.

Inputs:

Input	Type	Description
text	string	Single text to embed
texts	array	Array of texts to embed (batch)

Outputs:

Output	Type	Description
embeddings	array	Array of embedding vectors
model	string	Model used
usage	object	Token usage statistics
dimensions	number	Embedding dimensions
count	number	Number of embeddings generated
responseTimeMs	number	Response time in ms

Configuration:

Setting	Description
Embedding Model	Select an embedding model via model-selector
Dimensions	Override dimensions (0 = model default, max 4096)

Vision

Analyze images and visual content using vision-capable AI models (GPT-4V, Claude Vision, etc.).

Inputs:

Input	Type	Required	Description
image	string	Yes	Image URL (http/https) or base64-encoded image data
prompt	string	Yes	Text prompt describing what to analyze
systemPrompt	string	No	System message to guide AI behavior
temperature	number	No	Temperature value (0-2)
maxTokens	number	No	Maximum tokens to generate

Outputs: Same structure as AI Gateway (response, model, usage, responseTimeMs).

Configuration: model-selector (vision-capable model), defaultTemperature, defaultMaxTokens, defaultSystemPrompt, defaultPrompt.

Image Generation

Generate images from text prompts with async job-based processing.

Inputs:

Input	Type	Required	Description
prompt	string	Yes	Text prompt describing the image to generate
negativePrompt	string	No	What to avoid in the generated image

Outputs:

Output	Type	Description
images	array	Generated images with url or b64_json
jobId	string	Async job ID (if applicable)
model	string	Model used for generation
revisedPrompt	string	Model-revised prompt (if applicable)
responseTimeMs	number	Total response time in ms

Configuration:

Setting	Description
AI Model	Select an image generation model via model-selector
Image Size	Vendor-native size string (e.g. 1024x1024, 1792x1024, 1024x1792 for DALL-E 3). Leave blank for the vendor's default
Quality	Vendor-native quality token (e.g. standard / hd for DALL-E 3). Leave blank for the vendor's default
Number of Images	1-4 (default: 1)
Style	Vendor-native style token (e.g. vivid / natural for DALL-E 3). Leave blank for the vendor's default
Poll Interval	500-10000 ms for async jobs (default: 2000)
Max Wait	10-600 seconds (default: 120)
Default Prompt / Default Negative Prompt	Defaults used when not provided via input

Speech to Text

Transcribe audio to text using AI speech recognition models (Whisper, etc.).

Inputs:

Input	Type	Required	Description
audio	string	No	Base64-encoded audio data (provide this OR audioPath)
audioPath	string	No	Path to audio file from previous node
language	string	No	Language code hint (e.g. 'en', 'es', 'fr')
prompt	string	No	Context hint to guide transcription

Outputs:

Output	Type	Description
text	string	Transcribed text from the audio
language	string	Detected or specified language code
duration	number	Audio duration in seconds
segments	array	Timestamped segments (verbose_json format only)

Configuration:

Setting	Description
Transcription Model	Select a transcription model
Language	Language code hint (leave empty for auto-detection)
Response Format	JSON, Plain Text, SRT (Subtitles), VTT (Web Subtitles), Verbose JSON (with segments)
Transcription Prompt	Context hint with domain-specific terms

Text to Speech

Convert text to speech audio via AI Gateway.

Inputs:

Input	Type	Required	Description
text	string	Yes	Text to convert to speech

Outputs:

Output	Type	Description
audioPath	string	Path to cached audio file
format	string	Audio format (mp3/opus/aac/flac/wav)
voice	string	Voice used
inputLength	number	Input text length
audioSize	number	Audio file size in bytes
model	string	Model used
responseTimeMs	number	Response time in ms

Configuration:

Setting	Description
AI Model	Select a text-to-speech model via model-selector
Voice	Vendor-native voice identifier (e.g. alloy / echo / nova for OpenAI, a hex voice id for ElevenLabs, Aoede / Puck for Gemini). Leave blank for the vendor's default voice
Speed	0.25 - 4.0 (default: 1)
Voice Settings	Optional vendor synthesis settings passed through to the TTS provider (e.g. ElevenLabs stability / similarity_boost)
Audio Format	MP3 (default), Opus, AAC, FLAC, WAV
Default Text	Default text used when not provided via input

---

Agent Nodes

Agent nodes provide autonomous reasoning, multi-agent collaboration, and specialized AI-powered processing. Most agent nodes connect to an AI Gateway via a bottom "ai" dependency connector, and optionally to MCP tools providers and memory nodes.

Connector Pattern

Most agent nodes have three bottom dependency connectors:

• AI (bottom-left) -- Connect to an AI Gateway node for LLM reasoning
• Memory (bottom-center) -- Connect to a memory node for persistent state
• Tools (bottom-right) -- Connect to an MCP Tools Provider for external tool access

                  [Agent Node]
                  /    |    \
              [AI]  [Memory] [Tools]

ReAct Agent

Autonomous AI agent using the ReAct (Reasoning + Acting) pattern. Iteratively thinks, acts using tools, and observes results until the goal is achieved.

Inputs:

Input	Type	Required	Description
task	string	Yes	The goal or task for the agent to accomplish
context	string	No	Additional context to help the agent
tools	array	No	Available tools (can also come from connected tool nodes)

Outputs:

Output	Type	Description
finalAnswer	string	The agent's final response
success	boolean	Whether the agent achieved its goal
stopReason	string	Why the agent stopped (e.g. goal_achieved)
iterations	number	Number of think-act-observe cycles completed
toolsCalled	array	List of tools executed with arguments and results
trajectory	array	Complete trajectory of think/act/observe steps
totalTokens	number	Total tokens used across all AI calls

Configuration:

Setting	Default	Description
Max Iterations	10	Maximum think-act-observe cycles (1-50)
System Prompt	--	Additional instructions for agent behavior
Stop Patterns	"FINAL ANSWER:", "Task completed", "I have completed"	Patterns indicating task completion
Temperature	0.7	Creativity level for reasoning (0-1)
Max Tokens per Call	2000	Maximum tokens for each AI reasoning call (100-8000)
Token Budget	unlimited	Maximum total tokens to use
Heartbeat Enabled	false	Enable scheduled autonomous wake-ups to process pending tasks
Heartbeat Schedule	0 * * * *	Cron expression for the heartbeat (shown when heartbeat is enabled)
Heartbeat Timezone	UTC	IANA timezone for the heartbeat schedule

Dependencies: AI (required), Tools (optional), Memory (optional).

Agent Loop

Configurable autonomous think-act-observe agent loop. Similar to the ReAct Agent but with additional control over stop conditions.

Inputs:

Input	Type	Required	Description
goal	string	Yes	The goal for the agent to accomplish
tools	array	No	Available tool definitions
context	string	No	Additional context

Outputs:

Output	Type	Description
finalAnswer	any	The agent's final response
success	boolean	Whether goal was achieved
stopReason	string	Why the agent stopped
iterations	number	Number of think iterations
toolsCalled	array	Tools that were executed
trajectory	array	Full think/act/observe trajectory
totalTokens	number	Total tokens used

Configuration:

Setting	Default	Description
Max Iterations	10	Maximum iterations (1-100)
System Prompt	--	Custom system prompt
Stop Patterns	"FINAL ANSWER:", "Task completed"	Patterns that halt the loop
Stop Condition	Pattern Match	Pattern Match, Token Budget, or Max Tool Calls
Token Budget	0 (unlimited)	Total token limit
Temperature	0.7	Temperature (0-2)
Max Tokens Per Call	2000	Tokens per AI call (100-8000)
Output Format	Text	Text or JSON
Inject Library Rules (pre-turn)	false	Before each think step, fetch your applicable Library Rules and prepend them as a system message
Gate tool calls via Library Rules	false	Check each tool call against Library Rules before execution; blocked calls are skipped and recorded as violations
Rules membership ids	--	Optional agent/workflow ids whose rules apply (defaults to user-general rules)

Dependencies: AI (required), Tools (optional), Memory (optional).

Supervisor Agent

Orchestrates multiple sub-agents to accomplish complex tasks. Creates execution plans, delegates work, and synthesizes results. Similar to CrewAI and AutoGen patterns.

Inputs:

Input	Type	Required	Description
task	string	Yes	The complex task requiring multi-agent collaboration
context	string	No	Additional context for the supervisor
agents	array	No	Agent definitions (can also come from connections)
tools	array	No	Tool definitions (can also come from mcp-tools-provider)

Outputs:

Output	Type	Description
finalResult	string	Synthesized result from all agents
agentResults	object	Individual results from each agent
executionPlan	array	The execution plan that was followed
success	boolean	Whether all required tasks completed
agentsUsed	number	Number of agents used
failedAgents	number	Number of agents that failed

Configuration:

Setting	Default	Description
Orchestration Mode	Adaptive (AI decides)	Adaptive, Sequential, Parallel, or Hierarchical
Supervisor Instructions	--	Additional instructions for supervisor behavior
Synthesize Results	true	Combine all agent outputs into a coherent final answer
Max Retries	2	Maximum retries for failed agent tasks (0-5)

Dependencies: AI Gateway (required), Sub-Agents (optional), Tools (optional).

Multi-Agent Chat

Multiple AI personas collaborate on a shared discussion thread.

Inputs:

Input	Type	Required	Description
topic	string	Yes	Discussion topic
context	string	No	Additional context
agents	array	No	Agent definitions (objects with name, role, systemPrompt)

Outputs:

Output	Type	Description
transcript	array	Full discussion transcript
finalConsensus	string	Synthesized conclusion
roundsCompleted	number	Rounds completed
terminationReason	string	Why discussion ended
agentCount	number	Number of agents

Configuration:

Setting	Default	Description
Max Rounds	5	Maximum discussion rounds (1-20)
Termination Condition	Fixed Rounds	Fixed Rounds, Consensus Detected, or Keyword Match
Termination Keyword	CONSENSUS_REACHED	Keyword to end discussion
Enable Moderator	false	Add a moderator to guide discussion
Temperature	0.7	Temperature (0-2)

Dependencies: AI Gateway (required).

Debate Agent

Multi-agent debate pattern for reaching consensus through structured argumentation, critique, and synthesis.

Inputs:

Input	Type	Required	Description
topic	string	Yes	The topic or question to debate
context	string	No	Background information for the debate
agents	array	No	Agent configurations (optional, can use connected agents)

Outputs:

Output	Type	Description
conclusion	string	Synthesized conclusion from the debate
converged	boolean	Whether agents reached natural consensus
totalRounds	number	Number of debate rounds executed
debateHistory	array	Full history of debate rounds and arguments
votes	object	Voting results from agents
consensusReached	boolean	Whether consensus was achieved
agentCount	number	Number of agents that participated

Configuration:

Setting	Default	Description
Debate Mode	Structured	Structured (Propose/Critique/Rebut), Round Robin, Free Form, or Adversarial
Max Rounds	3	Maximum debate rounds (1-10)
Convergence Threshold	0.8	Agreement level to stop early (0.5-1.0)
Synthesize Conclusion	true	Generate a final synthesized conclusion
Enable Voting	true	Have agents vote on conclusions

Dependencies: AI Gateway (required), Debaters/Sub-Agents (optional).

Planner

Decompose complex goals into ordered sub-tasks with dependencies.

Inputs:

Input	Type	Required	Description
goal	string	Yes	Goal to decompose into tasks
context	string	No	Additional context
capabilities	array	No	Available tools/capabilities

Outputs:

Output	Type	Description
plan	array	Ordered list of sub-tasks with dependencies
reasoning	string	Planning reasoning
criticalPath	array	Critical path task IDs
totalTasks	number	Total number of tasks

Configuration:

Setting	Default	Description
Planning Strategy	Flat	Flat (single decomposition), Hierarchical (phases then tasks), or Iterative (plan then refine)
Max Sub-tasks	10	Maximum sub-tasks (3-20)
Include Complexity Estimates	true	Add complexity estimates to tasks
Temperature	0.3	Temperature (0-1)
System Prompt	--	Custom planning instructions

Dependencies: AI Gateway (required).

Reflection

Self-review and iterative content improvement via critique-revise cycles.

Inputs:

Input	Type	Required	Description
content	string	Yes	Content to reflect on and improve
originalPrompt	string	No	Original prompt that generated the content
criteria	array	No	Override evaluation criteria

Outputs:

Output	Type	Description
revisedContent	string	Final improved content
originalContent	string	Original content before revision
reflections	array	Array of critique-revise cycles
improvementScore	number	Score improvement from first to last
finalScore	number	Final evaluation score (0-1)
totalRevisions	number	Number of revisions performed

Configuration:

Setting	Default	Description
Evaluation Criteria	accuracy, completeness, coherence	Criteria tags for evaluation
Custom Criteria	--	Free-text custom criteria
Max Revisions	2	Maximum revision cycles (1-5)
Auto-Accept Threshold	0.8	Score threshold to auto-accept (0-1)
Temperature	0.3	Temperature (0-1)

Dependencies: AI Gateway (required).

RAG Prompt Builder

Node type: rag (Operators category). Builds Retrieval Augmented Generation prompts by combining user queries with retrieved documents from vector search. Pair it with an LLM node downstream to generate the final answer.

Inputs:

Input	Type	Required	Description
retrievedDocs	array	Yes	Documents retrieved from vector search
query	string	No	Query override (uses config if not provided)

Outputs:

Output	Type	Description
rag_prompt	string	Formatted prompt with context and query
query	string	The original query
docs_used	number	Number of documents included in context
context_length	number	Character count of the context

Configuration:

Setting	Default	Description
Query	--	User question to answer (required)
Top K Documents	5	Number of documents to include in context

This is a standard input/output node with no bottom dependency connectors.

Entity Extraction

LLM-powered entity extraction agent. Extracts named entities from documents using configurable entity type definitions with descriptions and examples. This is NOT a traditional NER system -- it uses an LLM to identify entities based on your definitions.

Inputs:

Input	Type	Required	Description
filename	string	Yes	Path to document file (.md, .html, or .txt)

Outputs:

Output	Type	Description
entities	object	Extracted entities grouped by type (always present)
documents	array	Per-document extraction stats (annotated output mode only)
summary	object	Extraction summary (annotated output mode only)

Configuration:

Setting	Description
Entities to Extract	Array of entity type definitions, each with name, description, examples, and output format (string/normalized/structured)
Output Mode	Flat List, Grouped by Type (default), or With Position Info
Confidence Threshold	Minimum confidence score (0-1, default: 0.7)
Validate Entities	Verify extracted entities exist in document text using LLM correction (default: on)
Max Output Tokens	Upper bound on tokens generated per chunk (64-8000, default: 2000)
Max Extraction Calls per Document	Hard cap on total LLM calls for one document (0 = auto)

Dependencies: AI (required), Memory (optional), Tools (optional).

Document Classification

LLM-powered document classification agent. Classifies documents into configurable labels using an LLM with keyword hints.

Inputs:

Input	Type	Required	Description
filename	string	Yes	Path to document file (.md, .html, or .txt)

Outputs:

Output	Type	Description
classifications	array	Array of results with filename, label, confidence, alternativeLabels, keywords, metadata, processingTime
summary	object	Summary with totalDocuments, labelDistribution, averageConfidence, processingTime
passThroughValues	object	Pass-through values from input

Configuration:

Setting	Description
Classification Labels	List of labels (e.g., Invoice, Contract, Receipt, Report, Other)
Keywords per Label	JSON mapping of labels to keyword arrays for classification hints
Confidence Threshold	Minimum confidence score (0-1, default: 0.7)

Dependencies: AI (required), Memory (optional), Tools (optional).

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.

Inputs:

Input	Type	Required	Description
rows	array	Yes	Array of row objects with source column names (sample of 5-10 rows)
headers	array	No	Source column names (inferred from rows if not provided)
filename	string	No	Source filename for context (passed through)
file	string	No	File path to pass through to downstream nodes
parsedTableKey	string	No	Cache key from table-parser

Outputs:

Output	Type	Description
columnMappings	object	Column mapping dictionary (target column --> source column)
success	boolean	True if mapping meets confidence threshold
confidenceScores	object	Confidence score (0-1) for each mapping
overallConfidence	number	Average confidence across all mappings
needsReview	boolean	True if any mappings are low confidence
usedCache	boolean	True if cached mapping was used instead of LLM
mappingCacheKey	string	Cache key for this mapping lookup

Configuration:

Setting	Description
Target Schema	Array of target columns with name, description, type, required flag, and examples
Confidence Threshold	Minimum confidence for successful mappings (0-1, default: 0.7)
Sample Size	Number of sample rows to send to LLM (1-20, default: 5)
Use Known Mappings	Use cached mappings from database if available (default: true)
Always Find New	Always use LLM even if cached mapping exists (default: false)
Memory Collection	Collection name for storing cached mappings (default: column_mappings)

Dependencies: AI (required), Memory (optional), Tools (optional).

Data Cleanup Agent

Uses LLM to validate and fix malformed data rows from PDF extraction. Detects shifted columns, merged values, and data type mismatches.

Inputs:

Input	Type	Required	Description
current_item	object	Yes	Row data to validate and clean
mappings	object	No	Column mappings from column-mapper node

Outputs:

Output	Type	Description
current_item	object	Cleaned row data (or original if no issues)
data_quality	string	Quality status: valid, cleaned, invalid, unfixable
was_cleaned	boolean	True if the row was modified by LLM
validation_issues	array	List of detected data quality issues
original_issues	array	Issues that were fixed (when was_cleaned is true)

Configuration:

Setting	Description
Date Columns	Column names that should contain date values
Numeric Columns	Column names that should contain numeric values
Validate Only	If enabled, only detect issues without fixing them

Dependencies: AI (required), Memory (optional), Tools (optional).

Web Agent

Node type: web-agent. Autonomous web agent. Given a natural-language task and a start URL, an LLM writes and runs Playwright browser automation code in a sandboxed environment to complete multi-step web tasks, returning the result plus a re-runnable script.

Inputs: task (string, required) -- natural-language description of the web task; startUrl (string, optional) -- URL to open first.

Outputs: result (final answer), success, stepCount, trajectory, generatedScript (re-runnable Playwright script), screenshots (cached screenshot paths).

Configuration: Max Steps (1-100, default: 30), Timeout (30-1800 seconds, default: 300), Capture Screenshots (default: on), Return Generated Script (default: on), Temperature (0-1, default: 0.7).

Dependencies: AI (required) -- connect an LLM node; the selected model drives the web agent.

PII Redactor Agent

Node type: pii-redactor. Detects PII in a text file via a connected AI Gateway model and applies per-type actions (redact / mask / label / pseudonymize / keep). Reads the source file, writes a redacted file back, and emits a metadata audit describing every detection.

Inputs: filename (string, required) -- path to a text file in the workflow file cache.

Outputs: file (path of the redacted file), filename (original basename), metadata (full audit of every detection and action), summary (total plus per-type and per-action counts).

Configuration: Detection Mode (model via the connected AI model, regex pattern list, or both), Regex Patterns, PII Types (each with a name, description, and action), Emit Redaction Values (include plaintext values for chaining into pdf-redactor; off by default for privacy), Emit Detection Values, Case-Insensitive Matching, Normalize Whitespace.

Dependencies: AI (required for model/both modes), Memory (optional), Tools (optional).

PII Redactor (Qwen Few-Shot)

Node type: pii-redactor-qwen. Few-shot variant of the PII Redactor designed for the Qwen 1B fine-tuned PII model. Same input/output shape as the standard PII Redactor, but the prompt includes user-supplied few-shot examples so the model adapts to your domain's PII patterns without retraining.

Configuration: Few-Shot Examples (example text plus expected detections), Qwen Label Mapping (maps model output labels to your PII type names), Detection Mode (model / regex / both), Regex Patterns, Emit Redaction Values, PII Types with per-type actions.

Dependencies: AI (required), Memory (optional), Tools (optional).

PII Detector (LLM)

Node type: pii-detector-llm. Pure detection, no redaction. Detects PII spans in a text file via any LLM that emits OpenPipe-compatible XML tags, and outputs the unique values list for a downstream redactor (e.g. pdf-redactor custom keywords). An optional inline regex pass merges into the same output list.

Configuration: LLM Label Mapping (maps model output labels to your PII type names, required), Detection Mode (model / regex / both), Regex Patterns, PII Types (the policy gate -- detections mapped to types not in this list are dropped), Confidence Threshold.

Dependencies: AI (required), Memory (optional), Tools (optional).

PII Redaction Validator

Node type: pii-redaction-validator. LLM-as-judge filter over upstream PII detections. Takes a candidate list from any detector that emits {type, value, start, end} plus the source text, asks the connected LLM whether each candidate is real PII in context, and drops the ones the judge rejects.

Configuration: Validation Prompt (required; must contain the {candidates} placeholder), Decision Format (json or tagged), missing-verdict policy (strict drop or lenient keep), Context Window size, Judge Concurrency (parallel judge calls per document, default: 4), Max Detections per Batch, Chunk Size, and an optional under-redaction recall pass that scans the document for PII the upstream detectors missed.

Dependencies: AI (required).

Function Call Extractor

Node type: function-calling (Operators category). Extracts and parses function/tool calls from AI responses.

Inputs:

Input	Type	Required	Description
aiResponse	object	Yes	Response from AI containing function calls
availableFunctions	array	No	List of available functions the AI can call

Outputs:

Output	Type	Description
function_calls	array	Extracted function calls from AI response
call_count	number	Number of function calls extracted

Configuration:

Setting	Description
Available Functions	JSON list of functions to validate extracted calls against

This is a standard input/output node with no bottom dependency connectors.

Tool Router

Node type: tool-router (Operators category). LLM-based dynamic tool selection for a given task. Analyzes a task and selects the best tools from a list of available options.

Inputs:

Input	Type	Required	Description
task	string	Yes	Task or query to route
tools	array	Yes	Available tools (objects with name, description)

Outputs:

Output	Type	Description
selectedTools	array	Selected tools (objects with name, confidence, reasoning)
totalAvailable	number	Total available tools
strategy	string	Routing strategy used

Configuration:

Setting	Default	Description
Routing Strategy	LLM-based	Keyword (no LLM), LLM-based, or Hybrid (keyword + LLM)
Max Selections	3	Maximum tools to select (1-10)
Confidence Threshold	0.5	Minimum confidence for selection (0-1)
Temperature	0.2	Temperature (0-1)

Dependencies: AI Gateway (optional, required for LLM and hybrid strategies).

Agent Handoff

Node type: agent-handoff (Operators category). Package and transfer context between agent nodes. Supports full pass-through, LLM-compressed summary, or selective field extraction.

Inputs:

Input	Type	Required	Description
currentState	any	Yes	Current agent's state/results
conversationHistory	array	No	Conversation history
nextAgentInstructions	string	No	Instructions for next agent

Outputs:

Output	Type	Description
handoffPackage	object	Packaged context for next agent
strategy	string	Strategy used
originalSize	number	Original context size
compressedSize	number	Packaged size
compressionRatio	number	Compression ratio

Configuration:

Setting	Default	Description
Handoff Strategy	Full	Full (pass everything), Summary (LLM-compressed), or Selective (specific fields)
Selective Fields	[]	Fields to extract (dot notation supported)
Summary Max Tokens	500	Max tokens for LLM summary (100-2000)
Include Key Findings	true	Include key findings in handoff

Dependencies: AI Gateway (optional, required for Summary strategy).

---

Memory Nodes

Memory nodes provide persistent state, conversation history, vector storage, and cross-agent communication for your workflows.

Knowledge Base

Graph knowledge store -- entities and relationships in Neo4j. For vector/embedding search use the Semantic Memory node instead. Supports query, store, update, delete, and connect operations.

Operations:

Operation	Description
Query	Text search over stored entities (contains match)
Store	Store entities with optional relationships
Update	Update existing entity properties
Delete	Remove an entity
Connect Entities	Create relationships between entities

Key Inputs:

Input	Type	Description
entity	object	Entity to store in the graph
relationships	array	Relationships to create
query	string	Text search query
entityId	string	Entity ID for update/delete
updates	object	Fields to update
sourceEntity / targetEntity	string	Entities to connect
relationship	string	Relationship type for connect

Key Outputs:

Output	Type	Description
success	boolean	Whether operation succeeded
results	array	Query results
entity_id	string	Entity ID (store/update operations)
neo4j_stored	boolean	Stored in Neo4j
neo4j_count	number	Result count from Neo4j
total_count	number	Total results count

Configuration:

Setting	Default	Description
Connection Type	Add-on	Neo4j add-on connection
Neo4j Add-on	--	Select the Neo4j add-on for graph storage (required)
Operation	Query	Query, Store, Update, Delete, or Connect Entities
Query	--	Text search query (contains match on stored data)
Max Results	10	Maximum results (1-10000)

Semantic Memory

Vector store with embedding-based retrieval via Milvus. Requires an AI Gateway connection for generating embeddings.

Inputs:

Input	Type	Description
text	string	Text to store
query	string	Search query
metadata	object	Additional metadata
id	string	Document ID (for delete)

Outputs:

Output	Type	Description
results	array	Search results (objects with text, metadata, similarity)
count	number	Number of results
storedId	string	ID of stored document
success	boolean	Operation success

Configuration:

Setting	Default	Description
Operation	Search	Store, Search, or Delete
Milvus Add-on	--	Select Milvus add-on (required)
Collection Name	semantic_memory	Milvus collection name
Embedding Dimensions	1536	Embedding vector dimensions
Top K Results	5	Number of results (1-100)
Temporal Decay	false	Apply time-based decay to similarity scores (exponential half-life)
Decay Half-Life (days)	30	Days for a score to decay by half (1-365)

Dependencies: AI (required, for generating embeddings).

Context Buffer

Manage working memory and context windows with configurable strategies for handling token limits.

Inputs:

Input	Type	Description
operation	string	Operation: store, retrieve, clear
data	any	Data to store in context buffer
query	string	Query string for filtering context
lastN	number	Number of recent entries to retrieve
metadata	object	Additional metadata for stored data

Outputs:

Output	Type	Description
context	string	The assembled context text
tokenCount	number	Tokens in the assembled context
messagesIncluded	number	Number of messages included
compressed	boolean	Whether older content was compressed

Configuration:

Setting	Default	Description
Max Tokens	4000	Maximum tokens in context (100-128000)
Buffer Strategy	Sliding Window	Sliding Window, Summarize Old Content, or Keep Important Content
Compression Ratio	0.3	How much to compress when summarizing (0.1-1)
Preserve System Messages	true	Always keep system messages in context
Preserve Recent Entries	3	Most-recent entries kept verbatim; only older history is compressed or dropped
Buffer Size	10	Maximum items in buffer (1-1000)
Operation	Retrieve	Store, Retrieve, or Clear
Query	--	Text query to filter context items during retrieval

Working Memory

Short-term key-value scratchpad with TTL (time-to-live) support for temporary state during workflow execution.

Inputs:

Input	Type	Description
key	string	Key for the entry
value	any	Value to store
ttl	number	Time-to-live in seconds

Outputs:

Output	Type	Description
value	any	Retrieved value
found	boolean	Whether key was found
success	boolean	Operation success
key	string	Key operated on
keys	array	All keys (list operation)
entriesCount	number	Current entry count

Configuration:

Setting	Default	Description
Operation	Get	Set, Get, Update, Delete, List All, or Clear All
Max Entries	100	Maximum entries (1-10000)
Default TTL	0 (no expiry)	Default time-to-live in seconds

Episodic Memory

Store and retrieve past workflow experiences via MongoDB. Useful for agents that learn from previous executions.

Inputs:

Input	Type	Description
task	string	Task description (for recording)
decisions	array	Decisions made
outcome	string	Episode outcome
success	boolean	Whether episode was successful
query	string	Search query (for retrieval)
filter	object	MongoDB filter (for search)
episodeMetadata	object	Additional metadata

Outputs:

Output	Type	Description
episodes	array	Retrieved episodes
count	number	Number of episodes returned
episodeId	string	ID of recorded episode
success	boolean	Operation success

Configuration:

Setting	Default	Description
Operation	Retrieve Recent	Record Episode, Retrieve Similar, Retrieve Recent, or Search
Connection Type	Data Source	Data Source or Add-on (MongoDB)
Database	memory	MongoDB database name
Collection	workflow_episodes	Collection name
Max Episodes	10	Maximum episodes to return (1-100)
Temporal Decay	false	Apply time-based decay to relevance scores (exponential half-life)
Decay Half-Life (days)	30	Days for a score to decay by half (1-365)

Memory Retriever

Meta-node that queries multiple memory sources and merges/ranks results. Connect up to 3 memory sources as dependencies.

Inputs:

Input	Type	Required	Description
query	string	Yes	Search query across memory sources

Outputs:

Output	Type	Description
results	array	Ranked results from all sources
totalResults	number	Total results returned
sourcesQueried	number	Number of sources queried
sourceBreakdown	object	Results count per source
rankingStrategy	string	Strategy used

Configuration:

Setting	Default	Description
Ranking Strategy	Relevance	Relevance, Recency, or Hybrid (relevance + recency)
Max Results	10	Maximum results (1-100)
Source Weights	(empty)	JSON weights per source (e.g., {"memory_1": 1.0, "memory_2": 0.8})
Temporal Decay	true	Apply time-based decay to scores (exponential half-life)
Decay Half-Life (days)	30	Days for a score to decay by half (1-365)

Dependencies: Memory Source 1 (required), Memory Source 2 (optional), Memory Source 3 (optional).

Shared Blackboard

Cross-agent shared key-value state via MongoDB. Enables multiple agents in a workflow to read and write shared state organized by sections.

Inputs:

Input	Type	Description
section	string	Section name
key	string	Key name
value	any	Value to write
since	string	ISO timestamp for subscribe operation

Outputs:

Output	Type	Description
value	any	Retrieved value
found	boolean	Whether key was found
sectionData	object	All data in section
changes	array	Changes since last read
success	boolean	Operation success
entriesCount	number	Number of entries

Configuration:

Setting	Default	Description
Operation	Read	Write, Read, Subscribe (get changes), or Clear Section
Board ID	(empty = workflow-scoped)	Board identifier
Connection Type	Data Source	Data Source or Add-on (MongoDB)
MongoDB Data Source / Add-on	--	Select the MongoDB data source or add-on backing the board
Database	memory	MongoDB database name

---

Key Workflow Patterns

Agent + LLM + MCP Tools Pattern

The most common agent pattern connects three nodes via the agent's bottom dependency connectors:

          [Trigger] --> [ReAct Agent] --> [Output]
                            |   |   |
                         [AI]  [M] [Tools]
                          |          |
                        [LLM]  [MCP Tools Provider]

1. The agent's ai port connects to an LLM node for reasoning
2. The agent's tools port connects to an MCP Tools Provider for external tool access
3. The agent's memory port connects to any memory node for state persistence

Agent Loop Pattern

The ReAct Agent and Agent Loop nodes follow an iterative think-act-observe cycle:

1. THINK  - Analyze the current situation and decide next action
2. ACT    - Call a tool or produce a response
3. OBSERVE - Process the tool result
4. REPEAT  - Continue until goal achieved or limits reached

The loop terminates when:

• A stop pattern is matched in the response (e.g., "FINAL ANSWER:")
• Maximum iterations are reached
• Token budget is exhausted
• An error occurs

Multi-Agent Patterns

Supervisor Pattern:

[Trigger] --> [Supervisor Agent] --> [Output]
                  |    |    |
               [AI] [Agents] [Tools]
                      |
            +---------+---------+
            |         |         |
        [Agent A] [Agent B] [Agent C]

The supervisor creates a plan, delegates to sub-agents, and synthesizes results.

Debate Pattern:

[Trigger] --> [Debate Agent] --> [Output]
                  |    |
               [AI] [Agents]
                      |
            +---------+---------+
            |         |         |
        [Agent A] [Agent B] [Agent C]

Multiple agents debate a topic through structured rounds until consensus.

Handoff Pattern:

[Trigger] --> [Agent A] --> [Agent Handoff] --> [Agent B] --> [Output]

Context is packaged and transferred between specialized agents.

RAG (Retrieval Augmented Generation) Pattern

[Trigger] --> [Semantic Memory (search)] --> [RAG Prompt Builder] --> [LLM] --> [Output]

1. Search semantic memory (Milvus) for documents relevant to the user query
2. RAG Prompt Builder combines the query with the retrieved documents into a single prompt
3. The LLM node generates the final answer with that context

Memory-Augmented Agent Pattern

[Trigger] --> [Context Buffer (retrieve)] --> [ReAct Agent] --> [Context Buffer (store)] --> [Output]
                                                  |
                                                [LLM]

1. Retrieve prior context from the Context Buffer
2. Agent uses that context for reasoning
3. The new exchange is stored back to the buffer

---

Best Practices

Model Selection

• Use smaller/faster models for simple classification or extraction tasks
• Use larger models for complex reasoning, planning, and multi-step tasks
• Set appropriate maxTokens limits to control costs

Agent Configuration

• Start with low maxIterations (5-10) and increase if tasks are under-completing
• Use specific systemPrompt instructions to guide agent behavior
• Add stopPatterns that match your expected output format
• Set token budgets to prevent runaway costs

Memory Usage

• Use Working Memory for temporary scratch state within a single execution
• Use Context Buffer to assemble conversation context under a token limit
• Use Semantic Memory for vector-based retrieval (requires Milvus add-on)
• Use Episodic Memory for learning from past workflow runs
• Use Shared Blackboard when multiple agents need to coordinate via shared state
• Use Memory Retriever to query across multiple memory sources at once

Error Handling

• Check the success output from agent and memory nodes
• Use the stopReason output from agent nodes to determine why an agent terminated
• Set maxRetries on Supervisor Agent for resilience
• Monitor totalTokens output to track costs

Next Steps

• Explore MCP tools
• Test AI workflows
• Deploy to production
• See AI workflow examples