# Astron Workflow

You design, connect, automate.
Astron Workflow keeps it running.

# 1. Astron Workflow Core Advantages

# 2. How to Use Astron Workflow Platform

# 2.1 Development of Prompt Agents

# 2.1.1 Function Overview

Quickly configure prompts to build instruction-based agents in just a few clicks.

Ideal for lightweight conversational scenarios such as copywriting, story creation, text translation, and AI image generation — while also supporting knowledge base integration, H5 page publishing, and API-based output for external systems.

# 2.1.2 Agent Creation

After entering the Astron Workflow platform, click Create on the left panel, then select Prompt Creation from the pop-up dialog. Enter a one-sentence description in the dialog that appears, and click Create Agent to enter the instruction-based agent setup page, where developers can configure detailed agent settings.

The following section explains how to create an Prompt agent.

# 2.1.2.1 Basic Information Filling

Setting up a Prompt Agent requires four mandatory fields:

Agent Name, Agent Category, Agent Description, and Agent Avatar.

To provide users with clear guidance on how to use the agent, it's recommended to fill out this information as completely as possible.

# 2.1.2.2 Prompt Editing

The content in the dialog box serves as the input instructions for the large language model, and how these instructions are configured directly affects the agent's performance. Prompt editing consists of three key fields:

Role, Task, and Reply Requirements.

Details are as follows:

# 2.1.2.3 Advanced Settings

Advanced Settings define capabilities beyond basic role-based conversation, including Knowledge Base and Conversation Enhancement. These settings help improve the agent's usability and conversational performance.

# 2.1.3 Debug Preview, and Publish

The platform supports debugging an agent while it's being created. On the agent settings page, developers can write prompts and test their effects in real time, refining the prompt until satisfied with the results.

Prompt Agents can be published as embeddable web pages — you can embed the agent as an iframe into your own website.

# 2.1.4 Prompt and Model Comparison & Tuning

# 2.1.4.1 Prompt Comparison

Prompt comparison involves designing multiple sets of different prompts and comparing their effects on model output (e.g., accuracy, relevance, logical coherence) in order to optimize prompts and achieve results that better meet expectations. This process is essential in LLM applications, as it directly impacts the quality of model responses.

To use this feature:

Click the Prompt Comparison button. Two prompt editing boxes will appear on the pop-up page — a Default Prompt and a Comparison Prompt.

Users can edit and modify the prompts as needed to test the agent's performance under different prompt configurations. Once testing is complete, select the preferred prompt to finalize the comparison.

# 2.1.4.2 Model Comparison

The Model Comparison feature allows developers to test multiple models in parallel. By directly comparing the response quality of different models, developers can select the best-performing model to optimize the agent's responses.

To use this feature:

Click the Model Comparison button — two models will appear by default. Up to four models can be compared simultaneously. Click the Add Model button in the top-right corner to add additional models as needed.

Once the models are selected, enter test content in the input field to compare how the same input performs across different models, helping you choose the model best suited to your needs.

# 2.2 Development of Workflow Agents

# 2.2.1 Function Overview

Workflow Agents orchestrate multiple task nodes into a coherent process, enabling automated handling of a wide range of business scenarios. Nodes cover stages such as data input, processing, and output, working together to build workflows that are both efficient and flexible.

Once a workflow is complete, the Workflow Agent can be published as an embeddable web page or published as an API with one click, allowing for quick integration into your own business systems.

Typical use cases include:

• Boosting Office Efficiency: Quickly build workflows and applications for office, healthcare, and innovation scenarios — such as knowledge-based intelligent customer service systems, technical support agents combining knowledge and tools, campus student assistant agents, and hospital triage and consultation agents.
• Bringing Creative Ideas to Life: Build Workflow Agents for lightweight office, lifestyle, and entertainment scenarios — such as daily industry news briefing agents, picture book creation agents, and various casual game agents.

# 2.2.2 Agent Creation

After entering the Astron Workflow platform, click Create on the left panel, then select Workflow Creation from the pop-up dialog.

Workflow Agent creation supports two methods:

1. Custom Creation: Provides a blank canvas, allowing users to build a Workflow Agent from scratch according to their own needs.
2. Template Creation: The platform offers a rich library of templates, allowing users to replicate similar functionality with one click. This enables developers with zero coding experience to quickly complete workflow orchestration for even complex tasks.

This guide uses Custom Creation as an example to walk through the process of building a complete Workflow Agent. On the pop-up page, select Custom Creation to begin building your workflow from scratch.

# 2.2.2.1 Basic Information Filling

After selecting Custom Creation and entering the blank canvas, click the Edit icon in the top-left corner to configure the workflow's basic information. This includes two mandatory fields — Workflow Name and Workflow Description — and one optional field, Workflow Category.

# 2.2.2.2 Advanced Settings

Click the Setting icon in the top-right corner of the canvas to access Advanced Settings, which define capabilities beyond basic conversational interaction. These settings help improve the agent's usability and conversational performance.

Details are as follows:

# 2.2.2.3 Workflow Orchestration

The system automatically creates a Start Node and an End Node. Developers only need to modify the relevant code or node logic according to their specific needs to build a complete workflow.

# 2.2.2.4 Version History

Click the Version History button in the top-right corner of the canvas to view previous versions in the pop-up page. You can switch between historical versions as needed.

# 2.2.2.5 Comparison Testing

Before running a comparison test, the workflow must first be bound to a prompt group. Click the Test Comparison button in the top-right corner of the canvas to perform comparison testing in the pop-up page.

# 2.2.2.6 Exporting and Importing Workflows

To facilitate the sharing and transfer of Workflow Agents, the platform provides convenient export and import functionality.

Please note: if a workflow includes custom tools, knowledge bases, or self-built models, these components will not be directly usable after import. Users will need to recreate the corresponding custom tools, or rebuild the knowledge base and self-built models, to ensure the workflow runs properly.

(1) Exporting a Workflow

On the My Agents page, locate the corresponding Workflow Agent, then select Export in the bottom-right corner to complete the export. Exported workflows are saved in YML format.

(2) Importing a Workflow

When creating a Workflow Agent, select the Import Workflow option in the top-right corner, then upload the workflow file in the pop-up page. The workflow file must be in YML format, with a file size limit of 20MB. Click Save to complete the import.

# 2.2.2.7 Partial Canvas Copy and Single Node Copy

To help developers quickly duplicate identical nodes, the platform offers a convenient copy-and-paste function. Note: the Start Node and End Node cannot be copied.

(1) Partial Canvas Copy

Hold Shift and press-and-hold the left mouse button to select a section of the canvas. A pop-up at the top will display the number of selected nodes (e.g., "N nodes selected"). Click the Copy button on the right to copy them.

Use Ctrl+V to paste the copied nodes onto the canvas.

(2) Single Node Copy

Click a single node, then press Ctrl+C to copy it — a pop-up will confirm "Copy successful."

Use Ctrl+V to paste it onto the canvas.

# 2.2.3 Node Overview

Nodes are the fundamental building blocks of a workflow. By correctly connecting individual nodes, developers can form a workflow tailored to a specific business process — achieving the goal of efficient, flexible, and easily extensible AI application development. Workflow Agents support five categories of nodes:

• Basic Nodes: Nodes that perform fundamental tasks within a workflow, including the Start Node, End Node, LLM Node, Code Node, and Knowledge Base Node.
• Tool Nodes: Nodes that integrate general-purpose or complex tools to extend the agent's capabilities, including the Tool Node.
• Logic Nodes: Nodes that control the workflow's direction according to specific logic, including the Decision Node, Branch Node, and Iteration Node.
• Transform Nodes: Nodes used to store, convert, or concatenate variables within a workflow, including the Variable Storage Node, Variable Extractor Node, and Text Concatenation Node.
• Other: Primarily includes the Message Node, which controls the output of related information during workflow execution.

In addition to the two functions shown by default, each node's toolbar (in the top-right corner) also includes some hidden functions:

• Add Comment: This feature allows developers to add text annotations to any node in the workflow (such as design intent or node functionality), effectively giving the workflow the equivalent of "code comments." When multiple people collaborate on maintaining a complex workflow, reviewing node comments helps developers quickly understand the design background, purpose, and other key details of that node.
• Duplicate: Creates a copy of a node that is identical to the original in every way except its name, making it easier for developers to batch-create nodes with similar functionality.

To help developers handle exceptions such as errors and timeouts, an exception handling feature has been added to select nodes, including the LLM Node, Code Node, Knowledge Base Node, Knowledge Base Pro Node, Database Node, Workflow Node, Tool Node, Decision Node, Agent Intelligent Decision Node, and Variable Extractor Node. This allows developers to configure the timeout duration, retry count, and exception handling method. Exception handling can be enabled via the toggle on the right.

• Timeout Duration: Measured in seconds. If the server does not respond within the specified time, it will be treated as an exception.
• Retry Count: After a timeout occurs, developers can select the number of retry attempts from the dropdown menu on the right.
• Exception Handling Method: Includes Interrupt Process, Return Preset Content, and Execute Exception Flow, selectable from the dropdown menu on the right.
  • Return Preset Content allows developers to configure a fallback response to be returned when an exception occurs.
  • Execute Exception Flow allows the node to connect to other nodes, which will be executed in the event of an exception.

# 2.2.3.1 Start Node

• Node Overview

The Start Node is the first node in a workflow, marking the beginning of the entire process. This node is typically responsible for receiving user input or trigger conditions, which serve as the basis for subsequent nodes to process tasks.

• Parameter Description

# 2.2.3.2 End Node

• Node Overview

The End Node serves as the final stage of a workflow and plays a critical role: it is responsible for returning the results once the workflow has finished executing.

