Bundles are vendor- or framework-specific component groups that appear as collapsible sections at the bottom of the Agentic Flow Builder sidebar.
Agentic Patterns
Multi-agent orchestration components for structured collaboration and task decomposition.
Agent Capability
Declares an agent’s capabilities for task routing in the orchestration system. Decomposers and orchestrators use these declarations to route work to the right agent.
Use in a flow
- Add one Agent Capability node per specialist agent in your pattern.
- Set Agent Name, Capabilities (comma-separated tags), Description, and System Prompt.
- Select Model Provider and Model ID for the agent that will run assigned tasks.
- Connect Capability Info to Agent Capabilities on Task Decomposer, Task Orchestrator, or Collaboration Orchestrator.
Agent Capability (Capability Info) ──► Task Decomposer
Agent Capability (Capability Info) ──► Task Orchestrator
Parameters
| Parameter | Default | Hidden | Description |
|---|---|---|---|
| Agent Name | — | No | Unique name for this agent (used when assigning and reporting tasks). Required. |
| Capabilities | — | No | Comma-separated capability tags (e.g., account_inquiry, transfers, balance). Required. |
| Description | — | No | What this agent specializes in; shown to decomposers when planning tasks. |
| System Prompt | You are a helpful assistant. | No | Instructions used when this agent executes an assigned task. Required. |
| Model Provider | — | No | LLM provider for this agent. Refresh to load options. Required. |
| Model ID | — | No | Model used when this agent runs a task. Required. |
| Region Name | — | No | Region where the selected model is available. |
| Model Kwargs | — | Yes | Additional keyword arguments passed to the model. |
Outputs
| Output | Description |
|---|---|
| Capability Info | Data object with agent name, capability tags, description, system prompt, and model configuration for routing. |
Limitations
- Tag matching — Task
required_capabilityvalues must align with tags on an Agent Capability node (or usegeneralas a fallback). - Orchestrator dependency — Capability nodes do not run tasks on their own; wire them into a decomposer and orchestrator to execute work.
Task Decomposer
Decomposes a complex user request into a directed acyclic graph (DAG) of sub-tasks using an LLM. Each sub-task is tagged with a required agent capability and optional dependencies on other tasks.
Use in a flow
- Add a Task Decomposer node to the canvas.
- Wire the user request into Input Request (from Input or upstream).
- Connect one or more Agent Capability nodes to Agent Capabilities.
- Select Model Provider and configure the decomposition model.
- Connect Task Graph to Task Orchestrator or Task Visualization.
Input ──► Task Decomposer ◄── Agent Capability (×N)
Task Decomposer (Task Graph) ──► Task Orchestrator
Parameters
| Parameter | Default | Hidden | Description |
|---|---|---|---|
| Input Request | — | No | The complex request to break into sub-tasks. Required. |
| Agent Capabilities | — | No | Connected Agent Capability outputs used for routing tags. |
| Model Provider | Amazon Bedrock | No | LLM provider used for decomposition. Required. |
| Decomposition Prompt | built-in default | Yes | System prompt for the decomposition LLM. Supports {capabilities} placeholder. |
Outputs
| Output | Description |
|---|---|
| Task Graph | Data object containing a flat DAG of tasks with descriptions, capability tags, dependencies, and complexity estimates. |
Limitations
- Capability tags — Without connected Agent Capabilities, all tasks use
general. - LLM output quality — Invalid JSON falls back to a single task containing the full request.
- DAG only — Task graphs must be acyclic; cycles are auto-flattened.
Task Orchestrator
Orchestrates task execution across multiple agents with dependency-aware scheduling, parallel execution, retry logic, automatic agent fallback, and targeted re-decomposition.
Use in a flow
- Add a Task Orchestrator node to the canvas.
- Connect Task Graph from Task Decomposer.
- Connect Agent Capability nodes to Agent Capabilities.
- Connect Orchestration Result to Output; optionally wire Executed Task Graph to Task Visualization.
Task Decomposer (Task Graph) ──► Task Orchestrator ◄── Agent Capability (×N)
Task Orchestrator (Orchestration Result) ──► Output
Parameters
| Parameter | Default | Hidden | Description |
|---|---|---|---|
| Task Graph | — | No | Task graph output from Task Decomposer. Required. |
| Agent Capabilities | — | No | Connected Agent Capability nodes used to match and execute tasks. |
| Max Retries | 2 | Yes | Maximum retries per task before marking it failed. |
| Task Timeout (seconds) | 120 | Yes | Maximum seconds allowed per task execution. |
| Enable Parallel Execution | true | Yes | Run independent ready tasks in parallel. |
| Enable Re-decomposition | true | Yes | Split failed tasks into smaller sub-tasks instead of stopping. |
Outputs
| Output | Description |
|---|---|
| Orchestration Result | Aggregated message with per-task results, assigned agents, and completion summary. |
| Executed Task Graph | Post-execution task graph with statuses, results, and assigned agents — suitable for Task Visualization. |
Hierarchical Decomposer
Breaks a complex user request into a hierarchical goal tree (Goals → Sub-goals → Tasks → Actions) using an LLM.
Use in a flow
- Add a Hierarchical Decomposer node to the canvas.
- Wire the user request into Input Request.
- Connect Agent Capability nodes to Agent Capabilities.
- Select Model Provider and Model ID.
- Connect Goal Tree to Collaboration Orchestrator.
Input ──► Hierarchical Decomposer ◄── Agent Capability (×N)
Hierarchical Decomposer (Goal Tree) ──► Collaboration Orchestrator
Parameters
| Parameter | Default | Hidden | Description |
|---|---|---|---|
| Input Request | — | No | The complex request to decompose. Required. |
| Agent Capabilities | — | No | Connected Agent Capability outputs used when assigning capabilities to leaf tasks. |
| Model Provider | — | No | LLM provider for decomposition. Required. |
| Model ID | — | No | Model used to generate the goal tree. Required. |
| Max Depth | 3 | No | Maximum hierarchy depth (1 = flat, 4 = full goal → sub-goal → task → action). |
| Output as TaskGraph | false | Yes | When enabled, flattens the goal tree into a task graph for Collaboration Orchestrator. |
Outputs
| Output | Description |
|---|---|
| Goal Tree | Data containing the hierarchical goal tree (or a flat task graph when Output as TaskGraph is enabled). |
Collaboration Orchestrator
Executes a task graph or goal tree by assigning each task to a matching agent. Supports Supervisor mode and Peer To Peer mode.
Use in a flow
- Add a Collaboration Orchestrator node to the canvas.
- Connect Goal Tree from Hierarchical Decomposer to Task Graph / Goal Tree.
- Connect Agent Capability nodes to Agent Capabilities.
- Choose Collaboration Mode and connect Orchestration Result to Output.
Hierarchical Decomposer (Goal Tree) ──► Collaboration Orchestrator ◄── Agent Capability (×N)
Collaboration Orchestrator (Orchestration Result) ──► Output
Parameters
| Parameter | Default | Hidden | Description |
|---|---|---|---|
| Task Graph / Goal Tree | — | No | Task graph or goal tree from a decomposer. Required. |
| Agent Capabilities | — | No | Connected Agent Capability nodes used to match and run tasks. |
| Collaboration Mode | supervisor | No | supervisor (LLM reviews between batches) or peer_to_peer (shared message bus). |
| Model Provider | — | No | LLM provider for the supervisor (supervisor mode only). |
| Model ID | — | No | Supervisor model (supervisor mode only). |
| Max Retries | 2 | Yes | Retries per task before marking it failed. |
| Task Timeout (seconds) | 120 | Yes | Maximum seconds per task execution. |
| Enable Parallel Execution | true | Yes | Run independent ready tasks in parallel. |
| Max Peer Messages | 20 | Yes | Maximum messages on the shared bus (peer-to-peer mode only). |
Outputs
| Output | Description |
|---|---|
| Orchestration Result | Summary message with per-task results and completion counts. |
| Executed Task Graph | Post-execution task graph with statuses, assigned agents, and results. |
Task Visualization
Renders a task graph or goal tree for inspection and monitoring. Output can be formatted as a markdown table or a Mermaid diagram.
Use in a flow
- Add a Task Visualization node to the canvas.
- Connect task graph or goal tree data to Task Graph.
- Choose Output Format (
markdownormermaid). - Connect Visualization to Output.
Task Orchestrator (Executed Task Graph) ──► Task Visualization ──► Output
Parameters
| Parameter | Default | Hidden | Description |
|---|---|---|---|
| Task Graph | — | No | Task graph or goal tree data to visualize. Required. |
| Output Format | markdown | No | markdown (table or indented tree) or mermaid (flowchart diagram). |
Outputs
| Output | Description |
|---|---|
| Visualization | Rendered graph as a message. Includes task statuses and per-task result blocks. |
Memories
Memory components provide persistent conversation history storage for agents across sessions.
PostgreSQL Chat Memory
Stores and retrieves conversation history from a PostgreSQL database for persistent memory across sessions.
Use in a flow
- Add a PostgreSQL Chat Memory node to the canvas.
- Set Session ID to scope history to a conversation.
- Connect Memory to an Agent memory input or Message History.
Input (Session ID) ──► PostgreSQL Chat Memory (Memory) ──► Agent
Parameters
| Parameter | Default | Hidden | Description |
|---|---|---|---|
| Table Name | message_history | Yes | PostgreSQL table used to store messages. Created automatically if it does not exist. |
| Session ID | — | Yes | Conversation session key. Falls back to default when empty. |
| Enable Retry | false | Yes | Retry database connection failures. |
| Max Retries | 3 | Yes | Maximum retry attempts. |
Outputs
| Output | Description |
|---|---|
| Memory | A chat message history backed by PostgreSQL. Downstream components use this to load prior turns and persist new messages. |
AWS AgentCore Memory
Stores and retrieves long-term and short-term memory using the AWS AgentCore Memory service.
Use in a flow
- Add an AWS AgentCore Memory node to the canvas.
- Enter Memory ID and Memory Strategy ID from your AgentCore Memory resource.
- Select Region and Memory Type.
- Connect AgentCore Memory to an Agent memory input.
AWS AgentCore Memory (AgentCore Memory) ──► Agent
Parameters
| Parameter | Default | Hidden | Description |
|---|---|---|---|
| Memory ID | — | No | AgentCore Memory resource ID (e.g., mem-xxxxxxxxxxxx). Required. |
| Memory Strategy ID | — | No | Strategy ID for namespace scoping. Required. |
| Region | us-east-1 | No | AWS region (us-east-1, us-west-2, eu-west-1, ap-northeast-1, ap-southeast-1). |
| Memory Type | Both | No | Long-term Only, Short-term Only, or Both. |
| Actor ID | — | No | Actor scope for memory. Defaults to flow ID when empty. |
| Max Results | 10 | Yes | Maximum records or events to retrieve. |
Outputs
| Output | Description |
|---|---|
| AgentCore Memory | Memory client wired into an Agent for storing and retrieving conversation context. |
Amazon / AWS
AWS components connect to Amazon Bedrock and AWS services for embeddings, document parsing, image generation, code execution, and storage.
Amazon Bedrock Embeddings
Generates text embeddings using workspace-enabled Amazon Bedrock embedding models.
Use in a flow
- Add an Amazon Bedrock Embeddings node to the canvas.
- Select Model Provider and Model ID.
- Connect Embeddings to a consumer (e.g., OpenSearch or Knowledge Retrieval).
Input ──► Amazon Bedrock Embeddings (Embeddings) ──► OpenSearch / Knowledge Retrieval
Parameters
| Parameter | Default | Hidden | Description |
|---|---|---|---|
| Input Message | — | No | Upstream message that triggers embedding generation. |
| Model Provider | — | No | Embedding model provider. Refresh to load options. Required. |
| Model ID | — | No | Embedding model to use. Required. |
| Region Name | — | No | Region where the selected model is available. |
Outputs
| Output | Description |
|---|---|
| Embeddings | An embeddings model instance for vectorizing text in downstream components. |
Amazon Intelligent Document Parser
Extracts structured data from documents and images using Amazon Bedrock Data Automation (BDA). Input files must already exist in S3.
Use in a flow
- Add an Amazon Intelligent Document Parser node to the canvas.
- Connect an Input Message with S3 file paths.
- Select AWS Bedrock BDA Region Name.
- Connect Parsed Content downstream.
Input (files in S3) ──► Amazon Intelligent Document Parser ──► Agent / Split Text
Parameters
| Parameter | Default | Hidden | Description |
|---|---|---|---|
| Input Message | — | No | Message with S3 file paths to parse. |
| AWS Bedrock BDA Region Name | us-east-1 | No | AWS region for Bedrock Data Automation (us-east-1 or us-west-2). |
| Wait for Completion | true | No | When enabled, waits for BDA to finish before returning. |
| Polling Interval | 5 | Yes | Seconds between status checks while waiting. |
| Max Wait Time | 300 | Yes | Maximum seconds to wait before timing out. |
Outputs
| Output | Description |
|---|---|
| Parsed Content | Extracted text as Data (combined markdown across pages or image summaries). |
AWS AgentCore Code Interpreter
Executes code using the AWS AgentCore managed code interpreter service. Run Python, JavaScript, or TypeScript in a secure sandbox.
Use in a flow
- Add an AWS AgentCore Code Interpreter node to the canvas.
- Choose Security (
sandboxorpublic). - Fill the fields for the action you need (Code Input, Command, file paths, etc.).
- Connect the matching output (e.g., Execute Code).
Input ──► AWS AgentCore Code Interpreter (Execute Code) ──► Output
Parameters
| Parameter | Default | Hidden | Description |
|---|---|---|---|
| Security | sandbox | No | sandbox (isolated) or public (shared environment). |
| Code Input | — | No | Code to run synchronously or in the background. |
| Language | python | No | python, javascript, or typescript. |
| Auto Manage Session | true | Yes | Automatically start and reuse a session. |
Outputs
| Output | Description |
|---|---|
| Execute Code | Run Code Input synchronously and return stdout/stderr. |
| Execute Command | Run a shell Command synchronously. |
| Write / Read / List / Remove Files | File management operations within the sandbox. |
| Start Background Code / Command | Run code or a command as a background task; returns a task_id. |
| Get Task / Stop Task | Check status of or cancel a background task. |
AWS Nova Image Generation
Generates images using Amazon Nova (and compatible Titan) models via Amazon Bedrock.
Use in a flow
- Add an AWS Nova Image Generation node to the canvas.
- Write a Prompt describing the image.
- Select Model Provider and Model ID.
- Connect Message to Output or downstream steps.
Prompt / Input ──► AWS Nova Image Generation (Message) ──► Output
Parameters
| Parameter | Default | Hidden | Description |
|---|---|---|---|
| Prompt | — | No | Text description of the image to generate. Required. |
| Model Provider | — | No | Image model provider. Required. |
| Model ID | — | No | Nova or Titan image model. Required. |
| Width | 1024 | No | Image width: 512 or 1024 pixels. |
| Height | 1024 | No | Image height: 512 or 1024 pixels. |
| Number of Images | 1 | Yes | How many images to generate (1–5). |
| CFG Scale | 8.0 | Yes | Prompt adherence (1.0–20.0). |
Outputs
| Output | Description |
|---|---|
| Message | Result message with generated image file paths attached. |
AWS Stability Image Generation
Generates images using Stability AI models via Amazon Bedrock.
Use in a flow
- Add an AWS Stability Image Generation node to the canvas.
- Write a Prompt, select Model Provider and Model ID, set Aspect Ratio.
- Connect Message to Output or downstream steps.
Prompt / Input ──► AWS Stability Image Generation (Message) ──► Output
Parameters
| Parameter | Default | Hidden | Description |
|---|---|---|---|
| Prompt | — | No | Text description of the image to generate. Required. |
| Model Provider | — | No | Image model provider. Required. |
| Model ID | — | No | Stability image model. Required. |
| Aspect Ratio | 1:1 | No | 1:1, 16:9, or 9:16. |
| Output Format | png | Yes | png or jpeg. |
Outputs
| Output | Description |
|---|---|
| Message | Result message with generated image file paths attached. |
S3 Bucket Uploader
Uploads files to a specified Amazon S3 bucket.
Use in a flow
- Add an S3 Bucket Uploader node to the canvas.
- Enter AWS Access Key ID, AWS Secret Key, and Bucket Name.
- Choose a Strategy for file upload.
- Connect Data Inputs from upstream file or data components.
File ──► S3 Bucket Uploader (Writes to AWS Bucket) ──► Output
Parameters
| Parameter | Default | Hidden | Description |
|---|---|---|---|
| AWS Access Key ID | — | No | AWS access key for the target bucket. Required. |
| AWS Secret Key | — | No | AWS secret key for the target bucket. Required. |
| Bucket Name | — | No | Destination S3 bucket name. Required. |
| Strategy for file upload | Store Data | No | Store Data (upload parsed text) or Store Original File (upload binary file). Required. |
| Data Inputs | — | No | One or more Data objects with file paths and content. Required. |
Outputs
| Output | Description |
|---|---|
| Writes to AWS Bucket | Completes the upload operation. |
LangChain
LangChain components provide character-based text splitting, natural-language CSV and SQL querying, database connections, and tool-calling agent patterns.
CharacterTextSplitter
Splits text into chunks using a character-based splitter.
Use in a flow
- Add a CharacterTextSplitter node to the canvas.
- Connect text or document data to Input.
- Set Chunk Size, Chunk Overlap, and optionally Separator.
- Connect the Data output to a vector store or embedding component.
File / Document Loader ──► CharacterTextSplitter ──► Embeddings / Vector Store
Parameters
| Parameter | Default | Description |
|---|---|---|
| Chunk Size | 1000 | Maximum length of each chunk in characters. |
| Chunk Overlap | 200 | Number of overlapping characters between consecutive chunks. |
| Input | — | The text or documents to split. |
| Separator | \n\n | Characters to split on. |
Outputs
| Output | Description |
|---|---|
| Data | The split text chunks as data objects. |
CSV Agent
A LangChain agent that reads and queries CSV files using natural language.
Use in a flow
- Add a CSV Agent node to the canvas.
- Connect a Language Model to the agent.
- Provide a File Path (upload a CSV or connect a path).
- Enter your question in Text.
- Connect Response to Chat Output or the next step.
Language Model ──► CSV Agent ──► Chat Output
CSV file ──► CSV Agent (File Path)
Parameters
| Parameter | Required | Description |
|---|---|---|
| Language Model | Yes | The LLM used to interpret questions and query the CSV. |
| File Path | Yes | The CSV file to analyze. |
| Text | Yes | The natural-language question to ask about the CSV data. |
Outputs
| Output | Description |
|---|---|
| Response | The agent’s answer as a message. |
SQL Agent
A LangChain agent that queries a SQL database using natural language.
Use in a flow
- Add a SQL Agent node to the canvas.
- Connect a Language Model to the agent.
- Enter the Database URI.
- Provide your question via Input.
- Connect Response to Chat Output or the next step.
Language Model ──► SQL Agent ──► Chat Output
Chat Input ──► SQL Agent (Input)
Parameters
| Parameter | Required | Description |
|---|---|---|
| Language Model | Yes | The LLM used to interpret questions and generate SQL. |
| Database URI | Yes | Connection string for the SQL database (e.g., postgresql://user:pass@host:5432/dbname). |
| Input | Yes | The natural-language question to ask about the database. |
Outputs
| Output | Description |
|---|---|
| Response | The agent’s answer as a message. |
SQLDatabase
Connects to a SQL database and exposes it as a connection object for LangChain components.
Note
SQL Agent vs SQLDatabase — SQL Agent takes a Database URI string directly. Use SQLDatabase only when another component expects a SQLDatabase connection object.
Parameters
| Parameter | Description |
|---|---|
| URI | The database connection string. Must be a valid SQLAlchemy-compatible URI. Required. |
Outputs
| Output | Description |
|---|---|
| SQLDatabase | A LangChain SQL database connection object. |
Tool Calling Agent
A LangChain agent that uses tool-calling capable language models to reason and act.
Use in a flow
- Add a Tool Calling Agent node to the canvas.
- Connect a Language Model that supports native tool calling.
- Connect tool sources (e.g., MCP Client) to Tools.
- Provide the user’s message via Input.
- Connect Response to Chat Output or the next step.
Chat Input ──► Tool Calling Agent ──► Chat Output
Language Model ──► Tool Calling Agent
MCP Client (Tools) ──► Tool Calling Agent
Parameters
| Parameter | Required | Description |
|---|---|---|
| Language Model | Yes | The LLM the agent uses. Must support native tool calling. |
| Tools | No | Tools the agent can call. |
| Input | Yes | The user’s message for the agent to process. |
| System Prompt | No | Instructions that guide the agent’s behavior. |
Outputs
| Output | Description |
|---|---|
| Response | The agent’s final answer as a message. |
XML Agent (Beta)
A LangChain-based agent that processes XML-structured inputs and tool responses.
Use in a flow
- Add an XML Agent node to the canvas.
- Connect a Language Model to the agent.
- Connect tool sources to Tools.
- Provide the user’s message via Input.
- Connect Response to Chat Output or the next step.
Chat Input ──► XML Agent ──► Chat Output
Language Model ──► XML Agent
Parameters
| Parameter | Required | Description |
|---|---|---|
| Language Model | Yes | The LLM the agent uses for reasoning and responses. |
| Tools | No | Tools the agent can call. |
| Input | Yes | The user’s message for the agent to process. |
| System Prompt | No | Instructions including {tools}, {input}, and {agent_scratchpad} placeholders. |
| Prompt | No | The user-message template. Must include {input}. |
Outputs
| Output | Description |
|---|---|
| Response | The agent’s final answer as a message. |
Limitations
- Beta — Behavior and fields may change.
- XML tool format — The model must follow the XML tag pattern in the system prompt for reliable tool use.
MCP
MCP bundle components connect the flow to MCP (Model Context Protocol) servers. These are the same components as in the main Integrations category, listed here for sidebar discoverability.
- MCP Client — Connects to an MCP server configured in your workspace.
- Public MCP Client — Connects to any publicly accessible MCP server by URL.
See Integrations for full parameter reference.
Red Hat
Red-Hat OpenAI Chat
Calls a Red Hat–hosted OpenAI-compatible chat endpoint and returns the response.
Use in a flow
- Add a Red-Hat OpenAI Chat node to the canvas.
- Fill in Endpoint URL, Bearer Token, and Model.
- Provide Message Content directly or connect from upstream.
- Connect Response to Chat Output or the next step.
Chat Input / Prompt ──► Red-Hat OpenAI Chat ──► Chat Output
Parameters
| Parameter | Default | Hidden | Description |
|---|---|---|---|
| Endpoint URL | — | No | The chat completions URL for your Red Hat OpenShift AI deployment. Required. |
| Bearer Token | — | No | Authentication token. Enter the token only — do not include the Bearer prefix. Required. |
| Model | gpt-oss-20b | No | The model name to use for the chat request. Required. |
| Message Content | — | No | The user message to send to the model. Required. |
| System Message | You are a helpful assistant | Yes | Instructions that set the assistant’s behavior. |
| Stream | false | Yes | When enabled, the response is streamed back incrementally. |
| Timeout | 200 | Yes | How long to wait for a response, in seconds. |
Outputs
| Output | Description |
|---|---|
| Response | The model’s reply as a message. |
Limitations
- Red Hat endpoint required — You must have a valid OpenShift AI endpoint URL and bearer token.
- OpenAI-compatible API — The endpoint must support the standard chat completions request format.