Agent Strategy defines how an intelligent agent node processes user requests, selects and invokes appropriate tools, and determines when a task is complete. It allows enterprises to customize decision-making logic and reasoning patterns through flexible configurations, enabling various reasoning modes such as Chain of Thought (CoT) and Tree of Thought (ToT) to address complex business needs.
System Strategy
GoInsight.AI offers two system strategies:
- ReAct Compact ExecutorA streamlined strategy optimized for structured tool execution. It employs a minimalist prompt template to ensure efficient API calls and concise JSON output, making it ideal for task automation and backend integration.
- ReAct Enhanced OratorAn advanced strategy that enriches the final response output through natural language expansion. This strategy enhances the prompt template, supports dynamic response formatting, context supplementation, and multi-turn dialogue logic, facilitating a human-like interaction experience.
In addition to the two system strategies provided by GoInsight.AI, you have the option to create custom agent strategies to suit your needs.
Creating a Custom Agent Strategy
1. Create an Agent Strategy
Step 1. In InsightFlow - Services & Tools, click the "Create" button in the upper right corner.
Step 2. Choose to create an agent strategy, and enter its name and description.
While creating an Agent Strategy, you can also manage its permissions to ensure compliance with enterprise requirements.
2. Orchestrate the Agent Strategy
Once you have created an Agent Strategy, you will automatically enter its orchestration canvas.
GoInsight.AI provides a template example of an Agent Strategy. This is a minimal runnable example of a ReAct agent, visually illustrating the "Think-Tool-Reflect" loop to aid in mastering agent strategy design:
- "Structured Thinking" Constraint
- Forces the large language model to output decisions in JSON format through prompts, allowing the AI's "thinking" to be parsed by workflows – laying the foundation for automatic tool invocation and error retry mechanisms.
- "Closed-Loop" Design
- Utilizes a loop node and multi-branch selection node to implement the ReAct automation process:
- → Large Language Model Decision: Choose "Answer Directly" / "Invoke Tool" / "Correct Error"
- → Parsing and Execution: Execute the corresponding logic based on the decision (output an answer/retry/invoke a tool)
- → Feedback Loop: Feed the results back to the large language model for reflection through query variables.
- This forms a complete automated "Think → Execute → Reflect" closed loop.
- Expand the Template as Needed
- Add Tools: Integrate internal enterprise tools (such as knowledge base searches or internal APIs) at the tool invocation node.
- Optimize Prompts: Fine-tune prompts for the large language model based on specific business scenarios to guide it toward making more aligned decisions.
- Complex Logic: Build advanced branches (for example, tool prioritization or multi-tool collaboration) to create sophisticated agents.
You can orchestrate and debug this template based on your needs to ensure it meets the expected logic, making it suitable for use in intelligent agent nodes.
The variables for the Start Node in the Agent Strategy are described as follows:
| Variable Name | Data Type | Description |
|---|---|---|
| FinalAnwser | String | Stores the agent's final output, either the answer or max iteration error. |
| UTCDate | String | The date when this workflow starts execution, in UTC, formatted as yyyy-MM-dd. |
| UTCTime | String | The time when this workflow starts execution, in UTC, formatted as HH:mm:ss. |
| $Model | Object | Specify the large language model to be called and its associated parameters (e.g., temperature). |
| $ToolNames | Array[String] | Set of tool names. |
| $Tools | Array[Object] | Collection of tools. |
| $Instruction | String | Define the agent's responsibilities and objectives to guide its behavior and response style. |
| $Query | String | Core query or task description the agent needs to process. |
| $MaxIterations | Number | Limit the agent's reasoning or tool-calling iteration cycles. |
| $Memory | Array[Object] | Provide contextual reference or previous reasoning results to enhance coherence and accuracy. |
| $WorkflowID | String | Workflow ID |
| $BatchId | String | Batch ID associated with this workflow execution. |
3. Publish & Reference the Agent Strategy
Step 1. After you have orchestrated and debugged the Agent Strategy, you can click the "Publish Agent Strategy" button in the menu bar above.
Step 2. Then, you can set the following content for publishing the Agent Strategy:
- Name and description of the Agent Strategy once published
- Usage: Define the variable descriptions for the input and output variables in the Agent Strategy
- Permissions: Specify who can use this Agent Strategy. Including "Make public within organization", or "Custom any groups/team members".
Step 3. After publishing the Agent Strategy, you can select it in the Agent Node.
Conclusion
The integration of Agent Strategy with Agent Node provides enterprises with highly flexible and intelligent solutions. By selecting the appropriate Agent Strategy in the Agent Node, organizations can ensure that each task is processed optimally. This configuration not only enhances the automation of workflows but also improves the system's responsiveness and adaptability. Benefits like:
- Optimize Task Processing: By selecting the appropriate agent strategy, ensure that each task is handled optimally.
- Improve Automation Levels: Enhance the automation and intelligence of workflows, improving system responsiveness.
- Flexible Customization: Allow organizations to customize and extend according to specific business needs.
- Efficient Operation: Ensure effective operation in dynamic environments and optimize business process management.