• Parameter Description

# 2.2.3.3 LLM Node

• Node Overview

The LLM Node invokes a large language model to generate responses based on input parameters and prompts. It is typically used for text generation tasks such as copywriting, text summarization, and article expansion.

The LLM Node relies on the language understanding and generation capabilities of large language models to handle complex natural language processing tasks. You can select different models based on your business needs and configure prompts to define the model's persona and response style. To gain more precise control over the generated output, you can also configure model parameters within the LLM Node to influence factors such as response length and content diversity.

• Parameter Description

# 2.2.3.4 Code Node

• Node Overview

The Code Node allows users to implement data or business logic processing by writing Python code blocks. Users can use an integrated development environment (IDE) tool to write code that processes input parameters and outputs the corresponding results. The tool supports AI-generated code as well as AI-assisted error correction.

• Parameter Description

• Notes
  • If your Code Node throws an error containing "Non-UTF-8," add the following line at the beginning of your code: # -*- coding: utf-8 -*-
  • Do not use the print function when writing code. Using print will cause the returned result to be incorrect.
  • The final result of the main function must be returned in JSON format. The field names and types in the JSON must match the variables defined in the Code Node, otherwise the Code Node will throw an error.
  • The Code Node supports writing multiple functions, but only the code within the main function will be executed. If you want to execute another function, it must be called from within the main function.

The Code Node's specific logic is as follows:

# -*- coding: utf-8 -*-

import json
import re

def main(input):
    name = ""
    age = -1
    # Use regex to remove line breaks and indentation spaces, while preserving spaces within objects
    compressed_json_str = re.sub(r'\s+(?=[{,\]}])|\s+', '', input)
    # Convert the input string into a dictionary
    input_data = json.loads(compressed_json_str)
    for item in input_data:  # Iterate through the roster list
        if "Li Si" in item["name"]:  # Find the person named "Li Si"
            name = item["name"]  # Get the name of "Li Si"
            age = item["age"]  # Get the age of "Li Si"
    ret = {
        "name": name,
        "age": age
    }
    return ret

# 2.2.3.5 Knowledge Base Node

• Node Overview

The Knowledge Base Node quickly retrieves relevant knowledge chunks from a specified knowledge base based on the user's input query, then efficiently returns this information to the user. It is primarily used in scenarios such as information storage and retrieval, improving response efficiency, optimizing workflows, and enhancing model performance.

• Parameter Description

The structure of each recall result is as follows:

{
  "score": ,      // Relevance score
  "docId": ,
  "title": ,
  "content": ,    // Content of the matched knowledge chunk
  "chunkId": ,
  "references": ,
  "docInfo": ,
  "fileName": 
}

# 2.2.3.6 Q&A Node

• Node Overview

Some nodes in a workflow require the user to provide necessary information or clarify their intent before the workflow can proceed. To handle this, the platform provides a dedicated Q&A Node, which precisely collects key information from the user through natural-language questions or multiple-choice options, ensuring a smooth conversational experience. When the agent detects a workflow containing a Q&A Node during a conversation, it will automatically present the preset question to the user and pause the current process until the user provides the required input before continuing.

• Parameter Description

The Q&A Node supports two reply modes — Direct Reply and Option Reply — for collecting user information or intent. Each mode is explained below.

Direct Reply

In the Question Content field, specify an open-ended question. The user replies directly in natural language, and the agent extracts either the user's entire response or specific key fields from it. If the user's response doesn't match the information the agent expects to extract — for example, a required field is missing, or the field's data type doesn't match — the agent will proactively ask again until it obtains the key field(s), or until the maximum number of reply attempts is reached (default: 2).

Click the button to the right of Reply Mode to configure additional parameters for this mode.

After enabling Extract Fields from User Reply (located to the right of Output), the system can extract key fields from the user's reply based on custom variables and descriptions. This is disabled by default.

Option Reply

The Q&A Node allows developers to preset fixed options, letting users respond by selecting from these options. This mode is typically used in chat-style agents to advance the conversation and enhance interactivity.

Click the button to the right of Reply Mode to configure additional parameters for this mode.

You can set the available user actions as selectable options, helping users respond quickly within a defined range, or use common intents as options to serve as reply prompts for the user. Each option typically corresponds to a different workflow branch. Replies that fall outside the provided options also need a corresponding branch — for example, prompting the user to choose again or executing a fallback process.

# 2.2.3.7 Database Node

The Database Node is designed for organizing and managing structured data. By creating a custom database and inserting a Database Node into a workflow, you can perform create, read, update, and delete (CRUD) operations. This platform provides persistent storage for structured data — as long as the data is not deleted or modified by the user, it remains permanently valid and fully preserved. Through a strict data isolation mechanism, the platform ensures that different developers' data resources are stored and accessed independently, safeguarding user privacy and security. In addition, the platform offers free cloud storage, helping users save on storage costs.

• Prerequisites

Before using the Database Node, you must first create a database in the Resource Management section — otherwise, the database selection field will have no databases available to choose from. For detailed instructions on creating a database, please refer to the "Development Guide – Resource Management – Database Management" section.

• Node Overview

The Database Node connects to a specified database and performs common operations such as inserting, querying, editing, and deleting data, enabling dynamic data management. The Database Node supports two methods for managing data: Custom SQL and Form-Based Data Processing. Select Custom SQL to write custom SQL statements to perform operations. If you're not familiar with SQL, you can instead select Form-Based Data Processing, which lets you manage data by selecting a specific data table and processing mode.

• Parameter Description

Custom SQL

Form-Based Data Processing

Parameter details for each processing mode:

• Insert Data: Inserts data into the specified data table. When configuring the data to insert, parameter values can be defined either by referencing the output parameter of an upstream node, or by entering a fixed value.
• Update Data: Updates existing data in the specified data table.
  • Set Data Range: Configure filter conditions here to specify the range of data to be updated (supports conditions such as equals, not equals, greater than, greater than or equal to, less than, less than or equal to, and fuzzy match). Comparison values can be defined either by referencing the output parameter of an upstream node, or by entering a fixed value.
  • Set Update Data: Specify the data fields to update and their new values.
• Query Data: Queries data in the specified data table.
  • Set Data Range: Configure the query conditions for the query fields here (supports conditions such as equals, not equals, greater than, greater than or equal to, less than, less than or equal to, and fuzzy match). Comparison values can be defined either by referencing the output parameter of an upstream node, or by entering a fixed value.
  • Set Result Fields: Specify the fields to be queried.
  • Sort: Configure how the query results should be sorted; the system will sort the results according to the specified parameters.
  • Query Limit: Limits the number of results returned.
• Delete Data: Deletes data from the specified data table. When setting the range of data to delete, the comparison values for the conditions can be defined either by referencing the output parameter of an upstream node, or by entering a fixed value.

# 2.2.3.8 Workflow Node

• Node Overview

The Workflow Node allows developers to quickly integrate a previously published workflow into the current workflow canvas, efficiently reusing existing capabilities. By nesting workflows, complex task designs can be broken down into modular components — each module being an independent Workflow Agent — enabling multi-agent collaboration and making workflow orchestration easier to manage.

• Parameter Description

Note: The Workflow Node can only add workflows that have already been published. Unpublished workflows must be published before they can be added.

# 2.2.3.9 Tool Node

• Node Overview

The Tool Node integrates a wide range of general-purpose and complex plugins, allowing users to directly invoke the plugins they need to extend the agent's capabilities. Common plugins include aggregated search, text-to-image generation, and general-purpose OCR models. Custom plugins are also supported.

• Parameter Description

• Usage Example

Select the Tool Node from the node list, then click the "+" icon to be redirected to the plugin selection interface. On this page, official plugins are grouped under "Official Tools", while custom plugins are grouped under "Created by Me." Developers can browse and locate the plugin they need, then click the Add button on the right to import it into the workflow for use. Note: before adding a custom plugin, developers must first create it. For instructions on creating a custom plugin, please refer to "Development Guide – Resource Management – Custom Plugins."

# 2.2.3.10 Decision Node

• Node Overview

The Decision Node leverages the capabilities of a large language model, with its primary function being to analyze input information, identify and classify user intent, and determine the logical direction of the subsequent workflow. Users can preset multiple distinct agent usage scenarios, and by chaining Decision Nodes together, the workflow can deliver more precise, tailored services.

• Parameter Description

# 2.2.3.11 Branch Node

• Node Overview

While the Decision Node uses natural language processing (NLP) to interpret user intent or needs, the Branch Node instead operates through conditional logic and branching mechanisms — functioning similarly to an if-else statement. Depending on whether the node's input parameters meet the specified conditions, the corresponding downstream branch is executed. Each branch condition supports flexibly adding multiple criteria, which can be combined using the logical operators AND and OR to construct more complex and refined logic. Multiple branch conditions can also be added, each with a different priority level.

# 2.2.3.12 Iteration Node

• Node Overview

The Iteration Node allows users to configure tasks or operations that repeat — similar to a for loop in programming languages. It iterates over a known array, executing the same set of steps for each element in the array. With each iteration, the workflow executes each node within the canvas in sequence.

• Parameter Description

# 2.2.3.13 Intelligent Decision Node

• Node Overview

The Agent Intelligent Decision Node primarily relies on the reasoning strategy selected by the user to invoke the chosen large language model, performing reasoning and analysis on complex input questions. It also has intelligent tool-scheduling capabilities, dynamically selecting and invoking suitable external tools based on the model's reasoning results — forming a closed loop of "think + execute." In addition, the node supports supplementary prompts to refine role settings, optimize the reasoning path, and enhance query semantics, in order to improve overall reasoning accuracy.

