Overview
The Agent Caller node enables you to execute other agents within your workspace while passing data between them. This node acts as a bridge, allowing you to build modular agent architectures where specialized agents can be called and reused across different contexts. The target agent must contain Data Input nodes to receive data and Data Output nodes to return results.
Input Configuration
Select Agent to Run
Choose the target agent to execute:
Purpose: Identify which agent in your workspace to execute
Selection Method: Use the dropdown to browse available agents
Default State: Shows "Select Agent" until an agent is chosen
Agent Requirements: Target agent must contain Data Input and/or Data Output nodes for data exchange
Agent Execution Mode
Control how the agent execution integrates with the current agent:
Return after Agent:
Purpose: Execute the target agent and return its output to continue the current agent
Behavior: Waits for target agent completion and retrieves results
Use Case: When you need the target agent's output for further processing
Trigger Only:
Purpose: Execute the target agent without waiting for output or return data
Behavior: Starts target agent execution and immediately continues current agent
Use Case: When triggering background processes or fire-and-forget operations
Data Exchange Configuration
File Input Section
Pass file data to the target agent:
File Input Field: Upload or connect files to pass to Data Input nodes in the target agent
Connection Point: Can receive file data from other agent nodes
Target Mapping: Files are passed to corresponding Data Input nodes in the called agent
File Types: Supports various file formats depending on target agent requirements
Data Input Section
Pass text or structured data to the target agent:
Data Field: Enter text, JSON, or other structured data to pass to the target agent
Connection Point: Can receive data from other agent nodes
Format Flexibility: Accepts various data formats as required by target agent's Data Input nodes
Multiple Inputs: If target agent has multiple Data Input nodes, data is distributed accordingly
Output Configuration
File Output Section
File Output Display: Shows file outputs returned from Data Output nodes in the executed agent
File Access: Retrieved files can be downloaded or passed to other nodes
Multiple Files: Displays all files returned by the target agent's Data Output nodes
Agent Results
Output Display: Shows text and data results from the target agent's execution
Data Format: Preserves original format and structure of returned data
Multiple Outputs: If target agent has multiple Data Output nodes, all outputs are displayed
Processing Status: Indicates execution progress and completion
Execution Control
Run Agent Button
Location: Top-right corner of the interface
Function: Initiates execution of the selected target agent
Data Passing: Automatically passes configured input data and files to target agent
Output Retrieval: Collects and displays results when execution completes
Agent Architecture Requirements
Target Agent Setup
Data Input Nodes: Target agent must contain Data Input nodes to receive data from Agent Caller
Data Output Nodes: Target agent must contain Data Output nodes to return results to Agent Caller
Node Mapping: Multiple Data Input/Output nodes in target agent correspond to multiple inputs/outputs in Agent Caller
Agent Design: Target agents should be designed with clear input/output interfaces for reusability
Data Agent Process
Input Distribution: Agent Caller distributes input data to all Data Input nodes in target agent
Agent Execution: Target agent processes using provided input data
Output Collection: Agent Caller collects results from all Data Output nodes in target agent
Result Display: Retrieved outputs are displayed in corresponding sections
Best Practices
Agent Design
Modular Architecture: Design target agents as reusable modules with clear input/output interfaces
Documentation: Document expected input formats and output structures for target agents
Error Handling: Implement error handling in target agents to provide meaningful feedback
Testing: Test agent calling relationships thoroughly before production use
Data Management
Input Validation: Ensure input data matches target agent's expected format and structure
Output Processing: Plan for handling various output types and potential error conditions
Data Size: Consider data volume limitations and processing time for large datasets
Format Consistency: Maintain consistent data formats across related agents
Performance Considerations
Execution Mode: Choose appropriate execution mode based on whether you need return data
Agent Complexity: Consider target agent execution time and resource requirements
Parallel Execution: Plan for cases where multiple Agent Caller nodes execute simultaneously
Resource Management: Monitor system resources when calling computationally intensive agents
Integration Considerations
Agent Orchestration
Agent Dependencies: Map dependencies between agents to avoid circular references
Execution Order: Plan execution sequences for complex multi-agent operations
State Management: Consider how data state is maintained across agent boundaries
Error Propagation: Plan how errors in target agents should affect calling agents
Use Cases
Data Processing Pipelines: Break complex processing into specialized, reusable agents
Microservice Architecture: Implement agent-based microservices with clear interfaces
Template Agents: Create reusable template agents for common operations
Conditional Processing: Execute different agents based on input conditions or business logic
Background Tasks: Trigger long-running processes without blocking main agent execution
Security Considerations
Access Control: Ensure appropriate permissions for cross-agent execution
Data Privacy: Consider data sensitivity when passing information between agents
Agent Isolation: Design agents to prevent unintended data leakage between executions
Audit Trail: Track agent execution relationships for compliance and debugging
The Agent Caller enables sophisticated agent orchestration patterns, allowing you to build scalable, modular automation systems with clear separation of concerns and reusable components.