Method, system and device for automatic generation of interaction cards for agent skills
By merging the initial process nodes of Agent skills and automatically rendering interactive cards, the problem of cumbersome interaction steps caused by too many nodes in traditional solutions is solved, achieving efficient user interaction and plug-and-play capabilities.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- SHENZHEN RABBIT PREMISE TECH CO LTD
- Filing Date
- 2026-05-15
- Publication Date
- 2026-06-12
AI Technical Summary
In scenarios involving the development of intelligent agent skills and the construction of automated workflows driven by large language models, traditional process generation solutions result in an excessive number of nodes and overly fine granularity, leading to cumbersome and lengthy user interaction steps. They also lack effective node aggregation logic, which affects operational efficiency and user experience.
By acquiring the initial process nodes of the Agent skill, batch processing is performed using preset merging rules. Node merging is executed according to the labeling status to generate merged business nodes. Based on functional description information, input parameter information, and associated upstream output parameter fields, an interactive card set is automatically generated to achieve node merging and automatic card rendering.
It significantly reduces user interaction steps, achieving a leap forward in front-end experience. The generated interactive cards have high availability and plug-and-play capabilities, solving the problem of cumbersome interaction steps in traditional solutions, and eliminating the need for manual configuration of UI fields.
Smart Images
Figure CN122196163A_ABST
Abstract
Description
Technical Field
[0001] This application relates to the field of artificial intelligence technology, and provides a method, system, and device for automatically generating interactive cards for Agent skills. Background Technology
[0002] In the current scenario of developing intelligent agent skills and automating workflows driven by large language models, traditional process generation solutions typically employ a hard binding relationship where process nodes correspond one-to-one with underlying API interfaces.
[0003] In this model, each atomic-level interface call needs to be represented as an independent node in the visualization canvas, resulting in an excessively large number of nodes and overly fine-grained execution granularity throughout the skill process. For end users, this fine-grained mapping directly leads to extremely cumbersome and lengthy interaction steps for the agent when performing tasks. Users need to frequently click or confirm numerous intermediate calculations that do not require manual intervention, severely impacting the operational efficiency of the intelligent agent's skills and the user experience. Furthermore, due to the lack of effective node aggregation logic, developers often need to manually define complex UI and AI logic linkages in the visualization canvas, further exacerbating the disconnect between the research and development process. Summary of the Invention
[0004] This application provides a method, system, and device for automatically generating interactive cards for agent skills, solving the technical problem that the interaction steps of agents when performing tasks are extremely cumbersome and lengthy in traditional solutions.
[0005] A method for automatically generating interactive cards for agent skills, the method comprising: Obtain the initial process nodes of the Agent skill and traverse the initial process nodes; The initial process nodes are processed in batches according to the preset merging rules, and a node merging operation is performed according to the labeling status of each initial process node to obtain the merged business nodes; wherein, the merging rule takes the detection of target interaction label as the merging termination condition. Obtain the functional description information, input parameter information, and associated upstream output parameter fields corresponding to the business node; based on the functional description information, input parameter information, and upstream output parameter fields, and in conjunction with the matching project design theme, generate a corresponding set of interactive cards for the business node; Extract the input parameter data from the set of interactive cards and synchronously supplement the input parameter data into the pre-dependency description of the business node.
[0006] An automatic generation system for interactive cards of agent skills, the system comprising: The merge rule configuration unit is used to maintain the node intelligent merge rules, wherein the merge rules include using the target interaction annotation as the merge termination condition; The node intelligent merging unit is used to process the initial process nodes in batches according to the merging rules, and to perform node merging operations according to the labeling status of each initial process node to obtain the merged business nodes. The node information generation unit is used to obtain the functional description information, input parameter information and associated upstream output parameter fields corresponding to the business node; An interactive card automatic generation unit is used to generate a corresponding set of interactive cards for the business node based on the function description information, the input parameter information, the associated upstream output parameter fields, and the project design theme. The synchronization unit is used to extract the input parameter data from the interaction card set and update the prerequisite dependency descriptions of the business nodes.
[0007] A computer device includes a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the steps of the method.
[0008] By employing the aforementioned dynamic batch merging rules based on interactive annotations and the automatic card rendering mechanism that links multi-dimensional parameter features, the traditional 1:1 interface-node mapping deadlock is cleverly broken. This not only significantly reduces the cumbersome steps that Agent skills present to users during execution, achieving a leap forward in front-end experience; but also enables end-to-end, second-level generation of interactive cards that highly align with business scenarios and enterprise visual standards without requiring any manual front-end code writing or UI field configuration. This ensures that the automatically generated intelligent agent skills truly possess high availability and plug-and-play practical capabilities, thereby solving the technical problem of lengthy interactions caused by hard binding of interfaces and nodes in traditional solutions, which leads to extremely cumbersome and lengthy interaction steps for Agents when executing tasks. Attached Figure Description
[0009] To more clearly illustrate the technical solutions of the embodiments of this application, the drawings used in the description of the embodiments of this application will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.
[0010] Figure 1 This is a flowchart illustrating a method for automatically generating interactive cards for Agent skills in an embodiment of this application; Figure 2 This is a schematic diagram of a working interface of a visualization orchestration canvas for an intelligent agent skill in an embodiment of this application; Figure 3 This is a structural schematic diagram of a computer device according to this application. Detailed Implementation
[0011] The technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.
[0012] In one embodiment, such as Figure 1 As shown, a method for automatically generating interactive cards for Agent skills is provided, which is used in an automatic interactive card generation system for Agent skills. The method includes the following steps: S10. Obtain the initial process nodes of the Agent skill and traverse the initial process nodes; S20. Process the initial process nodes in batches according to the preset merging rules, and perform node merging operations according to the annotation status of each initial process node to obtain the merged business nodes; wherein, the merging rule takes the detection of target interaction annotation as the merging termination condition. S30. Obtain the functional description information, input parameter information, and associated upstream output parameter fields corresponding to the business node; S40. Based on the functional description information, the input parameter information, and the upstream output parameter fields, and in combination with the matching project design theme, generate the corresponding set of interactive cards for the business nodes; S50. Extract the input parameter data from the interaction card set and synchronously supplement the input parameter data into the pre-dependency description of the business node.
[0013] Specifically, this embodiment is mainly applied to the scenario of agent skill development and workflow automation construction driven by Large Language Model (LLM). In traditional process generation schemes, process nodes are usually hard-bound to the underlying API interfaces in a one-to-one correspondence. This results in the entire skill process having an excessively large number of nodes and overly fine granularity, making the interaction steps for the front-end user extremely cumbersome and lengthy. To solve this pain point, the system first obtains the initial process nodes of the Agent skill (these nodes usually represent the unmodified order of underlying interface calls), and the execution engine initiates a systematic traversal of the initial process nodes across the entire chain.
[0014] During the traversal, the system does not forcibly pile up all nodes. Instead, it processes the initial process nodes in batches according to preset merging rules. It performs node merging operations based on the annotation status of each initial process node, thereby aggregating overly fragmented interface nodes upwards to obtain merged business nodes with a granularity more aligned with human cognition and operational habits. In this process, the merging rule terminates the merging process upon detecting a target interaction annotation. In both physical and business terms, a target interaction annotation represents a node whose execution must break the machine's silent state, forcibly requiring human intervention (e.g., high-risk operations requiring manual confirmation, or dynamic parameters that must be provided by the user in real time). Through this rule, the system cleverly encapsulates and folds continuous, purely background computation nodes that do not require human interaction. Once a node with a target interaction annotation is detected, the merging of the current batch is immediately stopped, serving as a physical isolation boundary. This perfectly balances the extreme simplification of the front-end process with the absolute completeness of key interaction control nodes.
[0015] After completing the physical merging and optimization of the underlying node granularity, the system then enters the automated mapping and construction phase of the front-end UI assets. The system obtains the functional description information corresponding to the business node (representing the macro business intent of the node), the input parameter information (representing the data raw materials that the current node is extremely lacking for successful execution and that need to be requested from the user), and the associated upstream output parameter fields (representing the result data that has been calculated and generated by the preceding node and can be displayed and reused by the current node).
[0016] After gathering all the aforementioned feature information spanning business logic and data flow dimensions, the system automatically renders and generates corresponding sets of interactive cards for each business node based on functional description information, input parameter information, and upstream output parameter fields, combined with the matching project design theme (i.e., pre-defined global UI visual specifications and interaction styles). This processing mechanism instantly transforms the originally tedious and obscure underlying network request parameters into modular front-end graphical interactive interfaces (i.e., interactive cards) with standard visual styles and containing input and display elements, completely eliminating the enormous workload of manually configuring UI form styles for each node in traditional development.
[0017] Finally, the system extracts the input parameter data from the set of interactive cards and synchronously supplements the pre-dependency descriptions of the business nodes. This is equivalent to establishing a data feedback loop at the system's bottom layer, formally announcing to the backend execution engine that the missing parameters of the current node have found a reliable front-end data collection channel (i.e., the generated cards), thus completing the logical self-consistency of data lineage and dependency completion within a single node.
[0018] As can be seen, this embodiment cleverly breaks the traditional 1:1 interface-node mapping deadlock by using the dynamic batch merging rules based on interactive annotations and the card automatic rendering mechanism that links multi-dimensional parameter features. This not only significantly reduces the cumbersome steps that Agent skills throw at users during execution, achieving a leap forward in front-end experience; but also achieves end-to-end, second-level generation of interactive cards that highly align with business scenarios and enterprise visual specifications without requiring any manual front-end code writing or UI field configuration. This makes the automatically generated intelligent agent skills truly possess high availability and plug-and-play practical capabilities.
[0019] In one embodiment, step S20, which involves processing the initial process nodes in batches according to a preset merging rule and performing a node merging operation based on the marked status of each initial process node to obtain the merged business nodes, includes the following steps: S21. Starting from the first node of the initial process node, check whether the currently traversed node has a user confirmation label or a user input label as the target interaction label; S22. If the current traversed node does not have a user confirmation label and does not have a user input label, then the current traversed node is included in the current merge batch, and the subsequent nodes are traversed. S23. If the currently traversed node has a user confirmation label or a user input label, then terminate the current merging batch and merge the nodes already included in the current merging batch to generate a business node.
[0020] Specifically, in the underlying architecture of complex intelligent agent skills, the initially generated interface call chain often presents as a highly fine-grained directed acyclic graph (DAG). Directing all these fragmented nodes directly to the front end would result in a poor user experience. To achieve intelligent and secure node dimensionality reduction, the system introduces a dynamic graph aggregation algorithm based on state machine breakpoints. The system's algorithm probe slides along the topological chain of the underlying interface call flow, starting from the first node of the initial process node and gradually moving backward, verifying the state attributes of the currently traversed nodes. Specifically, it checks whether user confirmation or user input annotations exist as target interaction annotations. At the physical and business logic level, user confirmation annotations represent high-risk operations such as database state changes, fund transfers, or sensitive data submissions at the current underlying interface. As a blocking security interceptor, it forces a pause and waits for manual authorization during actual runtime. User input annotations indicate that the current node has isolated required parameters that cannot be inherited or derived from upstream parameters. As a data breakpoint, it requires dynamic variables to be provided in real-time by the external environment (i.e., the end user). These two types of annotations together constitute the insurmountable target interaction annotation boundary of the system.
[0021] As the probe continues its traversal, if the currently traversed node lacks both user confirmation and user input annotations, this signifies, from a computer engineering execution perspective, that the node is a purely background, silent processing node. As a concrete example, these nodes might correspond to internal system data format conversions, silent queries of intermediate data, or background silent verification of access permission tokens; their execution requires absolutely no human intervention or perception. At this point, the system opens a logical container in memory called the current merge batch, includes the physical call pointer of the currently traversed node in this batch, and drives the probe to continue traversing subsequent nodes, thereby continuously expanding the scope of the current silent processing task at the logical level.
[0022] However, the expansion of this logical container must have strict safety boundaries. If, during the probe's sliding process, the currently traversed node contains user confirmation or input annotations, the system's underlying control engine will immediately recognize a hard state machine breakpoint that must be blocked to await asynchronous human interaction. At this point, the system will immediately trigger an interrupt command, terminating the continued expansion of the current merging batch. Subsequently, the system will perform closure merging on all silent processing nodes already included in the current merging batch at the physical presentation level, packaging them into a coarser-grained macroscopic module, thereby generating the business node. This method of stopping and packaging upon encountering a breakpoint ensures that all operations requiring human review and authorization or information input are strictly isolated outside the black box of silent merging, providing an absolutely accurate physical target for subsequent interactive card rendering as an independent node on the front end.
[0023] As can be seen, in this embodiment, by traversing using a logical container starting from the first node, silent nodes without interactive annotations are continuously included in the merging batch. The batch is immediately terminated and node merging is executed when user confirmation annotations or user input annotations representing high-risk risk control or missing parameters are detected. This feature processing logic cleverly utilizes known interaction and risk control boundaries as topology partitioning walls, precisely separating the continuous backend silent operations from the necessary frontend manual intervention steps in the underlying graph calculation model. While maximizing the compression of redundant underlying interface nodes to greatly simplify frontend user interaction steps, it absolutely ensures from the root of the algorithm mechanism that all risk control and data collection links requiring manual intervention are not swallowed up or omitted by the silent black box, perfectly balancing the extreme simplification of the automated workflow's granularity with the stringent bottom line of enterprise-level business security control.
[0024] In one embodiment, when generating a business node, the interface call chain corresponding to each initial process node within the business node is preserved, and the execution order and dependencies of each interface are maintained.
[0025] In complex enterprise-level microservice architectures, a macro-level business action is often composed of multiple high-frequency, fine-grained atomic API interfaces strung together at the underlying level. In the previous merging step, to optimize the user experience, the system encapsulated and collapsed continuous, unattended, purely background silent processing nodes into a coarse-grained business node at the physical level of the front-end presentation. However, if this merging is merely a simple and crude interface swallowing or reorganization, it can easily lead to logical breaks in the underlying network communication and parameter penetration failures. Therefore, when generating business nodes, the system enforces a front-end dimensionality reduction and back-end fidelity preservation isolation encapsulation strategy in the underlying engine.
[0026] The system strictly preserves the interface call chain corresponding to each initial process node within the business node. At the physical and logical levels of network communication, the interface call chain represents the complete addressing path, protocol header, data payload, and underlying state machine transition pointers when the Agent initiates a real request (such as an HTTP POST / GET request or an RPC remote call) to each target microservice. For example... Figure 2 As shown, this retention means that what the system presents to the user on the front end is only a merged black box business node (e.g., displayed as VIP registration channel verification), but in the underlying runtime environment, this black box still completely nests all the independent network request instruction sets before it was folded.
[0027] Furthermore, while preserving the link, the system absolutely maintains the execution order and dependencies of each interface. In computer data structures, the execution order and dependencies are visualized as a local subgraph of a directed acyclic graph (DAG) with a strict temporal order and data flow direction. As a specific business scenario example, suppose a merged business node contains three silent initial process nodes: first, "verify the access token (Auth_Token)"; second, "query the user level based on the token (UserLevel)"; and finally, "calculate the order amount based on the level". The system will strictly adhere to this temporal topology, which is rigidly constrained by business logic, and schedule them sequentially. It will never execute these nodes concurrently simply because they are packaged within the same macro-business node, nor will it allow arbitrary reversals of the call order. It will also ensure that the temporary token returned by the first interface is accurately and dynamically injected as an input parameter into the request body of the second interface. This deep internal logic encapsulation, without absolute limitations on the specific data organization form and underlying scheduling protocol, essentially establishes a highly faithful microservice execution microenvironment for the automatically generated macro-business nodes.
[0028] As can be seen, in this embodiment, by fully preserving the interface call chain of the initial process nodes nested within them in the underlying architecture when generating macro-level business nodes on the front end, and strictly maintaining the execution order and parameter dependencies between the original microservice interfaces, this processing logic constructs a visual folding and physical fidelity mechanism that completely decouples the presentation layer from the execution layer. Its principle lies in using black-box encapsulation technology to shield the complexity of the underlying, fragmented interfaces while encapsulating the original network communication contract as an immutable kernel within a black box. While significantly optimizing the granularity of the business node front-end presentation and simplifying the user interaction layer, it fundamentally prevents fatal system crashes caused by node merging and reorganization, such as disordered execution timing of underlying code and broken parameter dependencies. This perfectly ensures the absolute stability of the automatically generated Agent skills in the complex enterprise-level microservice environment and the correct execution of business logic.
[0029] In one embodiment, after terminating the current merge batch, the method further includes the following steps: S60. Starting from the node that triggers the termination of the current merge batch and has a user confirmation label or user input label, start the traversal of the next merge batch.
[0030] Specifically, in the process of automated dimensionality reduction and graph computation of complex Agent skill underlying workflows, when the system's underlying traversal probe (i.e., logical sliding window) encounters an interactive node with strong human intervention attributes and triggers physical blocking and batch termination, the system faces the engineering control challenge of seamlessly connecting subsequent unprocessed topology links. This embodiment provides an in-depth definition of the breakpoint resumption and state machine reset mechanisms in graph traversal algorithms. In the underlying scheduling logic of computer programs, once the current merging batch is forcibly terminated, the system has already successfully encapsulated the preceding continuous silent interfaces into a black-box business closure in memory. At this time, the node that triggered the termination action, marked with user confirmation or user input, not only represents a physical barrier between human and computer interaction in terms of business, but also represents a crucial anchor point in graph theory data structures (such as DAG).
[0031] To ensure the integrity of traversing the entire topology, the system's control logic does not arbitrarily jump to the next unknown memory address after terminating the merging process, nor does it discard the boundary node. Instead, it strictly follows the edge pointing relationships of the topology graph, using the node with user confirmation or user input annotations as the absolute reference starting point, and reinitializes the probe's state to begin traversing the next merging batch. As a specific business scenario example, suppose the underlying microservice call sequence is: "Silent Identity Verification -> Silent Balance Inquiry -> High-Risk Fund Transfer (with User Confirmation Annotation) -> Silent Log Recording." After merging the first two silent nodes, the traversal probe is precisely blocked by the "High-Risk Fund Transfer" node. At this point, the system immediately uses the pointer of the data structure containing the "High-Risk Fund Transfer" node as the absolute starting point of the new batch (because it has its own annotation, it will be independently retained as an interaction boundary), and drives the probe to smoothly transition to the subsequent silent log recording node along the pointers dependent on network communication, thus incorporating the subsequent silent nodes into the newly created merging batch container. This physical-level pointer anchoring and context state switching, without absolute limitations on the specific data structure organization and queue stacking methods, essentially provides a rigorous anti-omission cursor control protocol for the automated graph merging engine.
[0032] As can be seen, in this embodiment, after terminating the current merging batch, the node that triggered the termination operation and has strong interaction or risk control annotation is strictly used as the starting point of a new memory cursor to start the feature processing logic for the next merging batch traversal. When performing highly complex interface merging and dimensionality reduction, the fatal engineering risks of missing detached nodes or broken underlying call chains caused by batch interruption and context switching are completely eliminated from the root of the graph traversal algorithm. This absolutely ensures that the enterprise-level agent skills with a large microservice interface group can achieve full topology physical coverage and absolute continuity of business logic links during fully automatic optimization and generation.
[0033] In one embodiment, after obtaining the service node, the method further includes: S70. Parse the interface call relationships contained in the business nodes and automatically generate function names and prerequisite dependency descriptions for the business nodes.
[0034] Specifically, after the system's underlying state machine breakpoint mechanism completes the physical merging of fine-grained initial process nodes, the resulting macro-level business node in computer memory is essentially still a black box interwoven with multiple discrete code logic segments and network request pointers. To enable this highly abstract backend execution module to be recognized by the frontend interaction system and to ensure data consistency during execution, the system must bridge the gap between code and business semantics, endowing it with a structured metadata profile. The system first drills down into the business node, parsing the interface call relationships contained within it. In the physical sense of software engineering and graph computing, interface call relationships refer to the directed edges and execution sequence topology of data flow between various atomic-level API interfaces encapsulated within the current black box. As a concrete example, it precisely defines that "Interface A (identity authentication)" must be called before "Interface B (level query)," and the Token string output by Interface A must be accurately mapped to the input parameter payload in the request header of Interface B. The system comprehensively sorts out and extracts this intricate internal microservice collaboration contract by calling underlying syntax tree analysis or data lineage tracing algorithms.
[0035] After gaining a deep understanding of the internal operating mechanisms of the nodes, the system automatically generates function names for business nodes based on the semantic summarization capabilities of the Large Language Model (LLM) or its built-in natural language mapping templates. Function names are highly condensed, standardized identifiers that conform to human natural language intuition and the context of the business scenario. For example, after analyzing the URL path (such as / identifier) and operational attributes of internal interfaces, the system translates and encapsulates them into string text such as "User Identification" or "Department Number Generation and Push," which directly constitutes the core title bar data presented to end users or developers on the subsequent front-end visualization canvas.
[0036] Meanwhile, the system not only focuses on the semantic expression of business nodes but also pays close attention to their runtime physical security boundaries, thereby automatically generating pre-dependency specifications for business nodes. In the underlying system architecture, these pre-dependency specifications are essentially a data access state machine checklist that must be passed before the current macro-level business node is awakened and executed. When parsing internal interface call relationships, the system precisely calculates which required parameters cannot be self-sufficient within the node (i.e., cannot be obtained through connections between internal interfaces) and must therefore be retrieved from external sources (i.e., upstream business nodes or global context variables). The system aggregates, deduplicates, and standardizes the structure of these gaps, forming explicit parameter dependency contracts (e.g., declaring "must depend on parameters of type Object passed from upstream node"). The specific data format is not strictly limited here; its core purpose is to set hard pre-conditions for the workflow engine's operation.
[0037] In this embodiment, an algorithm automatically extracts concise natural language function names and rigorous parameter pre-dependency descriptions. This transforms the traditional, arduous manual work—heavily reliant on human engineers to manually read API documentation and write node comments and parameter connections—into a machine cognitive process automatically derived from the underlying data flow network. This not only endows the highly abstract aggregation black box with human-readable standardized semantic identifiers, completely bridging the cognitive gap between backend code and frontend visualization, but also precisely anchors the external data raw materials necessary for the execution of this node from the root of data flow. This provides an extremely solid, omission-proof structured parameter foundation for the dynamic rendering of subsequent interactive cards and the secure, error-free execution of the entire workflow.
[0038] In one embodiment, step S40, which involves generating a corresponding set of interaction cards for the business node, includes the following steps: S41. Construct the input component of the parameter information to be input as the interactive card set; S42. Construct upstream output parameter fields as information display components in the interactive card set; S43. Generate textual guidance information based on functional description information, and write the textual guidance information into the interaction card set; S44. Based on the project design theme, configure the style layout of input components, information display components, and text guidance information in the interactive card set to obtain the final interactive card set.
[0039] Specifically, after merging the graph computation topology of the underlying business workflow, the system faces the technical challenge of transforming highly abstract, unreadable backend API data contracts into a graphical interface that frontend users can intuitively operate. This embodiment details how the intelligent agent system bridges the gap between code logic and visual presentation, achieving fully automated mapping and assembly of multimodal UI assets. In the system's execution flow, the underlying data breakpoints are first parsed, and the input parameter information is constructed as an input component in the interactive card set. In the physical sense at the computer level, the input parameter information is the data payload that must be carried in the upcoming network communication protocol (such as an HTTP POST request) but is currently missing in the memory environment. After accurately extracting it, the system uses the underlying type mapper to forcibly convert its physical data type into the frontend visual input component. As a specific example, in the "department registration" business scenario, if the underlying input parameters are strictly constrained to be a long integer ID number or a string type real name and mobile phone number, the system will automatically construct the corresponding highlighted text input box control or numeric keyboard wake-up control, which serves as the physical interaction anchor point for dynamically collecting business variables from the end user.
[0040] However, in real-world human-computer interaction scenarios, an interactive card containing only a blank input box often feels abrupt and lacks context for users, reducing conversion rates. To improve the usability and business relevance of interactive cards, the system not only focuses on "what needs to be asked of the user" but also pays close attention to "what needs to be shown to the user." Therefore, the system backtracks along the dependency chain of the directed acyclic graph, constructing upstream output parameters as information display components within the interactive card set. These upstream output parameters represent the results data returned by the front-end silent processing nodes after completing their back-end calculations. As an example, this could be the "user VIP level (userLevel)" returned after a front-end "user identification" node call or a list of available appointment slots in the current system. Mapping this existing contextual data to front-end read-only information display components (such as text labels, colored logos, or data summary bars) provides end users with valuable decision-making references and information confirmation backgrounds when filling out forms, thus avoiding a disconnect between abstract business processes and actual physical usage scenarios.
[0041] Meanwhile, to further lower the cognitive threshold for users, the system generates textual guidance information based on functional description information and writes this guidance information into the interactive card set. Functional description information is typically a standardized semantic summary extracted by the system's preceding steps for that macro-level business node. The system calls built-in natural language processing algorithms or template rendering rules to translate the rigid backend intent into natural and fluent textual guidance information. For example, the underlying functional description involving writing new registration records to the database is transformed into the card's top title "Add Registration Person" and subtitle "Add new registration person information to the medical record database." This textual guidance information is precisely injected into the card's header view structure, acting as an interpreter during human-computer interaction.
[0042] After preparing the input components representing input constraints, the information display components representing contextual states, and the text guidance information representing textual guidance, the system enters the final visual assembly stage. Based on the project design theme, the system configures the style layout of the input components, information display components, and text guidance information within the interactive card set, resulting in the final interactive card set. In the front-end engineering architecture, the project design theme is essentially a set of predefined Cascading Style Sheets (CSS) variables and a visual specification dictionary stored in the global configuration library. It rigidly defines the card's primary color hexadecimal code (e.g., the main visual blue of a corporate brand), the radius of curvature of component borders, the margin indentation of internal elements, and global font layout rules. Specific data structures and visual parameter matrices are not absolutely limited here. The system's rendering engine acts like an automated UI renderer, strictly adhering to these theme constraints. It calculates the relative coordinates and stacking order of each component on the two-dimensional screen, dynamically assembling the aforementioned discrete logical components into a highly cohesive, style-consistent front-end visual interface, thus outputting the final interactive card set that can be used directly without manual modification.
[0043] As can be seen, in this embodiment, interactive input components are constructed by extracting the underlying input parameters, upstream output parameters are introduced as needed as contextual information display components, natural language guidance text is generated by combining functional descriptions, and finally, the global project design theme is used to uniformly style and render these discrete components. This deeply binds and dynamically integrates the previously highly fragmented backend interface data link gaps, upstream operating status, and frontend enterprise-level UI visual specifications. It completely breaks the technical bottleneck of traditional application development models, which require human frontend engineers to manually configure form controls, bind variables, and adjust page styles node by node on a visual canvas. This significantly reduces the development cycle of a single-node card interface from several hours to fully automated generation in seconds. Simultaneously, the generated interactive cards not only meet the strict data collection requirements of the underlying system but also possess rich contextual display capabilities and extremely high brand visual consistency, greatly reducing the operational and cognitive threshold for end users in complex business scenarios. This achieves a truly end-to-end integrated construction of intelligent agent skills, from pure business logic orchestration in the backend to highly available graphical interaction configuration in the frontend.
[0044] In one embodiment, step S50, which involves synchronously supplementing the input parameter data into the pre-dependency description of the business node, includes the following steps: S51. Extract the input parameter data corresponding to each component in the interactive card set, and write the input parameter data into the parameter dependency list corresponding to the business node. S52. Perform deduplication on duplicate upstream parameter dependencies in the parameter dependency list to determine the preceding dependency descriptions of business nodes.
[0045] Specifically, after completing the fully automated rendering and assembly of the front-end visual interactive assets (i.e., the interactive card set), the system must complete the data backfilling from the front-end graphical interface to the underlying logic control engine to ensure a closed loop during runtime. This embodiment details the technical mechanism of front-end and back-end data contract synchronization and dependency cleaning. In the actual workflow architecture of the system, the input parameter data corresponding to each component in the interactive card set is first extracted. At the physical and memory management level of the computer, the input parameter data represents the memory address of a dynamic variable or a data payload placeholder bound to a specific front-end UI control (such as an input box or drop-down menu). As a specific business example, in the "User Identification" card, the real name or mobile phone number entered by the user is the corresponding input parameter data. After extracting these input parameter data with clear data types and front-end data source anchors, the system writes them back into the parameter dependency list corresponding to the business node. In the scheduling logic of the workflow engine, the parameter dependency list is essentially a pre-entry checklist of the memory state machine that must be verified before the current macro-level business node is awakened and put into actual execution. Writing the input parameter data of the card into this list means, at the system logic level, announcing to the underlying execution engine that the isolated required parameter gaps that were originally discovered when sorting out the underlying microservice interfaces have now been successfully collected through a reliable front-end interaction channel, thus completely opening up the physical closed loop of data flow within a single node.
[0046] However, in complex enterprise-level intelligent agent workflow orchestration, since the current business node is a black box formed by merging multiple fine-grained initial process nodes, its internally nested microservice interfaces are highly likely to have concurrent or sequential requests for the same external environment variable. For example, the three query interfaces within the merged business node may all need to depend on the same upstream parameter dependency named "auth_token" or "user_id". To avoid logical redundancy during system runtime, the system's underlying cleaning algorithm further performs deduplication processing on duplicate upstream parameter dependencies in the parameter dependency list. In the specific algorithm implementation, the system extracts the field key value, data type constraint (such as String or Object), and business semantic hash value of each parameter dependency, and uses a hash set or graph isomorphism comparison algorithm to accurately identify and eliminate duplicate request instructions pointing to the same logical entity. After this round of rigorous memory-level cleaning and physical filtering, the system finally determines the pre-dependency description of the business node, ensuring that the exposed data request requirements are minimized and precisely unique.
[0047] In this embodiment, the input parameter data bound to the interactive card component is extracted and added back to the parameter dependency list of the underlying business node. Duplicate upstream parameter dependencies resulting from node merging are then deduplicated based on data characteristics. This cleverly utilizes front-end interactive assets as the final piece of the puzzle to complete the underlying abstract interface data gaps. Through rigorous algorithmic deduplication and cleaning, a line of defense for data completeness and conciseness is built before the business code is deployed for production. This not only fundamentally ensures the absolute integrity of macro-level business node dependency information, guaranteeing that all required parameters can be obtained normally during Agent process execution and avoiding hard crashes in microservice calls due to missing parameters; but also, through a fully automatic deduplication mechanism, it completely eliminates the absurd logical redundancy of complex aggregation nodes repeatedly requesting the same parameters from the user or system context during real interactions, greatly improving the underlying execution efficiency and the ultimate smoothness of end-user dialogue interaction.
[0048] In one embodiment, the method further includes the following steps: S80. Synchronously output the generated business nodes and interaction card sets to the workflow configuration of the Agent skill.
[0049] Specifically, after dynamically merging and optimizing the underlying microservice interface topology and automatically rendering and building the front-end graphical multimodal interactive assets, the system enters the final stage of automated generation and deployment of agent skills. This embodiment details how to assemble the discrete logic and visual assets obtained from previous calculations into a workable engineering entity. At the physical and architectural level of the computer system, the aforementioned generated business nodes (logical black boxes encapsulating the underlying API execution sequence and data connections) and interaction card sets (UI component stacks bound to business input parameter breakpoints and theme visual specifications) still reside in the system's temporary memory or intermediate computation cache. To enable these assets, endowed with highly business semantics, to truly function, the system must perform unified persistence and engineering orchestration operations.
[0050] In the specific execution flow logic, the system extracts these two types of core assets from memory and performs cross-level deep binding operations. The system synchronously outputs the generated business nodes and interaction card sets to the Agent skill's workflow configuration. The Agent skill's workflow configuration, in terms of the physical attributes of the agent's runtime environment, represents the global execution blueprint and underlying configuration list for that skill. As a concrete engineering implementation example, this workflow configuration can be a JSON or YAML structured text file conforming to a specific large language model orchestration specification, or an orchestration record table containing complex foreign keys and execution state machines stored in a relational database. The specific storage medium and communication protocol format are not absolutely limited here. This synchronous output operation is not a simple file copy but involves strict context dependency injection. The system hard-binds the logical coordinates (such as node ID) of a specific business node in the execution graph with the front-end routing address of the corresponding interaction card set, ensuring that when the agent's execution flow reaches that business node, the corresponding interactive form or display card can be accurately displayed on the terminal device's screen. This deep system-level embedding means that the node merging capability and card generation capability have been fully integrated into the AI-automated generation backbone of Agent skills, achieving synchronized process orchestration and front-end interaction configuration.
[0051] In this embodiment, the underlying business node entities, which have undergone intelligent dimensionality reduction and merging, are deeply bound to the dynamically rendered front-end interactive card set assets, and their synchronous output is serialized to the global workflow configuration of the target Agent skill. This cleverly breaks down the last-mile engineering barrier from "back-end logic abstraction and calculation" to "front-end skill instantiation and deployment." It completely eliminates the tedious assembly work required by traditional development models, where human developers manually drag and drop nodes in the workflow canvas and associate them with corresponding UI form components one by one. This fundamentally eliminates the fatal risk of back-end interface errors or front-end form data failures due to human configuration negligence. At the same time, it achieves 100% end-to-end fully automated construction of Agent skills from underlying process optimization to front-end interaction configuration, making the final output workflow assets plug-and-play and ready for immediate deployment, greatly accelerating the implementation and production cycle of enterprise-level complex intelligent agent businesses.
[0052] To facilitate understanding, a real-world example will be used to illustrate the above points. For example... Figure 2 The image shows a visual orchestration canvas for an agent's skills, intuitively demonstrating the technical solution for intelligent node merging and automatic interactive card generation described in the initial draft. The following is a detailed explanation of each part of the image, in conjunction with the example: 1. Initial process nodes and API resource library (corresponding to S10) The left side of the image, under the "Resource Library," showcases the underlying atomic-level interfaces, such as "Department Registration," "Schedule Inquiry," and "Appointment Submission." These correspond to the initial process nodes in the documentation. In traditional development, directly exposing these fine-grained interfaces to users would lead to cumbersome interactions; however, this system treats them as raw materials to be processed.
[0053] 2. The "business node" after intelligent node merging (corresponding to S20) The "Business Functions" section in the center of the image: The modules marked with numbers 1, 2, 3, and 4 on the canvas (such as "User Identification" and "Add Registered Person") are the merged business nodes. The system stops merging when it detects a "target interaction marker" (such as when the user needs to enter their name or ID number) according to the merging rules. For example, node 1, "User Identification," actually encapsulates multiple silent backend verification interfaces, forming physical boundaries only where user input is required. Although the frontend only displays one large node, the underlying execution order and dependencies of each interface are still preserved (such as the input and output parameter field mappings displayed inside the node).
[0054] 3. Automated mapping generation of interactive cards (corresponding to S40) The right side of the image [Mobile Simulator Interface] shows a set of interactive cards automatically generated for the "User Identification" node.
[0055] Component construction (S41-S44): Input components: Input boxes such as "Real Name" and "ID Number" on the mobile interface are automatically constructed based on the input parameter information from the underlying interface.
[0056] Text guidance: The "Hello, I am your outpatient registration assistant..." at the top of the card is a natural language guide automatically generated based on the function description information.
[0057] Style and layout: The blue tone of the entire card, the rounded corners of the buttons, and the layout are all generated in conjunction with the project design theme configuration, achieving UI rendering without manual coding.
[0058] 4. Explanation of Data Lineage and Prerequisites (for S50 & S70) In the middle of the image, node 3 [Add Registered Person] shows the parameter `userLevel` highlighted in green with a pointing arrow. This demonstrates the system's automatic parsing of interface call relationships and updating of prerequisite dependency descriptions. The system recognizes that this parameter cannot be self-sufficient and must be passed in from upstream (node 1 or 2), thus achieving logical consistency in data lineage within the workflow configuration.
[0059] 5. Workflow configuration synchronous output (for S80) The "Publish" button in the upper right corner of the image represents the synchronized output of the generated business nodes and interaction card set to the Agent skill's workflow configuration. This demonstrates that with this method, developers only need to focus on business logic (such as branch scenarios A / B), and the system can automatically handle complex API aggregation and UI generation, reducing the development cycle from hours to seconds.
[0060] As can be seen from the above description of the various embodiments, the embodiments of this application bring at least the following main effects: Enables intelligent node merging and optimizes process granularity: Based on manually interacting nodes and risk control nodes in the process, it can automatically determine the merging scope, complete the intelligent merging of consecutive non-interactive nodes, significantly reduce the number of process nodes, simplify user interaction steps, and improve the user experience.
[0061] Standardized merging rules to avoid omissions in control and interaction: Built-in clear node merging termination rules, with user confirmation and user input annotation as merging termination conditions, ensure that risk control and user interaction links are not missed during merging, taking into account the dual needs of process optimization and business control.
[0062] Achieve fully automated generation of interactive cards, significantly reducing configuration costs: Based on the functional description of nodes, input parameter information, upstream output parameters, and project design theme, it can automatically generate interactive card sets adapted to business scenarios, eliminating the need for manual configuration of each node and shortening the card configuration cycle from hours to seconds.
[0063] Improve card generation usability and fit business scenarios: When generating cards, not only are the input requirements of mandatory parameters covered, but output parameters from upstream nodes can also be introduced as needed for card display. At the same time, the generated cards can be used directly without manual modification, adapting to the project's design theme.
[0064] Deeply integrated with the entire skill generation process, achieving end-to-end automation: The node merging and card generation capabilities are deeply embedded in the AI-automated skill generation process, which can simultaneously complete process optimization and interaction configuration, realizing end-to-end automated construction of skills from process generation to interaction configuration.
[0065] In one embodiment, an automatic generation system for interactive cards of agent skills is provided, the system comprising: The merge rule configuration unit is used to maintain the node intelligent merge rules, including merging rules that use the target interaction annotation as the merging termination condition; The node intelligent merging unit is used to process the initial process nodes in batches according to the merging rules, and to perform node merging operations according to the marked status of each initial process node to obtain the merged business nodes. The node information generation unit is used to obtain the functional description information, input parameter information and associated upstream output parameter fields corresponding to the business node; The interactive card automatic generation unit is used to generate corresponding interactive card sets for business nodes based on functional description information, input parameter information, associated upstream output parameter fields, and project design theme. The synchronization unit is used to extract input parameter data from the interaction card set and update the prerequisite dependency descriptions of business nodes.
[0066] Specifically, this embodiment deeply dissects the hardware and software collaborative system for achieving fully automated dimensionality reduction and visualized asset mapping of intelligent agent workflows from the perspective of underlying software architecture and modular operation mechanisms. In the complex Agent orchestration platform, the merge rule configuration unit, in terms of physical memory and system architecture, is equivalent to a global policy storage and rule engine dictionary. It is responsible for persisting and dynamically maintaining the graph computation boundary conditions of the entire system. The preset merge rules in this unit clearly indicate that when performing topology folding of underlying API nodes, the target interaction annotation must be strictly used as the termination condition for merging. As an example, the target interaction annotation can be specifically visualized as a user confirmation annotation representing high-risk financial operations, and a user input annotation representing the existence of isolated data that must be provided by humans in real time. These rules set insurmountable physical barriers to ensure that any automated merge operation will not engulf or destroy critical business control and human-computer interaction boundaries.
[0067] As the core scheduling and graph computing engine of the system, the node intelligent merging unit is responsible for taking over the unprocessed, fine-grained underlying interface call network. In the actual runtime environment, this unit schedules a virtual probe to process the initial process nodes in batches according to the instructions issued by the configuration unit along the topology chain of the directed acyclic graph, based on the aforementioned merging rules. When the probe scans continuous silent nodes without target interaction annotations (such as background identity verification, format conversion, etc.), it will continuously add them to the current memory batch; once a node with a target interaction annotation is detected, the unit will immediately trigger the interrupt mechanism and perform a node closure merging operation based on the annotation status of each initial process node. This operation packages and folds the silent nodes in the batch at the front-end presentation level, while strictly preserving their original HTTP call sequence and dependencies at the underlying level, ultimately outputting merged business nodes with coarser granularity that are more in line with human business cognition.
[0068] To eliminate the data gap between the merged logical black box and the outside world, the node information generation unit is triggered as the parser of the underlying data contract. This unit drills down into the merged business node and, through syntax tree analysis or lineage tracing algorithms, obtains and summarizes the functional description information corresponding to the business node (i.e., the standardized natural language business intent name obtained through large model or template translation, such as "VIP user identification"), the input parameter information (i.e., the structured data payload that is extremely lacking for the current node to execute smoothly and must be requested from the outside, such as mobile phone number), and the associated upstream output parameter fields (i.e., the memory-state result data that has been calculated by the preceding node and can be displayed and reused by the current node, such as user level).
[0069] After completing the aforementioned multi-dimensional metadata profile, the interactive card automatic generation unit acts as a front-end automated UI renderer. This unit breaks away from the traditional development model where human engineers had to manually drag and drop form components, taking full control of the mapping from underlying logic to the front-end view. It generates card titles based on the parsed functional description information, automatically and forcibly maps the underlying data types of the input parameters (such as Integer or String) into front-end interactive components with input constraints (such as numeric keyboards or text boxes), and introduces related upstream output parameter fields as context information display components. Simultaneously, this unit places these discrete UI elements into the rendering pipeline of a preset project design theme (i.e., a Cascading Style Sheets (CSS) dictionary containing the company's main color scheme, rounded corner curvature, and global typography specifications), ultimately automatically assembling and generating corresponding highly available interactive card sets for business nodes.
[0070] Finally, to ensure that the data collected from the front end can be accurately fed back into the underlying business logic, the synchronization unit, acting as a closed-loop bridge for data flow between the front end and back end, begins operation. This unit extracts the input parameter data (i.e., memory variable addresses or parameter mapping identifiers) bound to each UI control in the interactive card set, performs strict hash deduplication filtering, and then writes this input parameter data back into the pre-dependency descriptions of the business nodes. This declares at the underlying physical architecture that the previously undefined gap in required parameters has successfully obtained a reliable anchor point for front-end data collection, thus completely establishing a physical closed loop for data flow.
[0071] In this embodiment, a system architecture is constructed that includes merging rule configuration, intelligent node merging, node information generation, automatic card generation, and dependency synchronization. A rule engine drives the dynamic and secure folding of the underlying API topology, and front-end interactive components are automatically mapped and rendered based on multi-dimensional parameter features and visual themes. Simultaneously, deduplication and backfilling of front-end and back-end data contracts are implemented. This completely eliminates the time-consuming manual workflow orchestration and front-end page rendering work in traditional Agent application development. It not only significantly optimizes the granularity of the interactive steps presented to end users during system execution but also absolutely guarantees no omissions in risk control and 100% closed-loop data links at the system-level architecture level. This achieves end-to-end, second-level automated construction and deployment of enterprise-level intelligent agent skills with high availability, high security, and high visual consistency.
[0072] For more details on the automatic generation system of interactive cards for this Agent skill, please refer to the description of the aforementioned method embodiments, which will not be repeated here. It should be understood that the sequence number of each step in the above embodiments does not imply the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of this application.
[0073] In one embodiment, such as Figure 3 As shown, a computer device is provided, wherein the processor of the computer device is used to provide computing and control capabilities, the computer device includes a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein when the processor executes the computer program, it implements the steps of an interactive card automatic generation method for an Agent skill as described in any of the preceding claims.
[0074] In one embodiment, a computer-readable storage medium is provided having a computer program stored thereon, which, when executed by a processor, implements the steps of the above-described method for automatically generating interactive cards for Agent skills.
[0075] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium. When executed, the computer program can include the processes of the embodiments of the methods described above. Any references to memory, storage, user databases, or other media used in the embodiments provided in this application can include non-volatile and / or volatile memory.
[0076] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the above-described division of functional units and modules is used as an example. In practical applications, the above functions can be assigned to different functional units and modules as needed, that is, the internal structure of the system can be divided into different functional units or modules to complete all or part of the functions described above.
[0077] The above-described embodiments are only used to illustrate the technical solutions of this application, and are not intended to limit them. Although this application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of this application, and should all be included within the protection scope of this application.
Claims
1. A method for automatically generating interactive cards for Agent skills, characterized in that, The method includes: Obtain the initial process nodes of the Agent skill and traverse the initial process nodes; The initial process nodes are processed in batches according to the preset merging rules, and a node merging operation is performed according to the labeling status of each initial process node to obtain the merged business nodes; wherein, the merging rule takes the detection of target interaction label as the merging termination condition. Obtain the functional description information, input parameter information, and associated upstream output parameter fields corresponding to the business node; based on the functional description information, input parameter information, and upstream output parameter fields, and in conjunction with the matching project design theme, generate a corresponding set of interactive cards for the business node; Extract the input parameter data from the set of interactive cards and synchronously supplement the input parameter data into the pre-dependency description of the business node.
2. The method according to claim 1, characterized in that, The process involves batch processing of the initial process nodes according to preset merging rules, and performing node merging operations based on the labeled status of each initial process node to obtain merged business nodes, including: Starting from the first node of the initial process node, check whether the currently traversed node has a user confirmation label or a user input label as the target interaction label; If the current traversed node does not contain the user confirmation label and does not contain the user input label, then the current traversed node will be included in the current merge batch, and subsequent nodes will continue to be traversed. If the currently traversed node contains the user confirmation label or the user input label, then the current merging batch is terminated, and the nodes already included in the current merging batch are merged to generate the business node.
3. The method according to claim 2, characterized in that, When generating the business node, the interface call chain corresponding to each initial process node within the business node is retained, and the execution order and dependency relationship of each interface are maintained.
4. The method according to claim 2, characterized in that, After terminating the current merge batch, the method further includes: Starting from the node that triggers the termination of the current merge batch and has the user confirmation label or the user input label, the traversal of the next merge batch is started.
5. The method according to claim 1, characterized in that, After obtaining the business node, the method further includes: The interface call relationships contained in the business nodes are parsed, and function names and prerequisite dependency descriptions are automatically generated for the business nodes.
6. The method according to claim 1, characterized in that, The step of generating a corresponding set of interactive cards for the business node includes: The input parameter information is constructed as an input component in the interactive card set; The upstream output parameter field is constructed as an information display component in the interactive card set; Based on the functional description information, generate textual guidance information and write the textual guidance information into the interactive card set; Based on the project design theme, configure the style layout of the input component, the information display component, and the text guidance information in the interactive card set to obtain the final interactive card set.
7. The method according to claim 1, characterized in that, The step of synchronously supplementing the input parameter data into the pre-dependency description of the business node includes: Extract the input parameter data corresponding to each component in the interactive card set, and write the input parameter data into the parameter dependency list corresponding to the business node; Perform deduplication on duplicate upstream parameter dependencies in the parameter dependency list to determine the preceding dependency descriptions of the business node.
8. The method according to any one of claims 1-7, characterized in that, The method further includes: The generated business nodes and the set of interactive cards are synchronously output to the workflow configuration of the Agent skill.
9. An automatic generation system for interactive cards of agent skills, characterized in that, The system includes: The merge rule configuration unit is used to maintain the node intelligent merge rules, wherein the merge rules include using the target interaction annotation as the merge termination condition; The node intelligent merging unit is used to obtain the initial process nodes of the Agent skill, traverse the initial process nodes, process the initial process nodes in batches according to the merging rules, and perform node merging operation according to the labeling status of each initial process node to obtain the merged business nodes. The node information generation unit is used to obtain the functional description information, input parameter information and associated upstream output parameter fields corresponding to the business node; An interactive card automatic generation unit is used to generate a corresponding set of interactive cards for the business node based on the function description information, the input parameter information, the associated upstream output parameter fields, and the project design theme. The synchronization unit is used to extract the input parameter data from the interaction card set and update the prerequisite dependency descriptions of the business nodes.
10. A computer device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the computer program, it implements the steps of the method as described in any one of claims 1-8.