• Parameter Description

Details on select parameters:

a. Selecting the Model and Agent Reasoning Strategy

When configuring the Agent Intelligent Decision Node, users must first select an appropriate model — i.e., choose an LLM from the available library that fits the current task — and set the corresponding reasoning strategy based on task complexity and tool-calling requirements, ensuring the agent has a clear reasoning path and execution capability.

The Agent reasoning strategy defaults to ReACT mode. ReACT (Reasoning and Acting) is an alternating "think + act" reasoning strategy that allows the model to think while answering a question, call external tools as needed, and continue reasoning based on the results until the task is complete. When running in ReACT mode, the model alternates through the following steps:

User Question → Model's First Reasoning Step → Determines Tool A Is Needed → Tool Returns Data → Model Reasons Again → Determines Tool B Is Needed → Reasons Again → Outputs Final Answer

b. Adding Plugins, MCP Tools, and Knowledge Bases

The Agent Intelligent Decision Node can extend its capabilities by adding tool plugins. Click the "Add Plugin" button to browse and select the plugins you need in the pop-up window. The platform supports three types of plugin integration:

• Common Plugins: Built-in capabilities such as aggregated search, general-purpose OCR models, and image understanding.
• MCP Server Tools: Supports invoking official tool services provided by the Astron Agent development platform via the MCP protocol — such as Amap (Gaode Maps) location queries, Bilibili video search, and structured data processing — as well as invoking self-built or externally connected MCP Server instances.
• Knowledge Base Resources: Serves as external knowledge support for the LLM, suitable for tasks that require referencing industry materials, internal documents, or domain-specific knowledge.

The system supports adding up to 30 plugins, and users can select multiple as needed. Click "Add" on the right to complete the tool integration.

In addition, if no suitable tool currently meets your business needs, you can also create your own custom plugins and knowledge bases to fulfill specialized task requirements. For instructions on creating these, please refer to "Development Guide – Resource Management – Knowledge Base Management."

c. Adding a Custom MCP Server Address

The platform allows users to add custom third-party MCP server addresses based on business needs, extending the range of capabilities the model can invoke during task execution. This configuration is optional and applies to the following typical scenarios:

• An enterprise or individual has already deployed their own MCP Server and wants to connect it to the Astron Agent development platform.
• Certain tool services exist only as private APIs/MCP services and need to be manually integrated.
• Users have specific requirements around response speed, security isolation, or custom service logic.

The system supports configuring up to 3 addresses. Click "Add Address" to manually enter the server's API address.

d. Configuring Prompts

Prompts provide the LLM with clearer context and behavioral guidance. Users can configure three prompt sections: Role Setting, Reasoning Steps, and User Query.

Example input:

# 2.2.3.14 Variable Storage Node

• Node Overview

The Variable Storage Node assigns variables from within the workflow to conversation variables for temporary storage, allowing them to be referenced in subsequent turns of the conversation. Variables are cleared when the conversation is deleted or a new conversation is started.

• Parameter Description

Note:

• A variable's value must be set using the Variable Storage Node before it can be retrieved in Get mode — otherwise, the variable will not appear as an available parameter in Get mode.
• A single Variable Storage Node can only perform one operation — either storing or retrieving. Therefore, storing and retrieving a variable requires two separate Variable Storage Nodes.

# 2.2.3.15 Variable Extractor

• Node Overview

The Variable Extractor leverages the capabilities of a large language model to extract key information fields from natural language, improving the agent's ability to handle complex tasks and enabling more flexible interactions.

• Parameter Description

# 2.2.3.16 Text Processing Node

• Node Overview

The Text Processing Node is a specific node type within a workflow that receives multiple text inputs from upstream nodes and processes them as strings according to preset rules or logic. The resulting processed string can serve as input for subsequent nodes, or be output directly to the end user. The Text Concatenation Node currently supports two functions: String Concatenation and String Splitting.

• Parameter Description

String Concatenation

String Splitting

# 2.2.3.17 Message Node

• Node Overview

The Message Node is an output node used at intermediate stages of a workflow, outputting content to the user during execution based on the configured settings. Its main function is to ensure information is effectively communicated throughout the agent's process, improving the overall user experience.

• Parameter Description

# 2.2.4 Agent Debugging

# 2.2.4.1 Debugging

Agent debugging is a critical step in optimizing an agent's performance and ensuring stable operation. It helps users identify and fix logic errors, optimize response efficiency and resource allocation, and calibrate the interaction experience to meet user expectations — ensuring the agent runs smoothly and effectively.

On the canvas page, click the Debug button in the top-right corner, then enter test input in the pop-up page to debug the agent. Debugging supports editing and testing simultaneously, allowing you to quickly adjust the orchestrated agent and verify its performance — helping you build an agent that meets user expectations.

# 2.2.4.2 Issue Feedback

To address the difficulty of troubleshooting node errors during Workflow Agent debugging, the platform offers a one-click feedback feature. This feature helps developers obtain complete runtime logs and submit relevant error information to the platform, enabling the platform's engineering team to troubleshoot issues efficiently. The process is shown below:

After clicking Save, the information entered by the developer — along with the username, Bot ID, Flow ID, SID, start time, end time, duration, tokens consumed, status, and error code — will be saved to the backend for use by the platform's engineering team in troubleshooting.

# 2.2.4.3 Trace Log Analysis

During agent development, the call chain of workflow requests can become quite complex. The platform's Trace Log feature tracks and records the calling sequence between components, helping developers analyze system behavior, pinpoint issues, and optimize performance — transforming the process from a "black box model" into "transparent decision-making."

Developers can locate the corresponding workflow from the Publish Management list, click Details, and then switch to the Trace Log tab to view the Trace data reported by the specified application within a given time range.

In the Trace list, select a target record and click it to view the Trace details.

The Trace log fields are described below:

To help developers quickly view the Trace data they need during debugging, the platform provides a Column Management feature, making it easy to filter for the desired information. The process is as follows:

Click the Column Management button in the top-right corner of the Trace list, then check the desired dimensions in the dropdown menu that appears.

# 2.2.5 Agent Publishing

Once an agent has been created, developers can locate it from the Publish Management menu and click Publish.

Note: To publish as an API, you must configure it in advance. Click the Configure button to enter the agent's API configuration page.

# 2.3 Development of Interactive Digital Human Agents

# 2.3.1 Function Overview

Building on Workflow Agents, the Interactive Digital Human Agent breaks through the limitations of traditional text-based interaction, enabling real-time voice interaction and multimodal, avatar-driven scenarios. It supports multiple interaction modes, including traditional text chat, avatar broadcast, avatar call, and voice call.

The Interactive Digital Human Agent supports a wide range of use cases:

• Companionship

With the Interactive Digital Human Agent, users can build a virtual companion simply by selecting an existing character — no additional nodes required. The digital human supports not only traditional text conversation but also natural voice calls with the user, automatically generating context-appropriate facial expressions throughout the interaction. For example, you could build a travel companion assistant that provides travel planning, route navigation, and weather updates from anywhere, while also engaging in free-flowing voice conversation.

• Intelligent Customer Service

The Interactive Digital Human Agent upgrades traditional customer service into a visual, avatar-based experience. This gives users a more "face-to-face" communication experience when interacting with the digital human, improving the intuitiveness and responsiveness of the service. For example, an e-commerce platform could deploy a virtual shopping advisor for voice-based consultation or real-time voice calls, giving customers a more human-centered service experience.

• Education and Training

The Interactive Digital Human Agent can be used to create expressive virtual instructors for educational applications. For instance, a history course could use the voice of a historical figure to narrate lessons, making learning more engaging; language learning courses could likewise feature a virtual foreign-language teacher, creating a more natural language-learning environment.

# 2.3.2 Agent Creation

After entering the homepage of the Astron Agent development platform, click the Create button on the left. In the pop-up dialog, select Interactive Digital Human Creation.

# 2.3.2.1 Basic Configuration

After selecting this option, the Basic Configuration dialog will appear. Basic configuration for Voice/Digital Human creation includes two mandatory sections: Basic Information and Voice & Appearance.

Basic Information includes the name, category, and description. Click the logo icon to the left of the name field to change the agent's logo — you can either upload one locally or generate one with AI. The description can be written manually, or generated in detail by AI based on a few keywords.

The Voice & Appearance section allows developers to configure the digital human's appearance and voice for avatar broadcasts or avatar calls.

Steps for creating a custom voice:

• Select Character Voice, then go to Basic Voices.
• Click Create Voice to create a voice from a single spoken sentence. First select a gender, then click Start Recording.
• In the pop-up dialog, click Start Recording, read the provided text aloud in full, and then click Stop Recording.
• Once processing is complete, a voice persona based on your own voice will be generated.

After completing both Basic Information and Voice & Appearance, click Confirm to finish the basic configuration.

After entering the workflow canvas, you can still modify the basic configuration at any time by clicking the Avatar Settings button in the top-left corner.

# 2.3.2.2 Advanced Settings

After creating the workflow, click the Advanced Settings button in the top-right corner to access advanced configuration.

Advanced Settings define capabilities beyond basic role-based conversation, including Conversation Opening, Next Question Suggestions, Role Voice, and Background Settings. These settings help improve the agent's usability and conversational performance.

# 2.3.2.3 Workflow Orchestration

The system automatically creates a Start Node and an End Node. Developers only need to modify the relevant code or node logic according to their needs to build a complete workflow. The platform currently offers a rich set of nodes, including LLM, Code, Decision, and Knowledge Base nodes. For detailed node descriptions, see Section 2.2.3, "Node Overview."

# 2.3.2.4 Version History

Click the Version History button on the workflow canvas to view previous versions in the pop-up page. Users can switch between historical versions as needed.

# 2.3.3 Agent Debugging

# 2.3.3.1 Debugging

Agent debugging is a critical step in optimizing an agent's performance and ensuring stable operation. It helps users identify and fix logic errors, optimize response efficiency and resource allocation, and calibrate the interaction experience to meet user expectations — ensuring the agent runs smoothly and effectively. On the canvas page, click the Debug button in the top-right corner, then enter test input in the pop-up page to debug the agent. Debugging supports editing and testing simultaneously, allowing you to quickly adjust the orchestrated agent and verify its performance — helping you build an agent that meets user expectations.

For Voice/Digital Human Agents, you can switch between Voice Call, Avatar Call, Text Chat, and Voice Broadcast in the top-right corner to test multimodal performance.

# 2.3.3.2 Issue Feedback

To address the difficulty of troubleshooting node errors during Voice/Digital Human Agent debugging, the platform offers a one-click feedback feature. This feature helps developers obtain complete runtime logs and submit relevant error information to the platform, enabling the platform's engineering team to troubleshoot issues efficiently.

# 2.3.4 Agent Publishing

Once a Voice/Digital Human Agent has been created, developers can locate it from the Publish Management menu and click Publish to make it available.

# 3. Technical Practice Cases

# 3.1 Prompt Best Practices

# 3.1.1 Opening Formula (Define Role + State Problem + Set Goal + Supplement Requirements)

You are a time management trainer [Define Role]. I want to learn about time management [State Problem]. I want you to output a PPT outline about time management [Set Goal]. The format is to output code marked in Markdown language [Supplement Requirements].

# 3.1.2 Few-Shot Prompting

Sometimes it may not be easy to describe a Prompt clearly, and providing examples will make it easier.

For example: We ask the model to act as a text classifier to perform binary classification on user reviews, with classification results being: Positive Review or Negative Review.

Please help me distinguish whether the category of the user input text is a positive review or a negative review according to the following classification method, and please output directly: Positive Review / Negative Review.

Please refer to the following samples:
Sample 1:
User Input: I went to this restaurant last night, and their food and service were amazing. I will definitely come again.
Output: Positive Review
Sample 2:
User Input: This mobile phone has an ultra-long battery life and great camera effects, very satisfied!
Output: Positive Review
Sample 3:
User Input: The courier was delayed for a week, and the packaging was damaged, the experience was extremely poor.
Output: Negative Review
Sample 4:
User Input: The movie has a wonderful plot and the actors' acting is on point, highly recommended!
Output: Positive Review
Sample 5:
User Input: The product quality is terrible, it broke after one use, and the customer service ignored me.
Output: Negative Review

Please answer the following question:
User Input: I dined at this western restaurant last month, it was okay, but not particularly amazing.
Output:

# 3.1.3 CoT (Chain of Thought)

CoT (Chain of Thought) is a thinking tool that helps people conduct deeper thinking and draw more complex and comprehensive conclusions by gradually extending and expanding an idea.

Core Concepts:

• The core idea of CoT is to guide the model to show its step-by-step reasoning process before generating the final answer.
• It imitates the way humans solve complex problems: instead of jumping directly to conclusions, it derives answers through a series of intermediate, interpretable logical steps ("chains").
• These steps usually include: understanding the problem, decomposing the problem, invoking relevant knowledge, performing logical operations or reasoning, integrating information, and drawing conclusions.

# 3.1.3.1 Zero-Shot

Add Let's think step by step or Let's analyze and think step by step to the prompt.

# 3.1.3.2 Few-Shots

Provide several examples with detailed reasoning steps in the Prompt. These examples show the complete process of "Question -> Step-by-Step Reasoning -> Final Answer". By observing these examples, the model learns to generate a similar reasoning chain when answering new questions. This is the most commonly used method and usually has better effects.

Please solve the following math problems. I will first give several examples and their detailed problem-solving ideas, then ask you to solve the final problem.

Example 1:
Question: Xiao Ming has 15 apples. He ate 3 of them, then bought 2 bags of apples, with 4 apples in each bag. How many apples does he have now in total?
Reasoning Steps:
1. Initial number of apples: 15.
2. Remaining after eating 3: 15 - 3 = 12.
3. Bought 2 bags, 4 apples each: 2 * 4 = 8.
4. Total number of apples now: remaining apples + newly bought apples = 12 + 8 = 20.
Answer: 20

Example 2:
Question: A swimming pool is 25 meters long, 10 meters wide, and 2 meters deep. If 5 cubic meters of water can be injected per minute, how many minutes does it take to fill the swimming pool?
Reasoning Steps:
1. Calculate the volume of the swimming pool: length * width * depth = 25 meters * 10 meters * 2 meters = 500 cubic meters.
2. Known water injection speed per minute: 5 cubic meters/minute.
3. Required time = total volume / water injection speed = 500 cubic meters / 5 cubic meters/minute = 100 minutes.
Answer: 100

Now, please solve this problem:
Question: A bookstore holds a promotion, all books are sold at a 20% discount. Xiao Li bought a book with an original price of 50 yuan and another book with an original price of 30 yuan. How much did she actually pay?
Reasoning Steps:

If you are interested in Prompt and want to learn more about Prompt knowledge, you can also learn from the following learning websites by yourself.

# 3.2 Development Practice of Photo-Based Q&A Agent

# 3.2.1 Case Introduction

With the continuous breakthroughs in large models and multimodal fusion technologies, the unified understanding and content generation of heterogeneous data such as text and images have been widely applied. AI applications such as photo-based Q&A and photo-based product searching have brought convenience to people.

This case mainly implements the photo-based Q&A function. When users encounter various unsolved problems in mathematics, English, etc., they only need to take a photo and upload it to the agent to get an accurate answer. This article will detail how to implement a multimodal agent application with photo-based Q&A function step by step.

# 3.2.2 Implementation Process

A complete agent product generally goes through four steps from development to application: creation, orchestration, debugging, and release, among which agent orchestration is the core of agent design and implementation.

The key points to realize the photo-based Q&A function lie in the recognition of image content and the generation of reasoning results by the large model. The overall design process of the workflow is as follows:

The specific implementation process will be explained step by step below.

# Step 1: Create a Workflow Agent

Click to enter the homepage of Xingchen Agent Development Platform (opens new window), click [My Agents] in the left navigation bar to enter the My Agents list page, click [New Agent] - [Create by Workflow] - [Custom Creation] to enter the agent canvas page. The agent canvas page has two mandatory nodes: Start and End by default.

# Step 2: Configure Support for Image Input

Click [+ Add] at the bottom left of the Start node to add an input variable, set the variable name to "image", and subsequent nodes will reference the network address of the image uploaded by the user through this variable name. Select "Image" as the variable type.

# Step 3: Implementation of Image-Text Recognition

The official provides a general OCR large model tool to support image and PDF recognition, which can be referenced through tool nodes. The operation process is as follows:

1. Click the [+] sign in the upper right corner of the [Tool] node in the node list on the left side of the canvas to enter the tool selection page, search and find the [General OCR Large Model] tool from the official tools, click the [Add] button on the right side of the tool to add the tool to the canvas, and click to return to the canvas page.

2. Connect the Start node and the General OCR Large Model node, and configure the input parameters of the General OCR Large Model node. The General OCR Large Model has three parameters:

For the input parameter "file_url", select to reference Start/image. For image data, ocr_document_page_start and ocr_document_page_end can be left blank by default.

# Step 4: Large Model Reasoning to Generate Answers

Connect a large model node after the General OCR Large Model node to reason and generate answers.

Configure two variables for the large model input parameters: input and image_content:

• input: Reference the text information input by the user (Start/AGENT_USER_INPUT)
• image_content: Reference the image OCR result (General OCR Large Model_1/data.content)

Select the model: Spark X1 for the answer mode;

The large model prompt configuration is as follows:

//System Prompt:
You are a teacher of all disciplines, please answer students' questions as required.

//User Prompt:
The picture of the question input by the user, after OCR, the result is: {{image_content}}. Please combine the user's requirements: {{input}}, and answer the question in a standard way that students can understand, and answer it standardizedly.

The large model node has 2 output variables:

REASONING_CONTENT: The thinking process of the large model;

output: The answer generated by the large model.

# Step 5: Output Configuration

Connect the large model node to the output node, and configure the End node as follows:

• Answer Mode: By default, it is sufficient to return the answer configured in the set format.
• Output definition references 2 variables:
  • output: Reference the large model output result (Large Model_1/output)
  • reasoning: Reference the thinking process of the large model (Large Model_1/REASONING_CONTENT)
• Reference variable in thinking content: {{reasoning}}
• Turn on streaming output for answer content, and reference variable for result: {{output}}

So far, the orchestration of the workflow is completed.

# Step 6: Debug the Workflow

Click the [Debug] button in the upper right corner to enter the debugging page, enter the description and the picture of the question, and click Send to test the result.

# Step 7: Release the Agent

After debugging the workflow effect and configuring the workflow name, description and other information. After the information is completed, click the release button in the upper right corner to select release.

# 4. API Integration

Calling the API requires the following processes:

# 4.1 Preparation

The workflow agent must be published as an API before it can be called via the API. The specific publishing process is as follows:

# 4.1.1 Publish Workflow as API

After completing the development and debugging of the workflow, click the publish button in the upper right corner of the workflow canvas page to publish it.

In the pop-up page, click the "Configure" button on the right side of the "Publish as API" column to jump to the configuration page for publishing as an API.

# 4.1.2 Real-Name Authentication

Real-name authentication is required before publishing a workflow as an API. If you have not completed real-name authentication before, you can find the "Go to Authenticate" button in the "Complete Real-Name Authentication" column on the page and click it to jump to the user authentication center page, where developers can complete real-name authentication as prompted. If you have successfully completed real-name authentication before, you can skip this step.

# 4.1.3 Create Application

If you have not created an application before, or expect to bind this workflow to a new application, you need to create a new application through this step. If you have created an application and want to bind this workflow to an existing application, you can skip this step.

Step 1: When you want to create a new application, find the "Create Now" button in the "Bind Application" column and click it to jump to the application creation page.

Step 2: Fill in the relevant information of the application on the creation page and click the "Submit" button to complete the creation.

# 4.1.4 Bind Application

Return to the API publishing configuration page, find the "Service Interface Authentication Information" tab, and complete the binding of the workflow and the application in this tab. The specific steps are as follows:

Step 1: Click the drop-down box of "Select the application you want to bind", and all application names under the current account will be displayed. Select the application you need to bind from them.

Notes:

• If the newly created application name is not found in the drop-down box, refresh the configuration page.
• Once the application is bound, it cannot be modified. Please choose carefully.

Step 2: After selecting the application, click the "Bind Now" button to complete the application binding. At this time, the interface information required for calling the API, including APIKey, API Secret, and API Flowid, will be displayed.

Note: If there are new changes to your workflow, please click the "Update Binding" button to republish it as an API before calling the API, so that the new changes will take effect in the API call.

# 4.2 Workflow API Integration

# 4.2.1 Basic Information

# 4.2.1.1 Interface Description

# 4.2.1.2 Interface Demo

# 4.2.1.3 Interface Requirements

Interface Type: Streaming HTTP(S)

Interface Authentication: Click here to view the document (opens new window)

# 4.2.1.4 Interface Permission Description

If authentication fails or the APPID does not match the current workflow, relevant flow control errors will be returned.

# 4.2.2 Initiate Session Request

# 4.2.2.1 Request Protocol Example

{
    "flow_id": "7265177322515169282",
    "uid": "123",
    "parameters": {
        "AGENT_USER_INPUT": "Hello"
    },
    "ext": {
        "bot_id": "workflow",
        "caller": "workflow"
    },
    "stream": true,
    "chat_id": "xxx",
    "history": [
      {
        "role": "user",
        "content_type": "text",
        "content": "Hello"
      },
      {
        "role": "assistant",
        "content_type": "text",
        "content": "Hello, I am your workflow assistant. How can I help you?"
      }
    ]
}

# 4.2.2.2 Request Parameters

# 4.2.2.2.1 Header

# 4.2.2.2.2 Body

# 4.2.2.2.3 history_message Object**

When processing the history_message object, the role of the first element must be user. The interaction history should be spliced in the order of user -> assistant -> user -> assistant. By default, a pair of interactions between user and assistant is regarded as one round of conversation. Fill in in the order of conversation time from first to last. For example: [{first time},{second time}...]

[
  // Splice conversation history information:
  {"role": "user", "content_type" : "text", "content": "What are the famous foods in Hunan?"},              // User's first question. role is user, indicating it is the user's question
  {"role": "assistant", "content_type" : "text", "content": "Hunan has xxxxxxx"},        // AI's first reply. role is assistant, indicating it is the AI's reply
]

# 4.2.3 Response

# 4.2.3.1 Response Protocol Example

# 4.2.3.1.1 Streaming Result Example**

Streaming Output Process Frame

{
  "code": 0,
  "message": "Success",
  "id": "cha000c0076@dx191c21ce879b8f3532",
  "created": 123412324431,
  "workflow_step": {
    "seq": 0,
    "progress": 0.4
  },
  "choices": [
    {
      "delta": {
        "role": "assistant",
        "content": "Hello,",
        "reasoning_content": ""
      },
      "index": 0,
      "finish_reason": null
    }
  ]
}

Streaming Output End Frame

{
  "code": 0,
  "message": "Success",
  "id": "spf0016609f@dx193193f43cba44d782",
  "created": 123412324431,
  "workflow_step": {
    "seq": 6,
    "progress": 1
  },
  "choices": [
    {
      "delta": {
        "role": "assistant",
        "content": "",
        "reasoning_content": ""
      },
      "index": 0,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 1,
    "completion_tokens": 0,
    "total_tokens": 9
  }
}

# 4.2.3.1.2 Non-Streaming Result Example**

{
  "code": 0,
  "message": "Success",
  "id": "cha000b0003@dx1905cd86d6bb86d552",
  "choices": [
    {
      "delta": {
        "role": "assistant",
        "content": "Hello, I am the Spark Cognitive Intelligence Model built by iFLYTEK.\nIf you have any questions or need help, please feel free to tell me! I will do my best to provide you with answers and support. How can I help you?",
        "reasoning_content": ""
      },
      "index": 0,
      "finish_reason": "stop",
      "finish_reason": ""
    }
  ],
  "usage": {
    "prompt_tokens": 6,
    "completion_tokens": 42,
    "total_tokens": 48
  }
}

# 4.2.3.1.3 Interrupt Event**

When there is a Q&A node in the workflow, the workflow will be interrupted.

Q&A Node Interrupt Frame (Direct Answer)

{
  "code": 0,
  "message": "Success",
  "id": "cha000c0076@dx191c21ce879b8f3532",
  "created": 123412324431,
  "workflow_step": {
    "seq": 0,
    "progress": 0.4
  },
  "choices": [
    {
      "delta": {
        "role": "assistant",
        "content": "Hello,",
        "reasoning_content": ""
      },
      "index": 0,
      "finish_reason": "interrupt"
    }
  ],
  "event_data": {
        "event_id": "7336690112690499584",
        "event_type": "interrupt",
        "need_reply": true,
        "value": {
            "type": "direct",
            "content": "Which of the following packages do you want to purchase?"
        }
    }
}

Q&A Node Interrupt Frame (Option Answer)

{
  "code": 0,
  "message": "Success",
  "id": "cha000c0076@dx191c21ce879b8f3532",
  "created": 123412324431,
  "workflow_step": {
    "seq": 0,
    "progress": 0.4
  },
  "choices": [
    {
      "delta": {
        "role": "assistant",
        "content": "Hello,",
        "reasoning_content": ""
      },
      "index": 0,
      "finish_reason": null
    }
  ],
  "event_data": {
        "event_id": "7336690112690499584",
        "event_type": "interrupt",
        "need_reply": false,
        "value": {
            "type": "option",
            "content": "Please select your package",
            "option": [
                {
                    "id": "A",
                    "text": "Annual Package"
                },
                {
                    "id": "B",
                    "text": "Monthly Package"
                }
            ]
        }
    }
}

# 4.2.3.1.4 Exception Result**

{
    "code": 20805,
    "message": "flow id : 7265177322515169282 is in draft status, please publish",
    "id": "spf00dc0001@hf193621572a96806782",
    "created": 1732517393,
    "choices": [
        {
            "delta": {
                "role": "assistant",
                "content": "",
                        "reasoning_content": ""
            },
            "finish_reason": "stop"
        }
    ],
    "workflow_step": {
        "seq": 0,
        "progress": 1.0
    },
    "usage": {
        "prompt_tokens": 0,
        "completion_tokens": 0,
        "total_tokens": 0
    }
}

# 4.2.3.2 Response Parameters

# 4.2.3.2.1 Response Data Parameters**

# 4.2.3.2.2 Supplementary Instructions on Result Format**

In addition to plain text type, the model results will include the following markup languages to meet typesetting requirements, and it is recommended that integrators adapt to them:

• markdown (tables, lists, etc.)

# 4.2.4 Resume Workflow Execution

When your workflow executes to a Q&A node, the workflow will be temporarily interrupted and return the corresponding event ID and the question set in the workflow. At this time, developers should call this interface to upload the user's reply, event ID and other information to resume the execution of the workflow.

# 4.2.4.1 Basic Information

# 4.2.4.1.1 Interface Description**

# 4.2.4.1.2 Interface Demo**

# 4.2.4.1.3 Interface Requirements**

Interface Type: Streaming HTTP(S)

# 4.2.4.2 Request

# 4.2.4.2.1 Request Protocol Example**

{
    "event_id": "123456789012345",
    "event_type": "resume",
    "content": "My name is:xxxx, Age：xxxx"
}

# 4.2.4.2.2 Request Parameters**

1. Header

2. Body

# 4.2.4.3 Response

# 4.2.4.3.1 Response Protocol Example**

1. Streaming Result Example

Streaming Output Process Frame

{
  "code": 0,
  "message": "Success",
  "id": "cha000c0076@dx191c21ce879b8f3532",
  "created": 123412324431,
  "workflow_step": {
    "seq": 0,
    "progress": 0.4
  },
  "choices": [
    {
      "delta": {
        "role": "assistant",
        "content": "Hello,",
        "reasoning_content": ""
      },
      "index": 0,
      "finish_reason": null
    }
  ]
}

Streaming Output End Frame

{
  "code": 0,
  "message": "Success",
  "id": "spf0016609f@dx193193f43cba44d782",
  "created": 123412324431,
  "workflow_step": {
    "seq": 6,
    "progress": 1
  },
  "choices": [
    {
      "delta": {
        "role": "assistant",
        "content": "",
        "reasoning_content": ""
      },
      "index": 0,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 1,
    "completion_tokens": 0,
    "total_tokens": 9
  }
}

2. Non-Streaming Result Example

{
  "code": 0,
  "message": "Success",
  "id": "cha000b0003@dx1905cd86d6bb86d552",
  "choices": [
    {
      "delta": {
        "role": "assistant",
        "content": "Hello, I am the Spark Cognitive Intelligence Model built by iFLYTEK.\nIf you have any questions or need help, please feel free to tell me! I will do my best to provide you with answers and support. How can I help you?",
        "reasoning_content": ""
      },
      "index": 0,
      "finish_reason": "stop",
      "finish_reason": ""
    }
  ],
  "usage": {
    "prompt_tokens": 6,
    "completion_tokens": 42,
    "total_tokens": 48
  }
}

3. Interrupt Event

When there is a Q&A node in the workflow, the workflow will be interrupted.

Q&A Node Interrupt Frame (Direct Answer)

{
  "code": 0,
  "message": "Success",
  "id": "cha000c0076@dx191c21ce879b8f3532",
  "created": 123412324431,
  "workflow_step": {
    "seq": 0,
    "progress": 0.4
  },
  "choices": [
    {
      "delta": {
        "role": "assistant",
        "content": "Hello,",
        "reasoning_content": ""
      },
      "index": 0,
      "finish_reason": null
    }
  ],
  "event_data": {
        "event_id": "7336690112690499584",
        "event_type": "interrupt",
        "need_reply": true,
        "value": {
            "type": "direct",
            "content": "Which of the following packages do you want to purchase?"
        }
    }
}

Q&A Node Interrupt Frame (Option Answer)

{
  "code": 0,
  "message": "Success",
  "id": "cha000c0076@dx191c21ce879b8f3532",
  "created": 123412324431,
  "workflow_step": {
    "seq": 0,
    "progress": 0.4
  },
  "choices": [
    {
      "delta": {
        "role": "assistant",
        "content": "Hello,",
        "reasoning_content": ""
      },
      "index": 0,
      "finish_reason": null
    }
  ],
  "event_data": {
        "event_id": "7336690112690499584",
        "event_type": "interrupt",
        "need_reply": false,
        "value": {
            "type": "option",
            "content": "Please select your package",
            "option": [
                {
                    "id": "A",
                    "text": "Annual Package"
                },
                {
                    "id": "B",
                    "text": "Monthly Package"
                }
            ]
        }
    }
}

4. Exception Result

{
    "code": 20805,
    "message": "flow id : 7265177322515169282 is in draft status, please publish",
    "id": "spf00dc0001@hf193621572a96806782",
    "created": 1732517393,
    "choices": [
        {
            "delta": {
                "role": "assistant",
                "content": "",
                        "reasoning_content": ""
            },
            "finish_reason": "stop"
        }
    ],
    "workflow_step": {
        "seq": 0,
        "progress": 1.0
    },
    "usage": {
        "prompt_tokens": 0,
        "completion_tokens": 0,
        "total_tokens": 0
    }
}

# 4.2.4.3.2 Response Parameter Description**

1. Response Data Parameters

2. Supplementary Instructions on Result Format

In addition to plain text type, the model results will include the following markup languages to meet typesetting requirements, and it is recommended that integrators adapt to them:

• markdown (tables, lists, etc.)

# 4.2.5 File Upload

# 4.2.5.1 Basic Information

# 4.2.5.1.1 Interface Description**

# 4.2.5.1.2 Interface Demo**

curl -X POST 'https://agent-sg-ali.xf-yun.com/workflow/v1/upload_file' \
--header 'Authorization: Bearer {api_key}' \
--form 'file=@localfile;type=image/[png|jpeg|jpg|webp|gif]

# 4.2.5.1.3 Interface Requirements**

Interface Type: Streaming HTTP(S)

Interface Authentication: Bearer Authentication

# 4.2.5.2 Request Parameters

# 4.2.5.2.1 Header**

# 4.2.5.2.2 Body**

# 4.2.5.3 Response

# 4.2.5.3.1 Response Protocol Example**

{
  "code": 0,
  "message": "success",
  "sid": "spf001b23c7@dx1939b17d9e3a4f3700",
  "data": {
      "url": "xxxxxxxxxx"
  }
}

2.5.3.2 Response Parameter Description

# 4.3 Error Code List

# 4.3.1 Workflow Errors

# 4.3.2 Model Errors

# 4.3.3 API Authorization

# 4.3.4 Text-to-Image

# 4.3.5 Tool Errors

# 4.3.6 Node Execution Errors

# 4.3.7 Session

# 5. Authentication Guide

# 5.1 Request URL

// Depends on specific AI capability
https://rest-api.xfyun.cn/v2/***

# 5.2 Signature and Authentication

API calls must sign HTTP requests. The server identifies and validates users through signatures. Users apply to the server for a credential, which is a key/secret key pair. The client concatenates Method, Accept, Date, other Header fields, and URL in a specified manner, then signs the request using a hash algorithm (such as HMAC-SHA256) and the user's secret. Finally, place the key, algorithm used, header fields involved in signing, and the calculated signature into the "Authorization" header field.

# Request Header Example:

Content-Type: application/json
Accept: application/json;version=1.0
Date: Tue, 26 Jun 2018 12:27:03 UTC
Host: "your host"
Digest: SHA-256=xxxxxxxxxxxxxxxxxxxxxxxx
Authorization: hmac api_key="your_key", algorithm="hmac-sha256", headers="host date request-line", signature="base64_digest"

# 5.3 Authentication Method

The client needs to use the hmac-sha256 algorithm to calculate a digest of relevant request parameters to generate a signature, building the Authorization header. The server parses the Authorization header and calculates the signature in the same way, comparing whether the signatures match. If they match, authentication passes.

# 5.4 Header Detailed Description

# 5.5 Signature Generation Formula

api_key="${api_key}", algorithm="hmac-sha256", headers="host date request-line digest", signature="${signature}"

Explanation:

• api_key: API key applied from the open platform
• algorithm: Signature calculation algorithm, supports hmac-sha256
• headers: Parameters required for signature, must include at least host, date, and request-line
• signature: Calculated signature

# 5.6 Authentication Detailed Process

# 5.6.1 Build Signature Origin String (signature_origin_str)

The format of signature_origin_str is:

host: ${host}
date: ${date}
${method} ${path} HTTP/1.1
digest: ${digest}

• host: Request host header, e.g., iat-api.xfyun.cn. Must be placed in the request header, and the host used in signature calculation must be completely consistent with the header in the HTTP message.
• date: Current timestamp, format is Wed, 08 Jun 2022 08:12:15 UTC. Must be placed in the request header.
• method: Request method. Supports GET, POST, DELETE, PATCH, PUT. Must be consistent with the current HTTP request method.
• path: Request path. Does not include the query string part ('?' and following). For example, when URL is '/v2/iat?a=b&c=d', only take '/v2/iat' as the path value.
• digest: Request body digest part, calculation method is "SHA256="+sha256(${body})

Note: There is a space after ':', '\n' is a newline character. HTTP/1.1 is the HTTP protocol version. If the client uses HTTP/1.0 protocol, the value should be changed to HTTP/1.0.

# 5.6.2 Calculate Signature

Calculation method: Use hmac-sha256 algorithm to calculate the signature of signature_origin_str, and perform base64 encoding.

signature = base64(hmac-sha256(${signature_origin_str}, ${api_secret}))

Where api_secret is the secret part of the key pair obtained from the platform side, and signature_origin_str is the parameters concatenated in the previous step.

# 5.6.3 Concatenate Authorization Header

authorization_raw = api_key="${api_key}", algorithm="hmac-sha256", headers="host date request-line digest", signature="${signature}"

# 5.7 Signature Generation Example

Suppose there is the following request:

• Request URL: http://iat-api.xfyun.cn/v2/iat
• Request method: POST
• User's api_key = 5ccdf2b4d1b5cdf81846697bf8bcd05d
• api_secret = B00TFRS9KDCfTrdX5JQwhVSXaFoHLy34
• Current time: Wed, 08 Jun 2022 09:00:06 UTC
• Request body content: hello world

Step 1: Then signature_origin_str should be concatenated as:

host: iat-api.xfyun.cn
date: Wed, 08 Jun 2022 09:00:06 UTC
POST /v2/iat HTTP/1.1
digest: SHA256=uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=

Step 2: The signature calculated using signature_origin_str:

rRU2FA174RdsqpdxGzrLmJ6C1CPk5GgfP7bUQToxQIw=

Step 3: Then the authorization header is:

api_key="5ccdf2b4d1b5cdf81846697bf8bcd05d", algorithm="hmac-sha256", headers="host date request-line", signature="rRU2FA174RdsqpdxGzrLmJ6C1CPk5GgfP7bUQToxQIw="

Step 4: The final request headers are:

Authorization: api_key="5ccdf2b4d1b5cdf81846697bf8bcd05d", algorithm="hmac-sha256", headers="host date request-line", signature="VhEap7PkvX7ujjx8DjBtkRZFwQDIEOc62EM+M9N+pf8="
Host: iat-api.xfyun.cn
Date: Wed, 08 Jun 2022 08:12:15 UTC
Digest: SHA256=uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=

Users can use this example to verify whether their signature algorithm implementation is correct.

# 5.8 Key Function Description

# 5.9 Authentication Failure Response Example

HTTP/1.1 403 Forbidden
Date: Thu, 06 Dec 2018 07:55:16 GMT
Content-Length: 116
Content-Type: text/plain; charset=utf-8

{
    "message": "HMAC signature does not match"
}

# 5.10 Possible Causes of Authentication Failure Analysis

Users can determine where the authentication problem lies through the httpCode returned by the server and the message field in the response body.

Troubleshooting Steps:

1. Check if api_secret is correct
2. Check if signature_origin_str format is concatenated correctly. The correct format is described in the document above. You can print parameters for comparison.
3. Check if the hmac-sha256 calculated signature length is 44. If it is 88, the string used for base64 calculation has already been hex-encoded. You need to use raw unencoded byte stream for base64 encoding.
4. Check if nginx proxy is used. Nginx defaults to using HTTP 1.0 for proxy requests, which causes the server to get HTTP version HTTP/1.0, resulting in signature calculation mismatch. Need to set nginx to use HTTP/1.1 protocol to request the server.
5. If none of the above methods solve the issue, try using packet capture tools to analyze the packet. Some frameworks may send HTTP messages that differ slightly from the code, such as host, path, and HTTP version number may not match expectations. Focus on checking whether these parameters in the packet match the corresponding parameters used in code for concatenating signature_origin_str.

# 5.11 Pseudocode

func assembleRequestHeader(requestUrl, method, body, apikey, apisecret) {
    url = urlparse(requestUrl)
    host = url.host
    path = url.path
    date = now().format('Tue, 26 Jun 2018 12:27:03 UTC')
    request-line = "$method $path HTTP/1.1"
    signature_headers = "host date request-line"
    signature_strs = "host: $host\ndate: $date\n$request-line"
    digest = ""
    
    if body != nil:
        signature_headers = "host date request-line digest"
        digest = "SHA-256=" + base64(sha256(body))
        signature_strs = "host: $host\ndate: $date\n$request-line\ndigest: $digest"
    else:
        signature_strs = "host: $host\ndate: $date\n$request-line"

    signature = base64(hmac-sha256(signature_strs, apisecret))

    authorization = 'api_key="$apikey", algorithm="hmac-sha256", headers="$signature_headers", signature="$signature"'

    return {
        "Host": host,
        "Date": date,
        "Digest": digest,
        "Authorization": authorization
    }
}

# 5.12 Sample Code for Signature Generation

# 5.12.1 Golang

package iflyauth

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/base64"
    "fmt"
    "net/url"
    "time"
)

// Build authentication headers
// @requestUrl: like http://api.xfyun.cn
// @method: GET, POST, etc....
// @body: request body
func NewAuthHeaders(requestUrl, method string, apiKey, apiSecret string, body []byte) map[string]string {
    bodySign := ""
    if body == nil {
        bodySign = sha256Base64([]byte(nil))
    } else {
        bodySign = sha256Base64(body)
    }

    bodySign = "SHA256=" + bodySign

    u, err := url.Parse(requestUrl)
    if err != nil {
        panic("parse url error" + err.Error())
    }
    host := u.Host
    date := time.Now().UTC().Format(time.RFC1123)
    if u.Path == "" {
        u.Path = "/"
    }
    requestLine := method + " " + u.Path + " HTTP/1.1"
    signUrl := fmt.Sprintf("host: %s\ndate: %s\n%s\ndigest: %s", host, date, requestLine, bodySign)

    signature := hmacSha256Base64([]byte(apiSecret), []byte(signUrl))

    authorization := fmt.Sprintf(`api_key="%s", algorithm="hmac-sha256", headers="host date request-line digest", signature="%s"`, apiKey, signature)
    return map[string]string{
        "host":          host,
        "date":          date,
        "authorization": authorization,
        "digest":        bodySign,
    }
}

func sha256Base64(b []byte) string {
    h := sha256.New()
    h.Write(b)
    return base64.StdEncoding.EncodeToString(h.Sum(nil))
}

func hmacSha256Base64(secret []byte, data []byte) string {
    h := hmac.New(sha256.New, secret)
    h.Write(data)
    return base64.StdEncoding.EncodeToString(h.Sum(nil))
}

# 5.12.2 Java

/**
 * Calculate header parameters needed for signature (HTTP interface)
 * @param requestUrl like 'http://rest-api.xfyun.cn/v2/iat'
 * @param apiKey
 * @param apiSecret
 * @method request method POST/GET/PATCH/DELETE etc....
 * @param body HTTP request body
 * @return header map, contains all headers should be set when accessing api
 */
public static Map<String, String> assembleRequestHeader(String requestUrl, String apiKey, String apiSecret, String method, byte[] body) {
    URL url = null;
    try {
        url = new URL(requestUrl);
        // Get date
        SimpleDateFormat format = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss z", Locale.US);
        format.setTimeZone(TimeZone.getTimeZone("UTC"));
        String date = format.format(new Date());
        // Calculate body digest (SHA256)
        MessageDigest instance = MessageDigest.getInstance("SHA-256");
        instance.update(body);
        String digest = "SHA256=" + Base64.getEncoder().encodeToString(instance.digest());
        // date = "Thu, 19 Dec 2024 07:47:57 GMT";
        String host = url.getHost();
        int port = url.getPort(); // port > 0 means url contains port
        if (port > 0) {
            host = host + ":" + port;
        }
        String path = url.getPath();
        if ("".equals(path) || path == null) {
            path = "/";
        }
        // Build parameters needed for signature calculation
        StringBuilder builder = new StringBuilder()
            .append("host: ").append(host).append("\n")
            .append("date: ").append(date).append("\n")
            .append(method).append(" ").append(path).append(" HTTP/1.1").append("\n")
            .append("digest: ").append(digest);
        Charset charset = Charset.forName("UTF-8");

        System.out.println(builder.toString());
        // Use hmac-sha256 to calculate signature
        Mac mac = Mac.getInstance("hmacsha256");
        // System.out.println(builder.toString());
        SecretKeySpec spec = new SecretKeySpec(apiSecret.getBytes(charset), "hmacsha256");
        mac.init(spec);
        byte[] hexDigits = mac.doFinal(builder.toString().getBytes(charset));
        String sha = Base64.getEncoder().encodeToString(hexDigits);
        // Build header
        String authorization = String.format("hmac-auth api_key=\"%s\", algorithm=\"%s\", headers=\"%s\", signature=\"%s\"", apiKey, "hmac-sha256", "host date request-line digest", sha);
        Map<String, String> header = new HashMap<String, String>();
        header.put("authorization", authorization);
        header.put("host", host);
        header.put("date", date);
        header.put("digest", digest);
        System.out.println("header " + header.toString());
        return header;
    } catch (Exception e) {
        throw new RuntimeException("assemble requestHeader error:" + e.getMessage());
    }
}

# 5.12.3 JavaScript

function assembleRequestHeader(host, path, method, apiKey, apiSecret, body) {
    var date = new Date().toGMTString()
    var algorithm = 'hmac-sha256'
    var headers = 'host date request-line digest'
    var digest = "SHA256=" + CryptoJS.enc.Base64.stringify(CryptoJS.SHA256(body))
    var signatureOrigin = `host: ${host}\ndate: ${date}\n${method} ${path} HTTP/1.1\ndigest: ${digest}`
    var signatureSha = CryptoJS.HmacSHA256(signatureOrigin, apiSecret)
    var signature = CryptoJS.enc.Base64.stringify(signatureSha)
    var authorization = `api_key="${apiKey}", algorithm="${algorithm}", headers="${headers}", signature="${signature}"`

    return {
        // 'Host': host,
        'X-Date': date, // In JS, may not be able to set Date header, use X-Date
        'Authorization': authorization,
        'Digest': digest,
    }
}

var headers = assembleRequestHeader('rest-api-gz.xfyun.cn', '/v2/tts', 'POST', 'xxxxxxxxxxxxxxx', 'xxxxxxxxxxxxxxx', '')

# 5.12.4 Python 3

from datetime import datetime
from wsgiref.handlers import format_date_time
from time import mktime
import hashlib
import base64
import hmac
from urllib.parse import urlparse
import sys

# Calculate sha256 and encode to base64
def sha256base64(data):
    sha256 = hashlib.sha256()
    sha256.update(data)
    digest = base64.b64encode(sha256.digest()).decode(encoding='utf-8')
    return digest

# Build auth request url
def assemble_auth_header(requset_url, method="GET", api_key="", api_secret="", body=""):
    u = urlparse(requset_url)
    host = u.hostname
    path = u.path
    now = datetime.now()
    date = format_date_time(mktime(now.timetuple()))
    digest = "SHA256=" + sha256base64(body.encode())
    # date = "Thu, 12 Dec 2019 01:57:27 GMT"
    signature_origin = "host: {}\ndate: {}\n{} {} HTTP/1.1\ndigest: {}".format(host, date, method, path, digest)
    # print(signature_origin)
    signature_sha = hmac.new(api_secret.encode('utf-8'), signature_origin.encode('utf-8'),
                             digestmod=hashlib.sha256).digest()
    signature_sha = base64.b64encode(signature_sha).decode(encoding='utf-8')
    authorization = "api_key=\"%s\", algorithm=\"%s\", headers=\"%s\", signature=\"%s\"" % (
        api_key, "hmac-sha256", "host date request-line digest", signature_sha)
    # print(authorization_origin)
    headers = {
        "host": host,
        "date": date,
        "authorization": authorization,
        "digest": digest,
    }
    return headers

requrl = "http://rest-api.xfyun.cn/v2/itr"

import requests
import json
import time

body = {
    "common": {},
    "business": {},
    "data": {}
}
now = time.time()
bds = json.dumps(body)

headers = assemble_auth_header(requrl, method="POST", api_key="xxxxxxxxx",
                            api_secret="xxxxxxxxxxxxx", body=bds)
resp = requests.post(requrl, headers=headers, data=bds)

print(resp.status_code, resp.text)

# 5.12.5 PHP

class http_test {
    function tocurl($url, $header, $content) {
        $ch = curl_init();
        if (substr($url, 0, 5) == 'https') {
            curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false); // Skip certificate check
            curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);  // Check if SSL encryption algorithm exists in certificate
            curl_setopt($ch, CURLOPT_SSLVERSION, 1);
        }
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_URL, $url);
        if (is_array($header)) {
            curl_setopt($ch, CURLOPT_HTTPHEADER, $header);
        }
        curl_setopt($ch, CURLOPT_POST, true);
        if (!empty($content)) {
            if (is_array($content)) {
                curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($content));
            } else if (is_string($content)) {
                curl_setopt($ch, CURLOPT_POSTFIELDS, $content);
            }
        }
        $response = curl_exec($ch);
        $error = curl_error($ch);
        // var_dump($error);
        if ($error) {
            die($error);
        }
        $header = curl_getinfo($ch);

        curl_close($ch);
        $data = array('header' => $header, 'body' => $response);
        return $data;
    }

    function xfyun() {
        $app_id = "XXXXX";
        $api_sec = "XXXXXXXXX";
        $api_key = "XXXXXXXXX";
        $resource = "resource/xx";
        $url = "xx";
        $host = "xx.xxx.cn";  # Request host
        $path = "/v2/xxx";    # Request path
        
        // Body assembly
        $body = json_encode($this->getBody($app_id, $resource));

        // Assemble HTTP request headers
        // $date = gmstrftime("%a, %d %b %Y %H:%M:%S %Z", time());
        $date = gmdate('D, d M Y H:i:s') . ' GMT';

        $digestBase64 = "SHA-256=" . base64_encode(hash("sha256", $body, true));

        $builder = sprintf("host: %s\ndate: %s\nPOST %s HTTP/1.1\ndigest: %s", $host, $date, $path, $digestBase64);

        $sha = base64_encode(hash_hmac("sha256", $builder, $api_sec, true));

        $authorization = sprintf("api_key=\"%s\", algorithm=\"%s\", headers=\"%s\", signature=\"%s\"", $api_key, "hmac-sha256", "host date request-line digest", $sha);

        $header = [
            "Authorization: " . $authorization,
            'Content-Type: application/json',
            'Accept: application/json;version=1.0',
            'Host: rest-api.xfyun.cn',  // Replace with actual domain host
            'Date: ' . $date,
            'Digest: ' . $digestBase64
        ];

        $response = $this->tocurl($url, $header, $body);

        var_dump($response['body']);
    }
}

# 6. FAQ

# 6.1 Platform-Related

Q1: Is the Astron Workflow Platform free to use?

Yes, the Astron Workflow Platform is free to use.

Q2: What is the maximum number of agents a single account can create?

100 agents.

# 6.2 Prompt Agent–Related

Q3: What's the difference between a Prompt Agent and a Workflow Agent?

Prompt Agent: Functions more like an autonomous "executor." You give it a prompt persona and a goal (for example, "help me plan a weekend trip"), and it will independently plan the steps, call tools (checking the weather, searching for attractions, comparing prices), adapt to changes, and ultimately deliver a solution. It emphasizes intelligence and adaptability.

Workflow Agent: Functions more like a preset "assembly line." You need to predefine the rules and sequence for each step in advance, and the agent strictly follows this process during execution. It emphasizes standardization, automation, and predictability.

# 6.3 Workflow Agent–Related

Q4: Does the platform support multi-agent collaboration?

Currently, a Workflow Agent can nest another Workflow Agent using the Workflow Node. Note that the referenced workflow must be published before it can be used in a Workflow Node.

Q5: Can the Astron Workflow Platform be quickly embedded into a mini program or other systems via JS?

Yes. The platform currently supports publishing as an API, which can be integrated and called via API.

Q6: Does the default intent in the Decision Node need to be connected to a downstream node? Is this required?

Yes, the default intent must also be connected, functioning as an independent branch.

Q7: Does the platform offer workflow templates, such as for customer service scenarios?

Yes. In addition to that, the platform offers a rich variety of workflow scenario templates. You can find them at: Platform Homepage → My Agents → Create Agent → Workflow Creation → [choose from multiple available templates].

Q8: Can workflow templates be called directly via an interface?

Yes — after creating a workflow from a template, you can publish it as an API and call it accordingly.

Q9: What should I do if the LLM Node's output doesn't match expectations? Or how can I get the model to output in a specific template or format?

This is typically a prompt-related issue. Try optimizing your prompt — for example, by including a sample output in the prompt so the model strictly follows that format when generating its response.

Q10: Does the model remember the context of a Workflow Agent's conversation? How do I enable conversation history to work in the debug interface?

Simply enable Conversation History in the LLM Node, where you can also set the number of conversation turns to include.

Q11: I enabled Conversation History in the Workflow Agent's LLM Node, but it doesn't seem to be working — the "chat history" field is missing from the input in the execution results. What's going on?

This is most likely because the model's parameter settings are limiting the input character count, which can happen if too many turns or too much content is configured. Try increasing the model's Max Reply Length and reducing the number of conversation turns.

Q12: What's the difference between the System Prompt and User Prompt in a Workflow Agent's LLM Node?

The System Prompt is a preset, global instruction used to define the model's behavioral framework, role identity, capability boundaries, and output style.

The User Prompt refers to a specific task with a clearly defined scenario.

Q13: Does the model used in a Workflow Agent's LLM Node support web search?

No. If you need web search capability, add a Tool Node and select the Web Search tool.

Q14: How does the Agent Intelligent Decision Node in a Workflow Agent call plugins?

First, make sure the relevant plugins have been added to the Intelligent Decision Node — the node can then independently reason through the user's request and decide which added plugin to call.

You can also explicitly instruct the Agent Decision Node in the prompt regarding under what conditions it should call a specific plugin.

Q15: What should I do if a Workflow Agent's Agent Intelligent Decision Node throws a timeout error?

Currently, the gateway will disconnect and return a timeout error if no response is returned within 2 minutes. Try using a Message Node to stream the reasoning process as output instead — note that you'll need to enable the Streaming Output toggle for this to work.

Q16: What should I do if a Workflow Agent's Agent Decision Node fails (e.g., the model returns reasoning content in an incorrect format, or invalid plugin parameters)?

Check whether the LLM's output content is well-formed and correct (for example, check for unexpected characters in JSON content), and confirm that the relevant plugins have been added to the Agent Decision Node.

Q17: Why does a Workflow Agent's Workflow Node fail to produce output, or fail entirely?

Common causes include: (1) The referenced workflow is complex and produces a large amount of output, causing a timeout — since the Workflow Node doesn't support streaming output, this results in a failed output; (2) Check whether the referenced workflow contains a Q&A Node — if it does, the Workflow Node does not support output in that case.

Q18: What causes the error "Workflow engine node protocol validation failed" during workflow import?

This error can occur for several reasons: (1) The imported workflow includes a model belonging to someone else, and that model (Model ID) isn't available under your own account; (2) The imported workflow includes a tool belonging to someone else, and that tool (Plugin ID) isn't available under your own account; (3) The imported workflow includes a knowledge base belonging to someone else, and that knowledge base (Knowledge ID) isn't available under your own account. The underlying cause is generally a missing resource that exists in the original account but not in yours.

Q19: A Workflow Agent's node is taking too long to run / execution time is too long — how can I speed it up?

Long node execution times are usually caused by the model itself. Try switching to a smaller model to increase output speed, or use a model without a reasoning/chain-of-thought pipeline. You can also optimize your prompt to reduce unnecessary reasoning steps, which cuts down on processing time. It's also recommended to add a Message Node after this node to enable streaming output, which can reduce perceived wait time.

Q20: What should I do if a Workflow Agent's Code Node makes a network request but returns no output? How can I make network requests?

The Code Node does not support network requests. If you need to make network requests, go to Homepage → Resource Management → Create Plugin to set this up.

Q21: Why does a node fail to produce proper output even though the workflow runs without any errors? For example, why might an Iteration Node fail to output correctly?

Check the execution results and verify whether there's an issue with that node's input — correct input is required in order to produce the corresponding output.

Q22: How can I iterate and optimize a task?

Create a Workflow Agent and use the Iteration Node. The Iteration Node allows users to configure tasks or operations that repeat — similar to a for loop in programming languages. It iterates over a known array, executing the same set of steps for each element. With each iteration, the workflow executes each node within the canvas in sequence.

Q23: Can a Workflow Agent's Q&A Node enforce a timeout during API calls — for example, requiring a response within a certain time, after which it becomes invalid?

Yes. This can be configured under Reply Mode settings in the Q&A Node, via the Conversation Timeout setting.

Q24: How can I upload images, audio, PDF, Word, PPT, Excel, or other files within an agent?

The Start Node supports uploading multimodal files such as images, audio, PDF, Word, PPT, Excel, and TXT, and allows you to define a custom variable for the file. Once uploaded to the platform, these files are automatically converted into a URL, with no expiration on storage. The file can then be parsed and processed using the platform's related plugin tools. For API calls, please refer to the "API Calls – File Upload" section of the platform's official documentation.

Q25: Can audio files only be uploaded via the Start Node? Can audio be uploaded during a Q&A interaction?

Audio files can only be uploaded via the Start Node; uploading audio during a Q&A interaction is not supported.

Q26: What does "streaming output" mean?

Streaming output: Rather than generating the entire response at once, the model generates it word by word or piece by piece (typically in units of tokens or word fragments). Each small piece of generated content is immediately transmitted over the network to the client (such as your browser or app), which can display or process these partial results in real time. This means generation and transmission happen in parallel.

The opposite of this is non-streaming output: the model must first fully generate the entire response internally, then package all of the content together and return it to the client in a single, complete HTTP response. This means generation and transmission happen sequentially, and the user must wait for the entire process to finish before seeing any result.