Agent-driven dynamic user interface generation method for recruitment scenarios

By combining a large language model with a knowledge base in the recruitment field for intent recognition and semantic parsing, a structured component calling protocol for the recruitment field is generated. This solves the problems of the single form of user interface output and lack of semantic understanding in the existing technology, realizes intelligent dynamic user interface generation and recruitment process management, and improves the data visualization and process automation capabilities of the recruitment management platform.

CN123114464APending Publication Date: 2026-11-17GUIZHOU WUJIANG HYDROPOWER DEV +1
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202611177501.6
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2026-08-05
Publication Date
2026-11-17

AI Technical Summary

Technical Problem

Existing recruitment management platforms have a single user interface output format, lack semantic understanding of the recruitment business domain, and cannot achieve two-way interactive closed loop and progressive task management. This results in a disconnect between information presentation and user needs, and fails to meet diverse data visualization requirements.

Method used

By combining a large language model with a knowledge base in the recruitment domain for intent recognition and semantic parsing, a structured component calling protocol for the recruitment domain is generated, enabling decoupled communication between the agent and the front-end component library. An adaptive chart selection and two-way interactive closed-loop mechanism are adopted to support user operation-driven interface updates and recruitment process decomposition.

Benefits of technology

It enables intelligent dynamic user interface generation, adaptively selects chart types based on recruitment data characteristics, supports continuous decision-making and interface updates based on user interaction feedback, and improves the ability to visualize, track, and automate the recruitment process.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN123114464A_ABST
    Figure CN123114464A_ABST
Patent Text Reader

Abstract

This invention discloses an intelligent agent-driven dynamic user interface generation method for recruitment scenarios, comprising: identifying recruitment intent and parsing business semantics of user natural language commands by combining a large language model of a recruitment domain knowledge base; selecting components and making chart decisions by combining recruitment context state and multi-dimensional features of recruitment data; assembling a structured component calling protocol for the recruitment domain; loading components on demand from a recruitment-specific front-end component library and injecting data to complete rendering; and transmitting user interaction events back to the intelligent agent decision engine to drive incremental updates of the interface, forming a two-way interactive closed loop. This invention solves the core problems of existing technologies, such as output forms limited to static text or fixed cards, lack of recruitment business semantic understanding, and two-way interactive closed loop, and realizes intelligent generation and adaptive rendering of dynamic user interfaces in recruitment scenarios.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This invention relates to the fields of human-computer interaction and artificial intelligence, and particularly to a method for generating dynamic user interfaces driven by intelligent agents in recruitment scenarios. Specifically applied to conversational interaction scenarios in recruitment management platforms, this invention integrates large language model intent recognition technology, semantic parsing technology from a recruitment domain knowledge base, decoupled communication technology between intelligent agents and the front end based on structured protocols, dynamic rendering technology for front-end components, and a two-way interactive closed-loop driving mechanism to achieve intelligent generation and adaptive updating of dynamic user interfaces driven by intelligent agents in recruitment scenarios. Background Technology

[0002] With the rapid development of Large Language Model (LLM) technology, recruitment management platforms are gradually incorporating conversational interaction capabilities, allowing users to complete various recruitment operations such as resume screening, recruitment data analysis, and process management through natural language commands. Currently, the most relevant prior art to this invention is an LLM-based conversational recruitment interaction system. The basic principle of this technology is: to identify the user's natural language intent, map it to a preset execution path, generate text or fixed-format card results, and finally feed them back to the dialog box interface.

[0003] The aforementioned existing technologies have the following four core technical problems:

[0004] First, the output format is always limited to static text or fixed-format cards, which cannot dynamically select and render the optimal visualization components based on the multi-dimensional characteristics of recruitment data (such as comparative, trend, proportion, funnel, multi-dimensional evaluation, etc.). This results in a single form of information presentation, which is difficult to meet the diverse data visualization needs of recruitment business.

[0005] Secondly, it lacks semantic understanding capabilities in the recruitment business domain. The general dynamic UI rendering solution cannot understand recruitment-specific business concepts such as recruitment funnel stages, candidate matching dimensions, and screening condition semantics. It cannot make targeted component selection decisions based on the recruitment business context, resulting in a disconnect between the generated interface and the actual recruitment business needs.

[0006] Third, it lacks a two-way interactive closed-loop mechanism between users and dynamically generated components. Users cannot trigger a new round of reasoning and interface updates by clicking on chart data points, selecting candidates, or adopting suggestions. The system can only output information in one direction and does not support continuous decision-making and dynamic interface updates based on user interaction feedback.

[0007] Fourth, there is a lack of progressive task management capabilities for the recruitment process. Complex recruitment tasks cannot be broken down into progressive task components with status and dependencies, and the task status cannot be automatically updated and subsequent related tasks can be advanced as the execution progresses. As a result, the entire recruitment process lacks visual tracking and automated advancement methods. Summary of the Invention

[0008] The purpose of this invention is to provide an agent-driven dynamic user interface generation method for recruitment scenarios, in order to solve the technical problems existing in the prior art, such as output forms being limited to static text or fixed cards, lack of semantic understanding of recruitment business domain, lack of two-way interactive closed-loop mechanism between users and rendering components, and lack of progressive task management capabilities for the recruitment process.

[0009] To achieve the above objectives, the present invention provides the following technical solution:

[0010] This invention provides a method for generating intelligent agent-driven dynamic user interfaces for recruitment scenarios, comprising:

[0011] By combining a large language model with a recruitment domain knowledge base, recruitment intent and business semantics are analyzed from the natural language commands input by the user, resulting in a structured description of recruitment intent type and business semantics. Based on the structured description of recruitment intent type and business semantics, and combined with the recruitment context state and multi-dimensional features of the retrieved recruitment data, component selection and chart type decisions are made, resulting in candidate component type combinations, data dependencies between components, and adaptive chart selection results. Based on the candidate component type combinations, the data dependencies between components, and the adaptive chart selection results, a recruitment domain structured component calling protocol is assembled. The recruitment domain structured component calling protocol is parsed, components are loaded on demand from the recruitment-specific front-end component library, and recruitment data query results are injected to render interactive rendering components. Based on the user's interaction with the interactive rendering components, the interaction events are sent back to the intelligent agent decision engine and the recruitment context state is updated. An updated recruitment domain structured component calling protocol is regenerated, and the interactive rendering components are incrementally updated to obtain the updated interactive interface.

[0012] Further, the assembly of the recruitment domain structured component calling protocol based on the candidate component type combination, the data dependency relationship between components, and the adaptive chart selection result includes: assembling a recruitment domain structured component calling protocol containing a protocol version field, a component type field, a component identifier field, a data mapping field, a layout field, an event field, and a metadata field; wherein the data mapping field contains a data source identifier and a query statement, the layout field contains position, sorting, and width, the event field contains the component's event binding definition, and the metadata field carries the chart selection confidence level; the method further includes: the data mapping field also contains tag field mapping, series field mapping, and numeric field mapping; when parsing the recruitment domain structured component calling protocol, a recruitment data query is performed based on the data source identifier and the query statement, and the query result is mapped and injected into the attributes of the loaded component according to the tag field mapping, the series field mapping, and the numeric field mapping.

[0013] Furthermore, the step of combining the recruitment context state with the multi-dimensional features of the retrieved recruitment data to select components and make chart type decisions, thereby obtaining candidate component type combinations, data dependencies between components, and adaptive chart selection results, includes: performing multi-dimensional feature analysis on the retrieved recruitment data to identify data dimension types, including comparative, trend, percentage, funnel, and multi-dimensional evaluation types; mapping comparative types to grouped bar charts, trend types to line charts, percentage types to pie charts or donut charts, funnel types to recruitment funnel charts, and multi-dimensional evaluation types to job-person matching radar charts, thereby obtaining adaptive chart selection results.

[0014] Furthermore, the selection of the chart type is achieved through a progressive optimization of the chart type based on a sparse Gaussian process, including: concatenating the data dimension type, job category, and user historical preference vector into a context feature vector; calculating the expected satisfaction and uncertainty of each chart type through a variational sparse Gaussian process posterior, wherein the variational sparse Gaussian process uses a radial basis kernel function and represents the posterior with an induced point, which is learned offline from historical interaction data by maximizing the variational lower bound; using an upper confidence bound strategy, the sum of the expected satisfaction and the uncertainty value after exploration and weighting with a tradeoff parameter is used as the upper confidence bound score for each chart type, and the chart type with the highest upper confidence bound score is selected as the adaptive chart selection result, and the inverse of the uncertainty is output as the chart selection confidence level to the metadata field of the recruitment domain structured component calling protocol, wherein the exploration and weighting parameter decreases inversely proportional to the square root of the number of interactions as the number of interactions increases; and asynchronously updating the variational sparse Gaussian process posterior and the induced point based on the chart satisfaction signal in user interaction feedback, forming a learning closed loop for chart selection.

[0015] Furthermore, the step of parsing the structured component calling protocol of the recruitment domain, loading components on demand from the recruitment-specific front-end component library and injecting recruitment data query results to render an interactive rendering component includes: parsing the component type field, data mapping field, layout field, and event field of the structured component calling protocol of the recruitment domain to obtain component loading instructions, data query instructions, layout configuration, and event binding instructions; loading the corresponding component definition on demand from the recruitment-specific front-end component library based on the component loading instructions; executing a recruitment data query based on the data query instructions and injecting the query results into the component attributes to obtain a component instance after data injection; mounting the component instance to a specified position in the dialog flow based on the layout configuration, the specified position including a dialog bubble, an independent panel, or a sidebar; and binding event handling functions to the component instance based on the event binding instructions to obtain an interactive rendering component.

[0016] Furthermore, after obtaining the candidate component type combination and before assembling the recruitment domain structured component invocation protocol, a global rendering budget optimal allocation is performed on the candidate component type combination, including: constructing an inference utility function for each candidate component in the candidate component type combination, wherein the inference utility function increases with the amount of rendering resources allocated to the candidate component and its marginal utility decreases to saturation, and weighting the utility cap of the inference utility function with the inherent information salience of the candidate component for the current recruitment decision; constrained by the total amount of rendering resources that the current dialog interface can support, and based on the sum of the inference utilities of all candidate components. A global constraint optimization problem is constructed with the goal of maximizing the value of the component. The global constraint optimization problem is solved, and the global shadow price is output to make the marginal utility of each candidate component that receives a positive rendering resource allocation equal. Candidate components whose marginal utility is always lower than the global shadow price are allocated zero rendering resources to perform rational abstention. The rendering resources released by the abstaining candidate components are redistributed to candidate components whose inference utility is about to enter a rapid increase phase, thus obtaining a globally optimal rendering budget allocation scheme. The subset of candidate components with positive rendering resources in the globally optimal rendering budget allocation scheme is used as the basis for assembling the structured component calling protocol of the recruitment domain.

[0017] Further, constructing an inference utility function for each candidate component in the candidate component type combination includes: measuring the amount of rendering resources allocated to the candidate component as a number of rendering tokens weighted by component complexity; determining the inherent information saliency as a score of the support of the candidate component's component type for the current recruitment decision; constructing the inference utility function such that: in the initial stage when the amount of rendering resources is lower than the information emergence threshold, the inference utility increases rapidly as the amount of rendering resources increases; after the amount of rendering resources exceeds the information emergence threshold, the marginal increment of the inference utility tends to saturate; and reallocating the amount of rendering resources released by the abstaining candidate components to candidate components whose inference utility is about to enter a rapid increase stage includes: allocating the amount of rendering resources released by the abstaining candidate components to candidate components whose inference utility is about to exceed the information emergence threshold, according to the principle of prioritizing those closer to the information emergence threshold.

[0018] Further, after the agent decision engine regenerates the updated recruitment domain structured component invocation protocol and before incrementally updating the interactive rendering component, answerability gating is performed, including: the agent decision engine maintaining a Bayesian posterior distribution of recruitment intent type and optimal component type; calculating a posterior approximation of the Bayesian posterior distribution through variational inference; using the normalized complement of the posterior entropy of the posterior approximation with respect to the optimal component type relative to the maximum possible entropy as an answerability gating index; and determining the current certificate when the answerability gating index is not less than a preset gating threshold. Based on sufficient evidence, the updated recruitment domain structured component calling protocol is used for the incremental update; when the answerability gating index is less than the preset gating threshold, it is determined that the current evidence is insufficient, and active information acquisition is initiated: from the candidate information source set including user clarification requests, recruitment data supplementation and context history backtracking, the information source with the largest ratio of expected answerability improvement to acquisition cost is selected as the target information source; information acquisition is performed based on the target information source, and the acquired information is sent back to update the Bayesian posterior distribution, and the posterior entropy is narrowed before triggering the next round of answerability gating.

[0019] Further, the information acquisition based on the target information source includes: when the target information source is a user clarification request, generating a component invocation protocol of component type clarification card, wherein the data mapping field of the clarification card contains a candidate array, the candidate array contains a preset number of candidate component types with the highest posterior probability, chart type, preview description, and data summary, the event field of the clarification card defines a clarification selection event, rendering the clarification card component, and updating the Bayesian posterior distribution based on the user's selection event on the clarification card component; when the target information source is a recruitment data supplementation query, the intelligent agent decision engine performs an additional recruitment data query to update the Bayesian posterior distribution with the updated recruitment context state; when the target information source is a context history backtracking, loading the dialogue history to supplement the recruitment context state and updating the Bayesian posterior distribution, wherein the user clarification request, the recruitment data supplementation query, and the context history backtracking are respectively configured with acquisition costs that decrease sequentially.

[0020] Furthermore, the method also includes: breaking down the recruitment process into multiple task steps according to the recruitment funnel stages based on user instructions, with each task step corresponding to a stage of the recruitment funnel; generating a task list component invocation protocol containing task identifier, task name, task status, responsible person, deadline, and inter-task dependencies; rendering the task list component; based on user operation events on the task list component, sending the operation events back to the intelligent agent decision engine, which updates the task status of the corresponding task step to the completed state and advances the task status of subsequent task steps to the in-progress state according to the inter-task dependencies, generating an updated task list component invocation protocol; and incrementally updating the task list component based on the updated task list component invocation protocol to obtain an automatically advanced task list component.

[0021] Furthermore, the method also includes: generating a recruitment suggestion component invocation protocol based on the recruitment bottlenecks identified by the intelligent agent decision engine during the recruitment process, wherein the recruitment suggestion component invocation protocol includes suggestion text, suggestion reasons, and executable action buttons, wherein the executable action buttons include an accept button, a modified accept button, and an ignore button, and rendering a recruitment suggestion component; based on the user's accept operation of the recruitment suggestion component, sending the accept event back to the intelligent agent decision engine, which updates the recruitment parameters, re-executes the recruitment data query based on the updated recruitment parameters, and generates updated component invocation protocols for the statistical card component and the resume list component; and performing incremental rendering based on the updated component invocation protocols for the statistical card component and the resume list component to obtain refreshed statistical card component and resume list component.

[0022] The present invention also provides an intelligent agent-driven dynamic user interface generation system for recruitment scenarios, including a processor and a memory, wherein the memory stores a computer program, and the processor executes the computer program to implement the steps of the above method.

[0023] The present invention has the following beneficial technical effects:

[0024] First, by defining the Recruitment Domain Structured Component Call Protocol (RCCP), the intelligent agent decision engine and the front-end component library are decoupled and communicated through protocols. The intelligent agent outputs protocolized instructions containing recruitment business semantics instead of fixed text, which fundamentally breaks the limitations of static output format.

[0025] Second, through the recruitment data-driven adaptive chart selection mechanism, the optimal chart type is automatically selected based on the mapping relationship between data dimension type and recruitment business context, realizing adaptive matching between data features and visualization form, and solving the problem of lack of recruitment semantic understanding in general solutions.

[0026] Third, through a two-way interactive closed-loop mechanism, a complete closed loop of "user operation → event feedback → agent reasoning → interface update" is constructed, supporting continuous decision-making and dynamic incremental interface updates based on user interaction feedback.

[0027] Fourth, by using progressive task components in the recruitment process, the entire recruitment funnel is broken down into task steps with states and dependencies, enabling visual tracking and dependency-driven automated state progression.

[0028] Fifth, by using a global shadow price mechanism derived from KKT conditions, the marginal utility of each component is balanced under the constraint of the total rendering budget. The rational abandonment mechanism reallocates resources from inefficient components to efficient components that are close to the information emergence threshold. This can achieve up to 3 times the global information utility improvement when the rendering budget is tight.

[0029] Sixth, through the Bayesian answerability gating mechanism, the uncertainty of agent decision-making is probabilistically quantified by the normalization of a posteriori entropy. When evidence is insufficient, the Bellman strategy is calibrated according to cost to actively acquire information instead of risky rendering, thereby improving the reliability of component selection.

[0030] Seventh, by using a sparse Gaussian process slot machine and a UCB strategy, and progressively optimizing the chart selection strategy based on user interaction feedback, the online inference complexity remains constant at O(m). 2 |A|), which meets the real-time response requirement of less than 2 seconds in recruitment dialogue scenarios. Attached Figure Description

[0031] To more clearly illustrate the technical solutions in the embodiments of this application, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the accompanying 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.

[0032] Figure 1 This is a schematic diagram of the overall process of the intelligent agent-driven dynamic user interface generation method for recruitment scenarios according to the present invention.

[0033] Figure 2 A flowchart illustrating the process of calling the protocol for structured components in the recruitment field;

[0034] Figure 3 This diagram illustrates the component loading and interactive rendering process in the recruitment field. Detailed Implementation

[0035] The specific embodiments of the present invention will now be described in detail with reference to the accompanying drawings.

[0036] Example 1

[0037] like Figure 1 As shown, this embodiment provides a method for generating a dynamic user interface driven by an intelligent agent for recruitment scenarios, including the following steps:

[0038] S1: By combining a large language model with a knowledge base in the recruitment domain, recruitment intent and business semantics are identified from the natural language commands input by the user, resulting in a structured description of the recruitment intent type and business semantics.

[0039] After receiving natural language commands from users, the dialogue interface of the recruitment management platform inputs these commands into a large language model that incorporates a recruitment domain knowledge base for processing. This knowledge base includes a recruitment business terminology table, an operational semantic mapping table, and a recruitment process ontology, covering professional vocabulary and operational semantics for each stage of the recruitment funnel, such as resume submission, initial screening, interviews, and offers. The large language model uses the recruitment domain knowledge base as a contextual constraint to classify and analyze the user's command execution intent. It categorizes the results into one of four recruitment intent types: recruitment data analysis, resume screening, task breakdown and follow-up, and recruitment suggestion adoption. Simultaneously, it extracts business elements from the command, such as job scope, time dimension, and screening conditions, generating a structured business semantic description object. Its fields include intent type identifier, a list of involved jobs, time range, data dimension requirements, and operational goals. For example, for the user command "Compare the resume submission volume for each job last week and this week," the intent type is identified as "recruitment data analysis," the structured business semantic description includes all jobs, a time range of "last week and this week," a data dimension requirement of "comparison of submission volume across time," and an operational goal of "visual presentation."

[0040] Specifically, the integration of the recruitment domain knowledge base and the large language model is achieved using a retrieval augmented generation (RAG) architecture. The recruitment domain knowledge base is persistently stored in the form of a vector database. Each knowledge entry includes definitions of recruitment business terms, operational semantic mapping rules, descriptions of recruitment process ontology nodes, and historical instruction parsing comparison samples. All entries are pre-converted into high-dimensional semantic vectors using a text embedding model and indexed accordingly. When a user's natural language instruction enters the system, the system first encodes the instruction text into a query vector using the same embedding model. Then, it performs a nearest neighbor search in the vector database, recalling the Top-K knowledge entries most relevant to the current instruction based on semantic similarity (default K=5, configurable according to business needs). The search results are dynamically concatenated into the system prompt of the large language model, serving as contextual knowledge constraints for the model's recruitment intent recognition and business semantic parsing. This allows for deep integration of the general semantic understanding capabilities of the large language model with recruitment domain-specific knowledge without modifying model parameters.

[0041] In this embodiment of the invention, the knowledge sources of the recruitment domain knowledge base include the following four categories: The first category is a standard terminology table for the recruitment industry, which includes recruitment professional abbreviations such as JD (Job Description), HC (Head Count), Offer, and background check, along with their complete semantic definitions; the second category is a semantic mapping table for recruitment operations, which establishes a two-way mapping relationship between everyday colloquial expressions such as "Check the progress this week" and "How is the resume status now?" and standardized query operation types (such as "Recruitment data analysis - application statistics"); the third category is the recruitment process ontology, which defines the preconditions, output states, and conversion triggering rules for each stage of the recruitment funnel (job posting → resume screening → initial telephone screening → interview arrangement → offer negotiation → hiring and onboarding) using a directed acyclic graph structure; the fourth category is a historical instruction parsing comparison sample set, which includes matching examples of user instructions and corresponding structured parsing results in real recruitment scenarios, serving as a reference for the few-shot prompt of the large language model, and assisting in processing semantically complex or ambiguous user instructions.

[0042] It should be noted that the knowledge base establishes sub-indexes according to the four categories mentioned above. During retrieval, precise retrieval is first performed within the sub-index partition corresponding to the current recruitment intent prediction category. If the semantic similarity of the retrieved data does not reach the threshold, it is automatically expanded to a full-database fuzzy search to balance retrieval timeliness and knowledge recall coverage. In addition, the knowledge base supports online incremental updates: recruitment platform operators can add new recruitment terms or operational semantic mapping entries to the knowledge base through the management backend. The new entries are vectorized by the embedding model and written to the vector index in real time, taking effect in subsequent user interactions without restarting the service, ensuring the continuous timeliness of recruitment domain knowledge.

[0043] S2: Based on the recruitment intent type and business semantic structured description, and combined with the recruitment context state and the multi-dimensional features of the queried recruitment data, component selection and chart type decision are made to obtain candidate component type combinations, data dependencies between components, and adaptive chart selection results.

[0044] The recruitment context management submodule loads the recruitment context state based on the current dialogue session identifier. This recruitment context state includes the currently focused position, activated filtering conditions, a snapshot of the candidate list, and the current recruitment funnel stage. The intelligent agent decision engine performs joint reasoning with the recruitment intent type, structured description of business semantics, and recruitment context state, outputting candidate component type combinations according to the component selection decision rule library. The data dependencies between components in the candidate component type combinations are recorded as a directed graph structure, where nodes are component instance identifiers and directed edges represent data flow directions. Based on this, the recruitment data feature recognition module performs multi-dimensional feature analysis on the recruitment data queried from the data service layer, identifies data dimension types, and outputs adaptive chart selection results according to the mapping rules between dimension types and chart types.

[0045] The component selection decision rule base is organized in the form of condition-action (ECA) rules. Each rule consists of three parts: triggering condition (applicable recruitment intention type), evaluation condition (joint judgment of recruitment context state and data dimension type), and execution action (recommended candidate component type combination and initial inherent information salience score of each component). The rule base pre-defines multiple decision rules covering major recruitment business scenarios. Typical rule examples are as follows: When the recruitment intent type is "recruitment data analysis" and the data dimension type includes "comparative", the candidate component type combination includes grouped bar charts (significance 0.9), statistical cards (significance 0.6), and an optional resume list (significance 0.4); when the recruitment intent type is "resume screening", the candidate component type combination includes a resume list (significance 0.9), statistical cards (significance 0.7), and an optional job-person matching radar chart (significance 0.5); when the recruitment intent type is "task decomposition and follow-up", the candidate component type combination only includes a task list (significance 0.95) and does not include chart components; when the recruitment intent type is "recruitment suggestion adoption", the candidate component type combination includes an executable suggestion card (significance 0.9) and associated statistical cards (significance 0.6) and a resume list (significance 0.6).

[0046] It should be noted that the initial saliency scores of the inherent information of each candidate component in the rule base were manually determined by domain experts based on the direct support relationship between each component type and the corresponding recruitment intent. These scores were continuously optimized through statistical corrections as user feedback data accumulated after the system went live. When multiple rules simultaneously meet the triggering conditions in the same dialogue round, the rule engine selects the rule with the highest priority according to the intent type priority order (recruitment data analysis > resume screening > recruitment suggestion adoption > task decomposition and follow-up), and merges the candidate components of the remaining rules into the candidate component type combination with lower saliency, ensuring that high-priority business information is presented first. The rule base adopts a configurable structure design. Recruitment platform administrators can add, modify, or deactivate rule entries through the rule editing console without modifying the code, supporting the customized deployment needs of different recruitment platforms.

[0047] S3: Based on the candidate component type combination, the data dependency relationship between the components, and the adaptive chart selection result, a structured component calling protocol for the recruitment field is assembled.

[0048] The RCCP protocol generation submodule takes candidate component type combinations, data dependencies between components, and adaptive chart selection results as input. It assembles the protocol content field by field according to the JSON Schema specification of the Recruitment-ContextComponent Call Protocol (RCCP), outputting a formatted RCCP protocol JSON. The RCCP protocol is a dedicated communication protocol defined in this invention. Its function is to transmit the component selection decisions of the agent's decision engine to the front-end dynamic rendering middleware in a structured form carrying recruitment business semantics, thereby achieving protocol-based decoupling communication between the agent and the front-end component library. Each field in the RCCP protocol carries component description information of different dimensions, the details of which are described in Example 2.

[0049] S4: Parse the structured component calling protocol of the recruitment field, load components from the recruitment-specific front-end component library on demand and inject recruitment data query results to render interactive rendering components.

[0050] After receiving the RCCP protocol JSON, the front-end dynamic rendering middleware parses it layer by layer according to the protocol fields, extracting component loading instructions, data query instructions, layout configurations, and event binding instructions. The recruitment-specific front-end component library is a predefined collection of components, including statistical cards, grouped bar charts, line charts, pie / ring charts, recruitment funnel charts, job-person matching radar charts, resume lists, task lists, executable suggestion cards, and clarification cards. Each component encapsulates the display and interaction logic of the recruitment business domain. Based on the component type identifier in the component loading instructions, the dynamic rendering middleware loads the corresponding component definition from this component library as needed. It retrieves data from the recruitment data service layer according to the data query instructions and injects it into the component attributes according to the mapping rules. Finally, it mounts the component instance to the specified position in the dialog flow according to the layout configuration and binds event handling functions, outputting an interactive rendered component.

[0051] S5: Based on the user's interaction with the interactive rendering component, the interaction event is sent back to the intelligent agent decision engine and the recruitment context state is updated. The updated recruitment domain structured component calling protocol is regenerated, and the interactive rendering component is incrementally updated to obtain the updated interactive interface.

[0052] When a user performs interactive operations such as clicking, checking, or accepting on a rendered component, the corresponding component's event handling function is triggered. This event is encapsulated into a structured event message, which includes an event type field, a component identifier field, a timestamp field, and an interaction payload field. The structured event message is sent in real-time to the agent decision engine via a WebSocket event postback channel. After parsing the event message, the agent decision engine merges the interaction result into the recruitment context state, triggering a new round of recruitment intent recognition and component selection decisions, generating an updated RCCP protocol. The front-end dynamic rendering middleware, based on the updated RCCP protocol, performs differential comparison on the already rendered components, only performing incremental updates or adding rendering to the changed component nodes. This avoids the interface flickering and performance loss caused by full re-rendering, resulting in an updated interactive interface. This forms a complete two-way interactive closed loop of "user operation → event postback → agent inference → incremental interface update".

[0053] Specifically, the differential comparison is implemented based on a recursive comparison algorithm of the Virtual DOM tree. After receiving the updated recruitment domain structured component calling protocol, the front-end dynamic rendering middleware first accurately locates the target node in the rendered component tree based on the component identifier field (component_id) of each component instance in the protocol. For existing component nodes, a field-level differential comparison (Diff) is performed between the target data state described by the new protocol and the currently rendered component data state to extract the data fields that have undergone substantial changes. Nodes with newly generated identifiers in the component identifier field are determined to be new rendering tasks. Rendered component nodes that no longer appear in the updated protocol are determined to be deletion tasks. The above differential comparison results generate a minimal change patch set, where each patch item describes a minimal granular DOM operation (attribute value update, child node insertion, or child node deletion). The rendering engine executes atomic DOM operations in the order of the patch set, ensuring that browser layout reflow and repaint are triggered only on the DOM subtrees that have actually changed.

[0054] It should be understood that incremental updates have significant advantages over full re-rendering in both performance and user experience. In terms of performance, browser layout reflow is the most computationally expensive DOM manipulation operation. Incremental updates narrow the scope of changes to the smallest granular subtree, reducing the reflow scope triggered by each round of interaction to 5% to 20% of that of full re-rendering (the specific value depends on the proportion of components involved in this round of changes). This is particularly effective in dialog interfaces containing multiple complex chart components. In terms of user experience, components not involved in this round of updates maintain their existing rendering state and the user's current browsing position. The chart data the user is currently viewing will not be lost due to the interface refresh triggered by a new round of agent inference, eliminating the interface flickering and scroll position reset problems caused by full re-rendering during multiple rounds of continuous interaction. This allows users to maintain a sense of control over the interface state and the continuity of interaction in conversational recruitment scenarios.

[0055] It is worth noting that the core technical problem solved by the aforementioned two-way interactive closed-loop mechanism lies in the fact that a one-way output system (i.e., the "user input command → system output result → interaction termination" mode) cannot support continuous refinement operations in recruitment decision-making scenarios. In actual recruitment management, recruitment managers typically need to reach a final decision through multi-step progressive operations. For example, they might first identify an abnormal number of resumes for a certain position from the aggregated data of all positions, then drill down to the detailed data analysis bottleneck for that position, then filter out low-matching resumes and mark them for elimination, and finally adopt the agent's suggestion to adjust the screening conditions. That is, the input of each step in the above operation sequence depends on the output result of the previous step, which is a typical continuous conditional decision-making process. If the system only supports one-way output, each step requires re-entering a complete natural language command. The user needs to manually transcribe the output result of the previous step (such as the job name identified in the table) into the next command, which is not only cumbersome but also prevents the context state from being automatically accumulated and passed between multiple steps. The two-way interactive closed-loop mechanism encapsulates each user action on the rendering component (click, check, accept, etc.) into a structured event message carrying precise semantics and sends it back to the agent decision engine in real time. This enables the agent to directly update the recruitment context state with precise operation parameters in the event payload (rather than re-parsing natural language), triggering the next round of targeted inference and interface updates, thus achieving smooth and continuous execution of the recruitment decision sequence.

[0056] In this embodiment of the invention, the following example of a typical multi-round recruitment data analysis scenario illustrates the complete process of the collaborative evolution of the interface state and the recruitment context state driven by the two-way interactive closed-loop mechanism. First round: The user inputs "Compare the number of resumes submitted for each position this week," and the system renders a grouped bar chart containing the number of submissions for each position. The recruitment context state records the currently focused position as "All Positions." Second round: The user clicks the bar corresponding to the "Backend Engineer" position in the bar chart, triggering the on_bar_click event, with the event payload carrying { "job": The "Backend Engineer" field is fed back to the agent's decision engine. The engine updates the focused job title in the recruitment context to "Backend Engineer," triggering a new round of reasoning. This generates an RCCP protocol containing a line chart of applications for the Backend Engineer position over the past four weeks and a statistical card of screening criteria. This incrementally replaces the original grouped bar chart component, eliminating the need for the user to re-enter any text commands. In the third round, the user selects three low-matching resumes on the resume list component. The on_check event is triggered, and the event payload carries a list of IDs of the selected resumes. The agent marks these resumes as "pending review" and updates the context state, triggering an incremental update of the statistical card component (number of resumes pending review + 3). In the fourth round, the agent detects in the context state that the initial screening pass rate for the Backend Engineer position is only 9%, significantly lower than the baseline. It automatically generates an executable suggestion card (suggesting to relax the work experience requirement). The user clicks the "Accept" button, triggering a closed-loop update. The resume list and statistical card are incrementally refreshed to show the newly added matching resumes after the relaxation of criteria. The above four-round operation sequence is executed sequentially under the drive of the two-way interactive closed-loop mechanism. The recruitment context state is accurately accumulated with each interaction event, and the interface state is only incrementally rendered for the changed nodes. In the whole process, the user only inputs the first natural language command, and the remaining operations are completed through direct interaction with the rendering component. This fully demonstrates the substantial improvement of the two-way interactive closed-loop mechanism on the operational efficiency and decision continuity in the recruitment decision-making scenario.

[0057] Example 2

[0058] like Figure 2 As shown, this embodiment further explains the process of assembling the recruitment field structured component calling protocol in step S3, based on embodiment 1.

[0059] S3.1: Assemble a structured component calling protocol for the recruitment domain, which includes a protocol version field, a component type field, a component identifier field, a data mapping field, a layout field, an event field, and a metadata field; wherein the data mapping field contains the data source identifier and query statement, the layout field contains the position, sorting, and width, the event field contains the component's event binding definition, and the metadata field carries the chart selection confidence level.

[0060] The RCCP protocol generation submodule fills in the protocol content one by one according to the following field specifications: The protocol version field (protocol_version) records the current RCCP specification version number, used by the front-end dynamic rendering middleware to perform version compatibility checks; the component type field (component_type) takes the enumerated values ​​of component types supported by the recruitment-specific front-end component library, such as grouped_bar_chart, stat_card, resume_list, task_list, actionable_suggestion, clarification_card, etc.; the component identifier field (component_id) is the unique identifier of the component instance in this call, generated by the intelligent agent decision engine when generating the protocol by combining the session identifier and timestamp, used to accurately locate the target component during subsequent incremental updates; the data mapping field (data_mapping) is a first-level sub-module... The fields include a data source identifier (source) and a query statement (query), specifying the data source service name and the specific structured query expression, respectively; the layout field (layout) includes three subfields: position (values ​​are chat_bubble / independent panel / sidebar), order (smaller values ​​are rendered first), and width (expressed as a percentage), controlling the component's spatial layout in the dialog flow; the events field (events) defines the event types supported by the component and their corresponding postback action identifiers in the form of a key-value pair array, for example, {"event_name":"on_bar_click","action":"filter_by_job"}; the metadata field (metadata) is an extensible field that carries the chart selection confidence (gp_confidence) value in chart selection scenarios, allowing the front end to display the selection basis to the user when necessary.

[0061] Preferably, the following is a complete JSON example of a structured component call protocol in the recruitment field, used to describe the complete component call intent for rendering a grouped bar chart of "comparison of resume submissions for each position across weeks" under the recruitment data analysis intent: {"protocol_version": "1.0","component_type": "grouped_bar_chart","component_id": "sess_001_chart_20240315143022","data_mapping":{"source": "recruitment_data_service","query": "SELECT job_name, week, SUM(resume_count)AS resume_count FROM resume_stats WHERE week IN ('last week', 'this week') GROUP BY job_name, week ORDER BY job_name","labels_field": "job_name","series_field":"week","values_field": "resume_count"},"layout": {"position": "chat_bubble","order": 1,"width": "100%"},"events": [{"event_name": "on_bar_click","action":"filter_by_job"}],"metadata": {"gp_confidence": "0.87"}}.

[0062] The `component_id` field is composed of the session identifier `sess_001` and the generation timestamp, ensuring the unique addressability of each component instance within the same session. During subsequent incremental updates, the rendering middleware can accurately locate the target node based on this identifier. The `data_mapping.query` field carries the complete structured query statement, allowing the front-end dynamic rendering middleware to directly submit the query to the data service layer for execution without needing to understand the recruitment business semantics. The `data_mapping.labels_field` specifies that the `job_name` field in the query results will be used as the horizontal axis label for the grouped bar chart, corresponding to each job title. The `data_mapping.series_field` specifies that the `week` field is used to distinguish data series, with one set of bars for last week and one for this week. The `data_mapping.values_field` specifies that the `resume_count` field will be used as the numerical value corresponding to the height of each series bar. The `metadata.gp_confidence` field has a value of 0.87, indicating that the current Gaussian process model has a high confidence level in the selection of the grouped bar chart, and the front-end does not need to display alternative chart type prompts to the user. The integrity of the JSON structure and the self-descriptive nature of its fields enable the front-end dynamic rendering middleware to independently complete the entire rendering process from component loading to event binding without relying on any recruitment business knowledge, fully embodying the protocol decoupling design principle between the intelligent agent decision layer and the front-end rendering layer.

[0063] S3.2: The data mapping fields also include tag field mapping, series field mapping and numeric field mapping; when parsing the recruitment domain structured component calling protocol, recruitment data query is performed based on the data source identifier and the query statement, and the query results are mapped and injected into the attributes of the loaded component according to the tag field mapping, the series field mapping and the numeric field mapping.

[0064] In addition to the data source identifier and query statement, the data mapping field (data_mapping) includes three sub-fields: label field mapping (labels_field), series field mapping (series_field), and values ​​field mapping (values_field). Label field mapping specifies the field names used as horizontal axis labels in the query results (e.g., job_name), series field mapping specifies the field names that distinguish data series (e.g., week, corresponding to the "last week" and "this week" series), and values ​​field mapping specifies the corresponding values ​​for each series (e.g., resume_count). When the front-end dynamic rendering middleware parses the RCCP protocol, it first routes to the corresponding recruitment data service based on the data source identifier, sending the query statement to that service to execute the data query. After the query results are returned, the rendering middleware, according to the above three types of field mapping rules, injects the values ​​of each field in the query results into the labels, series, and values ​​arrays in the component instance's props property, driving the component to complete data binding and final rendering. The aforementioned protocol-based data mapping mechanism completely decouples the data description intent of the agent's decision engine from the specific rendering logic of the front-end component. The front-end component does not need to be aware of the business semantics of the data source, and the agent does not need to understand the rendering implementation details of the front-end component.

[0065] It is important to emphasize that the Recruitment Domain Structured Component Calling Protocol (RCCP) of this invention is not a simple application of the general JSON data exchange format, but a structured communication protocol specifically designed for recruitment business scenarios and carrying recruitment business semantics. Its core features that distinguish it from general protocols (such as OpenAPI, GraphQL, JSON-RPC, etc.) are reflected in the following three aspects:

[0066] Feature 1: The data mapping fields include field mappings (labels_field / series_field / values_field) that reflect the semantics of recruitment business. The general protocol only defines the data source identifier and query statement; the front-end needs to understand the data semantics and perform visualization binding itself. The RCCP protocol, through the three sub-fields labels_field, series_field, and values_field, explicitly encodes the agent's semantic understanding of the data structure (such as "horizontal axis labels correspond to job titles," "series distinctions correspond to week numbers," and "values ​​correspond to resume submission volume") into the protocol. This allows the front-end rendering middleware to complete the precise binding of data to chart attributes without needing to understand the recruitment business, achieving a separation of responsibilities: "the agent is responsible for semantic understanding, and the front-end is responsible for mechanical execution."

[0067] Feature Two: Event fields define recruitment-specific event types. The RCCP protocol's event fields not only support the general `on_click` event but also predefine semantic events specific to the recruitment scenario, such as `on_bar_click` (clicking a bar chart data point, payload includes the job title), `on_check` (checking a candidate, payload includes a list of candidate IDs), `on_adopt` (adopting a suggestion, payload includes suggestion parameters), and `on_clarification_select` (clarifying the selection, payload includes the selected component type). These domain-specific events accurately convey the semantics of user interactions to the agent, eliminating the need for secondary semantic interpretation of the interaction behavior on the front end.

[0068] Feature 3: Metadata fields carry chart selection confidence levels. The RCCP protocol's metadata fields reserve structured fields such as `gp_confidence` to carry the agent's confidence level in its component selection decisions. The front-end can use this confidence level to decide whether to show the user alternative chart types (e.g., displaying "Do you want to view other chart types?" when the confidence level is below 0.6), thus providing users with an opportunity to actively participate in the selection process when the agent's decision-making is highly uncertain, improving the transparency and controllability of the interaction.

[0069] The above three core features make the RCCP protocol a dedicated bridge connecting the semantic understanding layer of the intelligent agent and the front-end rendering layer, rather than a simple reproduction of a general data exchange protocol. This is the key technical means for the present invention to achieve "protocol decoupling".

[0070] The design principle of the Recruitment Domain Structured Component Invocation Protocol (RCCP) stems from a deep solution to the communication boundary problem between the agent's decision engine and the front-end component library. In technical approaches that do not incorporate RCCP, agents typically interact with the front-end in two ways: first, by directly generating front-end framework code (such as JSX or Vue template code). This method requires the agent to be aware of the technical details of the front-end framework, and the generated code risks becoming invalid if the front-end framework is upgraded or the component implementation changes; second, by outputting fixed text cards in a preset format. This method cannot carry recruitment business semantics such as data dimension types and query semantics, cannot dynamically switch component types based on data characteristics, and cannot express the data dependencies and interaction event binding intentions between components, resulting in the output format always being limited to a finite static template. The core technical principle of the RCCP protocol is to replace the "specific rendering implementation instructions" with "structured intent descriptions carrying recruitment business semantics". The agent only needs to express "what type of components need to be displayed, where to get data from, what layout to use, and what interactive events to support" according to the protocol specifications, without having to care about how the front end implements rendering; the front-end dynamic rendering middleware only needs to execute rendering according to the protocol specifications, without having to understand the recruitment business semantics, thereby completely decoupling the agent's decision-making ability from the front-end rendering implementation at the architectural level.

[0071] Furthermore, the proposed protocol decoupling design brings substantial technical benefits at different stages of the system lifecycle. In terms of system maintainability, when a new component type is added to the dedicated front-end component library, only the corresponding `component_type` enumeration value and the corresponding rendering middleware adaptation logic need to be added to the RCCP protocol specification; the core reasoning logic of the agent's decision engine remains unchanged. Conversely, when the agent's component selection strategy (such as the sparse Gaussian process slot machine described in Example 4) is iterated and upgraded, as long as the field definitions in the protocol specification remain stable, the front-end rendering layer requires no changes. This ability for independent evolution of the two layers significantly reduces version management costs during long-term system operation and maintenance. In terms of interpretability and auditability, each component decision is fully recorded in structured JSON format, including the reasons for component type selection, data sources and query statements, and chart selection confidence levels. This supports auditing historical RCCP protocols, facilitating rapid identification of the root cause of interface rendering anomalies. At the multi-platform adaptation level, the same RCCP protocol can be parsed and executed by different front-end rendering adaptation layers for Web, mobile (iOS / Android) and desktop. Each platform only needs to implement its own rendering middleware, and the protocol layer itself does not need to be modified, thus achieving the architectural goal of "one agent decision, multi-platform protocol adaptation".

[0072] In a typical application scenario, a user enters "Help me check the difference in resume submissions for Java development and product manager positions this week" in the chat interface of a recruitment management platform. The large language model identifies the recruitment intent as "recruitment data analysis" and the data dimension as "comparative". The intelligent agent decision engine generates an RCCP protocol containing two components: a grouped bar chart (gp_confidence=0.87) and statistical cards (gp_confidence=0.79). The front-end dynamic rendering middleware does not need to understand the business meaning of "Java development" or "product manager". It only initiates a standardized query to the data service layer based on the structured query statement in the data_mapping.query field of the RCCP protocol. It injects the query results into the component attributes according to the mapping rules of data_mapping.labels_field, data_mapping.series_field, and data_mapping.values_field, embeds the component into the chat bubble container according to layout.position=chat_bubble, and binds the on_bar_click event handler function to the bar chart according to the events field, completing the entire rendering process. Throughout the process, the intelligent agent is responsible for "understanding intent and deciding on the presentation scheme," while the front end is responsible for "executing rendering instructions." The two systems exchange information only through RCCP protocol JSON documents, forming a system architecture with clear boundaries of responsibilities, high cohesion, and low coupling, which fundamentally breaks the limitations of the static text output format of traditional conversational recruitment systems.

[0073] Example 3

[0074] This embodiment, based on embodiment 1, further explains the process of component selection and chart type decision-making in step S2 by combining the recruitment context state and the multi-dimensional features of the queried recruitment data.

[0075] S2.1: Perform multi-dimensional feature analysis on the retrieved recruitment data to identify data dimension types, including comparative, trend, proportion, funnel, and multi-dimensional evaluation types.

[0076] The recruitment data feature identification module performs multi-dimensional feature analysis on recruitment data samples retrieved from the data service layer. The analysis process first examines the dimensional structure of the data: if the data contains two or more discrete classification dimensions and focuses on the quantitative differences between each classification, it is identified as comparative; if the data contains a time series dimension and focuses on the trend of indicators over time, it is identified as trend-based; if the data contains only a single classification dimension and focuses on the proportional relationship between each category and the total, it is identified as proportion-based; if the data structure corresponds to the conversion rates of each stage of the recruitment funnel (e.g., the step-by-step conversion from application to initial screening to interview to offer), it is identified as funnel-based; if the data contains multiple evaluation dimensions with different dimensions and focuses on the comprehensive evaluation of the same candidate across multiple dimensions, it is identified as multi-dimensional evaluation-based. The data dimensional type identification results serve as the core basis for subsequent chart type selection.

[0077] S2.2: Based on the mapping rules between data dimension type and chart type, map the comparative type to grouped bar chart, the trend type to line chart, the percentage type to pie chart or donut chart, the funnel type to recruitment funnel chart, and the multi-dimensional evaluation type to job matching radar chart to obtain adaptive chart selection results.

[0078] After identifying the data dimension types, the recruitment data feature identification module performs deterministic mapping according to the built-in dimension type and chart type mapping rule table: For comparative data, grouped bar charts are selected to clearly present the quantitative comparison relationship across categories using group intervals; for trend data, line charts are selected to intuitively display the time-series change trajectory using continuous lines; for percentage data, pie charts or donut charts are selected (donut charts are preferred when there are more than 6 categories to ensure readability), using sector areas to present the proportion of each category; for funnel data, recruitment funnel charts are selected to intuitively reflect the candidate conversion rate at each stage of recruitment using a shrinking funnel shape; for multi-dimensional evaluation data, person-job matching radar charts are selected to comprehensively present the evaluation results of candidates in multiple dimensions such as skills, experience, and matching degree using multi-axis polygon areas. These mapping rules ensure a high degree of semantic matching between charts and data while fully reflecting the professional visualization requirements of recruitment business scenarios. The adaptive chart selection results, along with the candidate component type combination and data dependencies, are jointly transmitted to the RCCP protocol assembly stage.

[0079] Example 4

[0080] Based on Example 3, this embodiment replaces the static rule mapping of chart types in step S2.2 with a chart type progressive optimization method based on sparse Gaussian process slot machine, so as to realize the continuous adaptive optimization of chart selection strategy according to user interaction feedback.

[0081] Step S2.2.1: Concatenate the data dimension type, job category, and user historical preference vector into a context feature vector.

[0082] The context feature vector v is composed of three concatenated parts, with approximately 35 dimensions: the first part is the one-hot encoding of the data dimension type, with 5 dimensions, corresponding to five categories: comparative, trend, proportion, funnel, and multi-dimensional evaluation; the second part is the one-hot encoding of the job category, with dimensions determined according to the size of the job category library, covering major job categories such as technology R&D, product design, marketing, and functional support; the third part is the user's historical preference vector, obtained by averaging the user's satisfaction feedback signals for each chart type in historical interaction sessions through a sliding window, with dimensions consistent with the number of selectable chart types. The context feature vector v comprehensively characterizes the objective features of the current recruitment data (data dimension type), business scenario attributes (job category), and the user's subjective preference history (user historical preference vector), providing multi-dimensional contextual input for subsequent Gaussian process posterior calculations.

[0083] Step S2.2.2: Calculate the expected satisfaction and uncertainty of each chart type using a variational sparse Gaussian process posterior. The variational sparse Gaussian process uses a radial basis kernel function and represents the posterior with induced points. The induced points are learned offline from historical interaction data by maximizing the variational lower bound.

[0084] Chart type selection is modeled as a contextual multi-armed slot machine problem, with each chart type... For each arm, the reward signal is the user's satisfaction rating of the chart. (A represents the set of all available chart types), maintain a variational sparse Gaussian process model, using user satisfaction distribution as the modeling objective. The kernel function used is a radial basis function (RBF kernel). ,in For signal variance, For length-scale hyperparameters, both are estimated offline from historical interaction data by maximizing the variational lower bound (ELBO). The parameter v' represents a copy or transformed form of the context feature vector v, used to maintain sign independence in variational inference. The sparsity scheme uses m induced points (m ranging from 50 to 100) to represent the posterior of the Gaussian process; the positions of these induced points are also learned offline from the historical data distribution by maximizing the variational lower bound. During online inference, only the learned m induced points are needed to perform posterior prediction, resulting in a computational complexity of O(n log n). This is independent of the amount of historical interaction data, ensuring constant real-time performance of online inference. Given the current context feature vector v, the variational sparse Gaussian process outputs the expected satisfaction for each arm. and uncertainty ,in Predicted from the posterior mean. The square root of the posterior variance prediction. The source of the user satisfaction signal is multi-dimensional behavioral data of user interaction with the chart, including the user's viewing time on the chart (the longer the viewing time, the higher the satisfaction), screenshot operation (triggering a screenshot indicates high information value), and the correlation of subsequent operations (such as making a filtering decision based on the chart data, the correlation is high). The three factors are weighted and comprehensively scored as the satisfaction reward signal for this interaction.

[0085] Furthermore, the overall satisfaction score is calculated as follows:

[0086]

[0087] The definitions of each component are as follows: View duration rating Based on the user's cumulative dwell time t (in seconds) on the chart, after logarithmic normalization, the following is obtained: ,in The score is calculated using the 95th percentile of the longest historical dwell time. A logarithmic transformation is used to suppress the dimensional influence of abnormally long dwell times, causing the score to converge to the [0,1] interval. (Screenshot operation scoring) The rating is binary: a value of 1 is assigned if the user takes a screenshot or saves the chart while viewing it, and a value of 0 otherwise. The screenshot action serves as a high-confidence, explicit satisfaction signal regarding the value of the information the user actively retains; subsequent actions are rated based on relevance. The percentage of user actions that directly reference the chart's data dimension in subsequent actions after viewing the chart is calculated, ranging from [0,1]. This reflects the actual driving force of the chart on the user's subsequent decision-making behavior (e.g., users clicking to filter specific positions based on the bar chart, or manually adjusting filter conditions based on chart values, are all counted as related operations). The default weights for the three dimensions are w1=0.4, w2=0.3, and w3=0.3, with a slightly higher weight for viewing duration than for the correlation between screenshotting and subsequent actions. This reflects the coverage advantage of viewing duration as basic behavioral data while giving a higher weight to high-confidence active signals such as screenshots. The weights can be adjusted through A / B experiments based on the user behavior characteristics of specific recruitment platforms. The final comprehensive satisfaction score reward ranges from [0,1] and is written into the historical interaction dataset along with the current context feature vector as training samples for the variational sparse Gaussian process posterior update, driving continuous personalized optimization of the chart selection strategy.

[0088] Step S2.2.3: According to the upper confidence bound strategy, the sum of the expected satisfaction and the uncertainty value after weighting by the exploration and utilization trade-off parameter is used as the upper confidence bound score of each chart type. The chart type with the highest upper confidence bound score is selected as the adaptive chart selection result, and the inverse of the uncertainty is output as the chart selection confidence level to the metadata field of the recruitment domain structured component calling protocol. The exploration and utilization trade-off parameter decreases inversely proportional to the square root of the number of interactions as the number of interactions increases.

[0089] For each chart type The formula for calculating the upper confidence boundary (UCB) score is as follows: Where β is the exploration and utilization trade-off parameter. In the initial stage of system launch, historical data is limited, and the satisfaction estimates for each chart type have significant uncertainty. At this time, a larger value for β is taken to encourage exploration of different chart types and expand the coverage of satisfaction data. As the number of interactions n increases, data accumulation gradually reduces uncertainty, and β is adjusted accordingly. The pattern gradually diminishes, shifting from "exploration-first" to "utilization-first," selecting the chart type with the highest expected satisfaction, where β... n β0 represents the exploration trade-off parameter at the nth interaction, and β0 represents the preset initial exploration trade-off parameter. The chart type with the highest upper confidence bound score is the adaptive chart selection result output in this step, which is passed to the RCCP protocol assembly stage; at the same time, the uncertainty corresponding to the selected chart type is... The inverse (i.e.) The `gp_confidence` field is used as the chart selection confidence level. It is filled with the metadata field (metadata.gp_confidence) of the RCCP protocol, so that the front end can show the user alternative chart types when the confidence level is low.

[0090] Step S2.2.4: Based on the chart satisfaction signal in the user interaction feedback, asynchronously update the variational sparse Gaussian process posterior and the induction point to form a learning closed loop for chart selection.

[0091] After the chart is rendered and displayed, the system asynchronously collects user interaction data (viewing duration, screenshot operations, and relevance of subsequent operations) to calculate a comprehensive satisfaction score. This score, along with the current context feature vector v, is written into the historical interaction dataset as new training samples. The variational sparse Gaussian process posterior update employs an asynchronous batch approach, performing a batch variational inference update after accumulating a certain number of new samples. This synchronously updates the position and covariance parameters of the inducing points, thus incorporating the latest user preference information into the posterior distribution and improving the accuracy of chart selection in subsequent similar scenarios. The above sequence of "chart selection → rendering and display → satisfaction feedback → posterior update" constitutes a complete learning loop, enabling the chart selection strategy to be continuously and personalizedly optimized as user engagement deepens.

[0092] It should be understood that the chart type progressive optimization method based on sparse Gaussian process slots has unique technical adaptability in recruitment dialogue scenarios compared to other chart type adaptive solutions. Traditional adaptive selection solutions (such as frequency statistical sorting and ε-greedy multi-armed slots) do not incorporate contextual features such as data dimension type and job category into chart preference modeling, but only maintain the global average satisfaction of each chart type. This fails to capture context-related heterogeneous preferences such as "technical R&D managers tend to use line charts to track weekly trends, while business development managers tend to use pie charts to view channel proportions," causing the chart selection optimization benefit to decline rapidly with the increase in user group diversity. Ordinary (non-sparse) Gaussian process solutions have context modeling capabilities, but their online inference computational complexity increases with the amount of historical interaction data n by O(n^2). 3 As historical data accumulates to several thousand records, the online inference time exceeds the real-time limit of less than 2 seconds for recruitment dialogue scenarios, limiting engineering feasibility. The sparse Gaussian process solution introduces m induction points (m is much smaller than n, typically 50 to 100) to reduce the online inference complexity from O(n^2) to O(n^2). 3 ) decreased to O(m 2 |A|) (where |A| is the number of selectable chart types, typically 5), in the offline stage, the optimal position of the inducement point is learned by maximizing the variational lower bound. In the online stage, only the learned m inducement points are used to perform posterior prediction. This achieves both constant online inference complexity and high-precision uncertainty quantification capability. This is the core technology choice of this invention to achieve personalized chart selection optimization under the real-time constraints of recruitment dialogue scenarios.

[0093] In this embodiment of the invention, the following uses specific numerical examples to illustrate the working process of the sparse Gaussian process in a real recruitment interaction scenario. Suppose a user is recruiting for a technical R&D position. The context feature vector v of the current input command is composed of a one-hot encoding of the "comparative" data dimension type, a one-hot encoding of the "technical R&D" job category, and the user's historical preference vector [0.75, 0.60, 0.30, 0.45, 0.50] (corresponding to the historical average satisfaction of five chart types: grouped bar chart, line chart, pie / ring chart, recruitment funnel chart, and job matching radar chart, respectively). The variational sparse Gaussian process performs posterior prediction on each of the five chart types, outputting the expected satisfaction and uncertainty estimates as follows: Grouped bar chart ( =0.82, =0.08); Line chart ( =0.45, =0.15); Pie chart / donut chart ( =0.38, =0.12); Recruitment funnel chart ( =0.55, =0.10); Person-job matching radar chart ( =0.60, =0.18). The current system has accumulated 60 interactions (t=60). Explore the use of trade-off parameters... Attenuation, let =1.0 then The upper confidence bound scores for each chart type are as follows: Grouped bar chart UCB = 0.82 + 0.129 × 0.08 ≈ 0.830; Line chart UCB = 0.45 + 0.129 × 0.15 ≈ 0.469; Pie / Donut chart UCB = 0.38 + 0.129 × 0.12 ≈ 0.395; Recruitment funnel chart UCB = 0.55 + 0.129 × 0.10 ≈ 0.563; Job-person matching radar chart UCB = 0.60 + 0.129 × 0.18 ≈ 0.623. The system selects the grouped bar chart with the highest UCB score (UCB ≈ 0.830) as the adaptive chart selection result; the grouped bar chart corresponds to uncertainty. =0.08, the chart selection confidence score gp_confidence is normalized to 0.92 and written to the RCCP protocol metadata field. If the front end determines that the confidence score is higher than the display prompt threshold, it will not show the user the alternative chart type suggestions.

[0094] Furthermore, the above example illustrates the differences in performance of the equilibrium mechanism at different stages of the system's lifecycle. In the initial stage of system deployment (t=5). The uncertainty of each chart type remains high (e.g., a certain chart). =0.30), the uncertainty item contributed 0.134 to the UCB score, indicating that the system prefers to explore chart types with higher uncertainty, even if the expected satisfaction is not the highest, to quickly expand the coverage of satisfaction data in various contexts; as users continue to use the system until t=200, The contribution of uncertainty decayed to 0.021, and the UCB score was mainly driven by expected satisfaction. The system shifts to a stable approach, utilizing accumulated preference knowledge to consistently select the chart type with the highest expected satisfaction, achieving a smooth transition from exploration-driven to utilization-driven approaches. This continuously improves the personalized accuracy of chart selection in long-term use in recruitment dialogue scenarios.

[0095] Example 5

[0096] like Figure 3 As shown, this embodiment, based on embodiment 1, further explains the process in step S4 of parsing the structured component calling protocol in the recruitment field, loading components on demand from the recruitment-specific front-end component library, and injecting recruitment data query results to render interactive rendering components.

[0097] S4.1: Parse the component type field, data mapping field, layout field, and event field of the structured component calling protocol in the recruitment field to obtain the component loading instruction, data query instruction, layout configuration, and event binding instruction.

[0098] After receiving the RCCP protocol JSON, the front-end dynamic rendering middleware performs a protocol version compatibility check. Once it confirms that the current rendering middleware version supports the protocol version, it parses each business field sequentially. From the component type field (component_type), it parses the component loading instructions, which include the name of the component to be loaded and version constraints. From the data mapping field (data_mapping), it parses the data query instructions from the data source identifier (source) and query statement (query). From the layout field (layout), it parses the layout configuration, including the target mounting position, component sorting priority, and display width. From the event field (events), it parses the event binding instructions, including the event name, trigger condition, and postback action identifier for each event. The parsing results of these four types of instructions are cached in the corresponding processing stages of the rendering pipeline for subsequent sequential execution.

[0099] S4.2: Based on the component loading instruction, load the corresponding component definition from the recruitment-specific front-end component library as needed, execute the recruitment data query based on the data query instruction, and inject the query result into the component attribute to obtain the component instance after data injection.

[0100] The rendering middleware, based on the component name in the component loading instruction, queries the component registry of the recruitment-specific front-end component library for the corresponding component definition module. If the component definition has not yet been loaded to the client, it initiates asynchronous on-demand loading (lazy loading), and instantiates the component in memory after loading. If the component definition is already cached on the client, it is directly read from the cache and instantiated, eliminating the need for repeated network requests and reducing rendering latency. Simultaneously, the rendering middleware initiates a data query request to the recruitment data service layer based on the data query instruction. The query results are then injected into the component instance's props (such as labels, series, values, etc.) according to the label field mapping, series field mapping, and numeric field mapping rules in the data mapping fields, completing the component's data binding and obtaining the data-injected component instance.

[0101] S4.3: Based on the layout configuration, mount the component instance to a specified position in the dialog flow, where the specified position includes a dialog bubble, a standalone panel, or a sidebar.

[0102] The rendering middleware determines the mounting target of component instances based on the position field in the layout configuration: when position is set to chat_bubble, the component is embedded in the bubble container of the current chat turn and displayed side by side with the text reply, suitable for lightweight statistics cards or short suggestion components; when position is set to "independent panel", the component has an independent display area below the chat flow, providing ample space to display complex components such as charts or lists; when position is set to "sidebar", the component is mounted to the sidebar area on the right side of the chat interface, suitable for task lists or continuously tracking components that need to be continuously visible and not disappear with chat scrolling. The order field in the layout configuration controls the rendering order of multiple components in the same chat turn, with components with smaller order values ​​being rendered closer to the user's line of sight first; the width field controls the horizontal proportion of the component within the mounting container as a percentage.

[0103] S4.4: Bind an event handling function to the component instance based on the event binding instruction to obtain an interactive rendering component.

[0104] The rendering middleware, based on the event binding instructions, iterates through each event definition in the event field and binds a unified event handling function to the corresponding event (such as on_click, on_check, on_adopt, etc.) of the component instance. This unified event handling function performs the following actions when the event is triggered: capturing the event type (event_type), the current component identifier (component_id), the trigger timestamp (timestamp), and the event payload (containing specific parameters of the user's operation, such as the clicked bar index, the checked task ID, the adopted suggestion content, etc.); encapsulating the above information into a structured event message; and pushing the structured event message to the server-side intelligent agent decision engine in real time via the WebSocket event postback channel. After event binding is complete, the component instance becomes an interactive rendering component, capable of sensing and responding to various user operations, and is a key front-end infrastructure for realizing a two-way interactive closed loop.

[0105] Example 6

[0106] Based on Example 1, this embodiment introduces a global rendering budget optimization step based on shadow price after obtaining the candidate component type combination and before assembling the recruitment field structured component calling protocol.

[0107] Step S2.3: Construct an inference utility function for each candidate component in the candidate component type combination. The inference utility function increases with the amount of rendering resources allocated to the candidate component and decreases to saturation at the marginal utility level. The utility cap of the inference utility function is weighted by the inherent information significance of the candidate component for the current recruitment decision.

[0108] For each candidate component c in the candidate component type combination, its inference utility function U(c) is constructed. This inference utility function has the following properties: as the amount of rendering resources e(c) allocated to component c increases, the utility monotonically increases; however, the marginal utility (i.e., the first derivative of U with respect to e(c)) continuously decreases as e(c) increases, eventually approaching saturation, characterizing the diminishing marginal utility of component rendering—once the component has obtained sufficient resources to fully present key information, the information increment brought by additional resources becomes increasingly small. The inference utility function is weighted by the inherent information salience (s) of the candidate component for the current recruitment decision. The inherent information salience reflects the component type's ability to provide valuable information in the current recruitment decision context, and is synchronously output by the component selection decision rule base in step S2, with a value range of (0,1). This utility function design enables highly salient components (such as charts most directly related to the current intent) to obtain higher utility with the same resource input, thereby obtaining more resource allocation in global optimization.

[0109] Step S2.4: Construct a global constraint optimization problem with the total amount of rendering resources that the current dialog interface can support as a constraint and the goal of maximizing the sum of the inference utilities of all candidate components. Solve the global constraint optimization problem and output the global shadow price that makes the marginal utilities of each candidate component that receives positive rendering resource allocation equal.

[0110] Let B be the total rendering resources (rendering budget) that the current dialog interface can support. Construct a global constraint optimization problem for all candidate components: (For all c). The above problem is a convex optimization problem (since U(c) is a concave function), and the optimal solution can be derived through the KKT (Karush-Kuhn-Tucker) conditions. Under the optimal allocation, the global shadow price... Satisfies: For all components c that receive positive rendering resource allocation (i.e., e(c) > 0), their marginal utility equals the global shadow price, i.e. For component c allocated zero resources, its marginal utility at zero resources does not exceed the global shadow price, i.e. Global shadow price In an economic sense, the price signal that represents the maximum marginal contribution of an additional unit of rendering budget to the overall information utility is the core price signal for achieving optimal resource allocation.

[0111] Step S2.5: Allocate zero rendering resources to candidate components whose marginal utility is always lower than the global shadow price to perform rational abstention, and redistribute the amount of rendering resources released by the abstaining candidate components to candidate components whose inference utility is about to enter a rapid increase phase, to obtain the globally optimal rendering budget allocation scheme.

[0112] Based on global shadow price The solution results are used to classify the candidate component set: for those that satisfy... Candidate components (whose marginal utility is lower than the global shadow price even at zero resources) undergo rational abstention, forcibly allocating e(c)=0 and releasing their potential budget allocation back to the global budget pool. The economic implication of this rational abstention mechanism is that investing any resources in such components leads to a loss of global utility; therefore, the optimal strategy is to completely abandon rendering these components. The rendering resources released by the abstaining components are then redistributed according to the principle of prioritizing components closest to the information emergence threshold: priority is given to candidate components whose inference utility function is in a rapidly rising phase (i.e., e(c) is just below the information emergence threshold), enabling these components to cross the emergence threshold and enter the high-utility range, achieving the redistribution goal of "maximizing marginal resource input and output." Finally, the globally optimal rendering budget allocation scheme is output, recording the optimal rendering resource allocation e for each candidate component. * (c)

[0113] Step S2.6: The subset of candidate components with positive rendering resource amounts in the global optimal rendering budget allocation scheme is used as the basis for assembling the recruitment domain structured component calling protocol.

[0114] Select e from the globally optimal rendering budget allocation scheme. * Candidate components (c) > 0 form a subset of valid components participating in RCCP protocol assembly. Rational abstention (e) * Candidate components with (c)=0) do not generate corresponding RCCP protocol entries, meaning that these components are not rendered in this dialogue round. The subset of effective components and their corresponding data dependencies are passed to step S3, where the RCCP protocol JSON for each component is generated according to the protocol assembly process described in Example 2. This ensures that, under the constraint of the total rendering budget, only the set of components with the highest value to the current recruitment decision information is rendered, thereby maximizing the global information utility.

[0115] Example 7

[0116] Based on Example 6, this embodiment further explains the specific construction method of the inference utility function in step S2.3 and the resource reallocation principle in step S2.4.

[0117] Step S2.3.1: Measure the amount of rendering resources allocated to the candidate component as a number of rendering tokens weighted by component complexity.

[0118] The rendering resource quantity e(c) of each candidate component is measured in terms of render tokens and component complexity coefficients. (c) Weighting is performed, i.e., e(c) = (c)·t(c), where t(c) is the original number of rendering tokens. (c) represents the component complexity coefficient. The component complexity coefficient κ(c) is pre-defined based on the component type: statistical cards with fewer data series. Smaller (e.g.) =1.0), grouped bar charts, line charts, and other charts containing multiple series of data and axes. Centered (e.g.) =1.5), charts with complex drawing logic such as job-person matching radar charts and recruitment funnel charts. Larger (e.g.) =2.0). Using complexity-weighted rendering tokens as a resource quantity metric can more accurately reflect the actual rendering computing resources and interface space resources occupied by components, making global budget constraints practically operable.

[0119] Step S2.3.2: Determine the salience of the inherent information as the support score of the component type of the candidate component for the current recruitment decision.

[0120] The inherent information significance s(c) of candidate component c is determined by looking up a table in the component selection decision rule base according to the correlation strength between the current recruitment intention type and the candidate component type. The value range is (0,1], and the higher the value, the stronger the direct support of the component type for the current recruitment decision. For example, under the recruitment data analysis intention, the grouped bar chart directly presents the comparative data, with a support score s=0.9; the statistical card provides the summary value, with a support score s=0.6; the resume list has a low correlation with the current intention, with a support score s=0.4. The inherent information significance s(c) serves as the upper limit weighting coefficient of the utility function, ensuring that highly significant components always have a higher utility valuation under the same resource input, thus gaining an advantage in the global shadow price competition.

[0121] Step S2.3.3: Construct the inference utility function as follows: in the initial stage when the amount of rendering resources is lower than the information emergence threshold, the inference utility increases as the amount of rendering resources increases; after the amount of rendering resources exceeds the information emergence threshold, the marginal increment of the inference utility tends to saturate.

[0122] The inference utility function takes the form of a shifted-surge utility function:

[0123] Where s(c) represents the inherent information significance (utility ceiling). The utility growth rate parameter (controls the speed at which utility rises rapidly to saturation, and is related to the information emergence threshold of the component). (The larger the value, the smaller the emergence threshold). In the stage where e(c) is below the information emergence threshold τ(c) = 1 / α, the inference utility grows rapidly with resource input, but the growth rate gradually slows down. When e(c) exceeds τ(c), the marginal utility tends to saturate, corresponding to a stage where additional resources can only refine existing information. The above function accurately describes the two-stage characteristics of the rendering utility of the recruitment visualization component: "information emergence - marginal saturation".

[0124] Methods for determining the utility growth rate parameter α: Parameter α controls the rate at which the inference utility of the component rises rapidly to saturation, and its reciprocal τ = 1 / α is the information emergence threshold. α can be determined using one of the following two methods:

[0125] Method 1 (Component Complexity Calibration): Pre-calibrate the α value based on the component type. For components with high information density and where a small amount of data is sufficient to present the core conclusion (e.g., statistical cards, which only need to display a single value), a larger α value is used (e.g., α = 0.12, corresponding to τ ≈ 8.3 rendering tokens). For components with multiple information dimensions and requiring more data to fully present the information (e.g., job matching radar charts, which need to display scores across 5-7 dimensions), a smaller α value is used (e.g., α = 0.025, corresponding to τ = 40 rendering tokens). The specific calibration process is as follows: For each component type, domain experts assess the "minimum amount of data required to present the core information," convert this data amount into the number of rendering tokens as the information emergence threshold τ, and then reverse-calculate α = 1 / τ.

[0126] Method 2 (Optimization based on A / B testing): Treating α as a configurable hyperparameter, A / B testing is conducted in the early stages of system deployment to compare user satisfaction ratings (such as subjective ratings of the amount of information in charts) under different α values, and the α value that maximizes average satisfaction is selected. Experiments show that fluctuations in α within ±20% have no more than 5% impact on satisfaction, indicating that the utility function is robust to the value of α.

[0127] The information emergence threshold τ = 1 / α physically represents the minimum amount of rendering resources required for a component to present its core information from scratch. When the number of rendering tokens e(c) allocated to a component is less than τ, the component has not yet obtained enough resources to display its key information. At this time, the utility increase brought by adding resources is the fastest (the utility function curve is in the steep rising segment). When e(c) exceeds τ, the component has basically presented its core information completely, and adding resources can only be used for secondary optimizations such as beautification and animation, and the marginal utility drops sharply. The existence of this threshold makes the allocation of rendering budget have a clear "critical point". The core value of the global shadow pricing mechanism is to identify and prioritize the allocation of resources to the components closest to the critical point, so as to achieve the effect of "using the best resources where they are most needed".

[0128] To avoid s(c) becoming out of touch with actual user preferences due to its long-term reliance on a static rule base, this embodiment provides an automatic update method based on user feedback. Specifically, after each user interaction, the system collects implicit feedback signals from the user regarding the rendered components (such as viewing time and relevance to subsequent operations), and calculates a comprehensive satisfaction score according to the method described in Embodiment 4. When a sufficient number of satisfaction scores (e.g., more than 20) have accumulated for the same component type under the same intent type, the average value is taken as the updated significance score for that component type under that intent type, replacing the initial static value in the rule base. This update process is executed asynchronously in batch processing, without occupying the user-perceptible response path. Through this dynamic update mechanism, s(c) can adaptively adjust to changes in user habits, avoiding long-term resource allocation misallocation due to initial calibration deviations.

[0129] Step S2.4.1: The step of reallocating the rendering resources released by the abstaining candidate components to the candidate components whose inference utility is about to enter a rapid increase phase includes: allocating the rendering resources released by the abstaining candidate components to the candidate components whose inference utility is about to exceed the information emergence threshold, based on the principle of prioritizing those closer to the information emergence threshold.

[0130] When reallocating rendering resources released by abstaining candidate components, the system calculates the current allocation e for each component in the valid component subset. * (c) Distance from its information emergence threshold (c)=1 / The gap (c)= (c)-e * (c) (only for) (c) Components with a value greater than 0 are counted, i.e., components that have not yet reached the emergence threshold. (According to...) (c) Sort by size from smallest to largest, prioritizing the allocation of released resources to components with the smallest gap (i.e., those closest to the information emergence threshold and "most likely" to cross the threshold and enter the high-utility range), until the released resources are exhausted or all components that have not reached the threshold have crossed it. This redistribution principle prioritizing the emergence threshold is mathematically equivalent to maximizing the global utility increment under the condition of limited additional resources, because the resource investment that just crosses the information emergence threshold corresponds to the steepest inflection point region of the utility function curve, where the utility increment per unit of resource is the largest.

[0131] The following numerical example illustrates the complete calculation process and effect of optimal global rendering budget allocation based on shadow prices. Suppose that in a certain dialogue round, the agent's decision engine outputs four candidate components: Component A is a grouped histogram (intrinsic information significance s=0.9, utility growth rate...). =0.08, corresponding to the information emergence threshold =1 / 0.08=12.5 rendering tokens), component B is the statistics card (s=0.7, =0.10, =10 rendering token), component C is a job matching radar chart (s=0.4, =0.02, =50 rendering tokens), component D is a recruitment funnel chart (s=0.3, =0.015, ≈67 rendering tokens). The total rendering budget for the current dialog interface is B = 30 rendering tokens. The inference utility function is in the form of... The marginal utility of each component at zero resources (i.e., the slope of the utility function at e=0) are as follows: A: 0.9×0.08=0.072; B: 0.7×0.10=0.070; C: 0.4×0.02=0.008; D: 0.3×0.015=0.0045.

[0132] Solve the KKT conditions for the global constraint optimization problem and derive the global shadow price. Since the zero-resource marginal utility of components C and D (0.008 and 0.0045, respectively) is significantly lower than that of components A and B (0.072 and 0.070, respectively), it can be determined that C and D both receive zero-resource allocation under optimal allocation (i.e., are rationally abstained), and the total budget... Allocate all assets to A and B. Apply KKT and other marginal conditions to A and B: Let ,Right now Combined with constraints Solving the system of equations simultaneously, we get... (Rendering token) (Rendering token), Global shadow price Verify the rational abstention condition: C has zero marginal utility of resources. The zero marginal utility of resources of D Both components satisfy the rational abstention judgment condition and are allocated zero rendering resources. It should be noted that the economic implication of the abstention judgment mechanism is that the utility increment from allocating any rendering token to component C or D is lower than the utility increment from allocating the same token to component A or B. Therefore, the optimal strategy is to concentrate all budgets on the most efficient components A and B. In the numerical example above, the total inferred utility under the globally optimal allocation scheme (A:17, B:13, C:0, D:0) is U. A (17)+U B (13) = 0.9 × (1 - exp(-0.08 × 17)) + 0.7 × (1 - exp(-0.10 × 13)) ≈ 0.9 × 0.742 + 0.7 × 0.727 ≈ 0.668 + 0.509 = 1.177; compared to the naive equal distribution scheme (each component is allocated 7.5 rendering tokens), the total inference utility U A (7.5)+U B (7.5)+U C (7.5)+U D(7.5)≈0.9×0.451+0.7×0.527+0.4×0.139+0.3×0.107≈0.406+0.369+0.056+0.032=0.863, the information utility improvement of the globally optimal allocation scheme reaches 36.4%; in the scenario where the rendering budget is further tightened to B=15, the utility difference between the two schemes can reach 2 to 3 times, which is consistent with the statement in the beneficial technical effects section of the manual that "a global information utility improvement of up to 3 times can be achieved when the rendering budget is tight", verifying the core technical value of the mechanism in the scenario where rendering resources are limited.

[0133] Furthermore, the benefits of the above mechanism are even more pronounced when the resource quotas released by the abstaining component are used in conjunction with resource reallocation. Consider another scenario where there exists a component E that has already been allocated... Render token (not yet reached the information emergence threshold) Rational abstention releases 10 rendering tokens for reallocation. The system calculates the difference between each non-abstention component and the emergence threshold: Component A's (The emergence threshold has been exceeded) Component B (The emergence threshold has been exceeded), component E's (The emergence threshold has not yet been reached, so the gap is minimal). Following the principle of prioritizing components approaching the emergence threshold, two rendering tokens are allocated to component E first, allowing it to cross the information emergence threshold and enter the high-utility range. The remaining eight rendering tokens are then allocated sequentially according to their marginal utility, maximizing the utility increment from each additional resource and achieving the globally optimal goal of rendering budget reallocation.

[0134] Example 8

[0135] Based on Example 1, this embodiment introduces an answerability gating step based on Bayesian selective inference after the agent decision engine regenerates the updated recruitment domain structured component calling protocol and before performing incremental updates on the interactive rendering component.

[0136] Step S5.1: The agent decision engine maintains the Bayesian posterior distribution of recruitment intention type and optimal component type, calculates the posterior approximation of the Bayesian posterior distribution through variational inference, and uses the normalized complement of the posterior entropy of the posterior approximation with respect to the optimal component type relative to the maximum possible entropy as the answerability gating index.

[0137] The agent decision engine maintains a Bayesian posterior distribution for each dialogue session. ,in It contains two implicit variables: recruitment intention type. and optimal component type ; x represents the current recruitment context features (including user command text, context state feature vector, and data dimension type); D represents the historical interaction data of this session (including historical event messages and component selection records). Since precise posterior computation is infeasible in high-dimensional parameter spaces, the system employs a variational inference method based on parameterized distribution families. (e.g., mean field distribution) approximates the true posterior. Optimize variational parameters by maximizing the lower bound of evidence (ELBO) , to obtain the posterior approximation Based on posterior approximation Calculate its relationship with the optimal component type Conditional marginal distribution entropy And with that entropy relative to the maximum possible entropy (Right now The normalized complement of the entropy (when uniformly distributed across all candidate component types) is used as the answerability gating index: . A higher value indicates a more concentrated posterior (lower uncertainty, more sufficient evidence), while a lower value indicates a more dispersed posterior (higher uncertainty, less sufficient evidence).

[0138] To meet the requirement of less than 2 seconds for end-to-end response latency in recruitment dialogue scenarios, the system uses a mean-field variational family to approximate the true posterior, decomposing the multidimensional joint posterior into a product of independently distributed dimensions. During each round of responsiveness gating verification, only a few steps of gradient descent updates (typically 5 to 10 steps) are needed for the variational parameters, without waiting for complete variational inference convergence. The convergence criterion is: when the change in ELBO (lower bound of evidence) over two consecutive steps is less than a preset threshold δ (e.g., δ=0.01), the current posterior approximation is considered to have reached sufficient accuracy, and iteration stops. This threshold was calibrated through offline testing before system deployment, ensuring that in over 95% of scenarios, 5-10 iterations are sufficient to meet the convergence condition.

[0139] The responsiveness gating index A(x) is based on the posterior distribution with respect to the optimal component type. The marginal entropy is calculated, not the joint entropy. This is because: even if the recruitment intention type While uncertainties exist (e.g., ambiguous user commands leading to dispersed posterior intent types), as long as the posterior distribution of the optimal component type is sufficiently concentrated (e.g., regardless of whether the intent is "data analysis" or "resume screening," the optimal component is always a statistics card), the answerability gating metric can still be high, allowing the system to render without clarification. This design avoids excessive clarification triggered by intent type uncertainty, thus improving interaction efficiency.

[0140] Preset gate threshold The default value is 0.7, which can be determined as follows: During the offline testing phase of the system, a set of historical interaction data is collected. For each interaction sample, its answerability gating index A(x) and the user's subsequent satisfaction score (0-1) for component selection are calculated. A scatter plot of A(x) versus satisfaction score is plotted, and the cutoff point where "user satisfaction significantly decreases when A(x) is below the threshold" is selected as the threshold. In a typical experiment, when A(x) < 0.7, the average user satisfaction drops below 0.6, while when A(x) ≥ 0.7, the average user satisfaction remains above 0.85. Therefore, 0.7 is taken as the default threshold. Different recruitment platforms can adjust the threshold using the same method based on their own data; this threshold supports online configuration.

[0141] When the posterior approximation quality of variational inference is poor (e.g., due to variational parameters getting stuck in a local optimum, causing ELBO to be significantly lower than expected), the system initiates a degradation scheme: it degrades to directly selecting the component type with the highest posterior probability for rendering, while setting the chart selection confidence in the metadata field to a lower value (e.g., 0.5), allowing the front-end to display alternative chart type suggestions to the user when necessary. The degradation scheme is triggered when the ELBO remains below a preset threshold (e.g., -100) after the variational inference iteration steps reach the upper limit (e.g., 20 steps). This degradation scheme ensures that the system can still render normally in extreme cases and will not interrupt interaction due to variational inference failure.

[0142] Step S5.2: When the responsiveness gating index is not less than the preset gating threshold, the current evidence is determined to be sufficient, and the updated recruitment domain structured component calling protocol is used for the incremental update.

[0143] Set preset threshold (The default value is 0.7, which can be configured according to business needs). When When the evidence provided by the current context feature x and the historical interaction data D is sufficient to make the posterior distribution fully concentrated on a certain optimal component type, the agent decision engine has a sufficiently high confidence in the component selection result, and directly transmits the currently updated RCCP protocol to the front-end dynamic rendering middleware to perform incremental updates, thus normally advancing the two-way interaction closed loop.

[0144] Step S5.3: When the answerability gating index is less than the preset gating threshold, it is determined that the current evidence is insufficient, and active information acquisition is initiated: from the candidate information source set including user clarification requests, recruitment data supplementation and context history backtracking, the information source with the largest ratio of expected answerability improvement to acquisition cost is selected as the target information source.

[0145] when At this point, the system determines that the current evidence is insufficient to reliably determine the optimal component type. Forcing rendering at this stage might select a component that doesn't match the user's actual needs, causing interface clutter and a degraded user experience. Therefore, the system initiates a proactive information acquisition process. The candidate information source set I includes three categories: user clarification requests (actively inquiring about user preferences), recruitment data supplementation (automatically performing additional data queries), and context history backtracking (loading earlier dialogue history to supplement context). The system uses a cost-calibrated Bellman strategy to calculate the ratio of expected answerability improvement to acquisition cost for each type of information source. ,in The expected increase in answerability gating index after obtaining information source i (estimated by historical data statistics) is defined as cost(i), where cost(i) is the cost of obtaining this information source (user clarification request cost=2.0, requiring interruption of the user; recruitment data supplementation cost=1.0, requiring waiting for data query; context history backtracking cost=0.5, only requiring reading from the local cache). The information source i* with the largest ratio(i) is selected as the target information source.

[0146] Step S5.4: Perform information acquisition based on the target information source, and send the acquired information back to update the Bayesian posterior distribution. After narrowing the posterior entropy, trigger the next round of responsiveness gating.

[0147] Based on target information source i * Execute the corresponding information acquisition action (see Example 9 for specific execution method). After acquiring new information, append this information as new observation data D' to the historical interaction data D, and re-execute variational inference to update the posterior approximation. The introduction of new information increases the posterior constraints, and the posterior entropy... The responsiveness gating index has been narrowed compared to the previous version. The corresponding improvements will be made. After the update is complete, the next round of responsiveness gating verification will be triggered, and the assessment will be re-evaluated. and The size relationship is determined. If the criteria are met, the RCCP protocol is used to perform an incremental update. If the criteria are still not met, the information source is repeatedly selected and information acquisition is performed until... Or it may reach the maximum number of information acquisition rounds limit.

[0148] In this embodiment of the invention, the following specific numerical examples illustrate the complete workflow of the Bayesian answerability gating mechanism to help understand its technical value in preventing mis-rendering and proactively disambiguating in actual recruitment interaction scenarios. Suppose a user inputs the recruitment instruction "Help me organize the information about the technology R&D department." Since this instruction is semantically broad, after parsing the current context features, the agent decision engine calculates the Bayesian posterior distribution... The probabilities are relatively dispersed across multiple candidate component types: grouped bar chart (posterior probability 0.35), line chart (posterior probability 0.25), job-person matching radar chart (posterior probability 0.20), and resume list (posterior probability 0.20). Posterior entropy. =-(0.35×log20.35+0.25×log20.25+0.2×log20.20+0.20×log20.20)≈1.97 bits; Maximum possible entropy Bits (entropy when the four candidate components are uniformly distributed); the responsiveness gating index A(x) = 1 - 1.97 / 2.00 = 0.015, which is far below the preset gating threshold. =0.7, indicating that the current evidence is seriously insufficient.

[0149] After answerability gating is triggered, the system calculates the ratio of expected answerability improvement to acquisition cost for three types of information sources using a cost-calibrated Bellman strategy: context history backtracking. =0.12 / 0.5=0.24 (Lowest acquisition cost, but historical records show this user's first query for technical R&D data, so the expected gain from historical data backtracking is limited); Recruitment data supplementary query =0.25 / 1.0=0.25 (Executing an additional dimension data query is expected to provide data differentiation for component type determination); User clarification request =0.55 / 2.0=0.275 (Actively inquiring about user preferences yields the greatest expected improvement in responsiveness but also the highest cost). Based on the principle of maximizing the ratio, the system selects the user's clarification request as the target information source. The system generates a component invocation protocol for the clarification card component type. From the candidate array of clarification cards, it presents the top 3 candidate component types with the highest posterior probability (grouped bar chart: preview of "comparison of resume submissions across positions"; line chart: preview of "recent trend changes in submissions"; person-job matching radar chart: preview of "candidate multi-dimensional evaluation radar chart") and their respective data summaries, rendering the clarification card component for the user to choose from.

[0150] It should be understood that if the grouped bar chart with the highest posterior probability is directly selected for rendering without answerability gating, the posterior probability of the grouped bar chart in the above numerical example is only 0.35, meaning that the system selects a component type that is not actually needed by the user with a 65% probability. In recruitment management scenarios, the cost of incorrect rendering is not only visual interference, but also leads to subsequent incorrect decisions based on incorrect component data (such as users mistakenly believing it is a comparison of application volume data and making incorrect adjustments to the screening criteria), the cost of which is far higher than the slight interruption cost of initiating a clarification request to the user. The answerability gating mechanism, by quantifying the posterior entropy, uses the comparison between the level of decision uncertainty and the gating threshold as a precondition for rendering. When the evidence is sufficient (A(x)≥0.70), rendering is quickly advanced; when the evidence is insufficient (A(x)<0.70), the information source actively disambiguates at the lowest cost, achieving an optimal balance between reliability and response efficiency.

[0151] It should be noted that the real-time engineering implementation of variational inference is as follows: To meet the end-to-end response latency requirement of less than 2 seconds in recruitment dialogue scenarios, the system uses a mean-field variational family to approximate the true posterior. The multidimensional joint posterior is decomposed into a product of independent distributions in each dimension. During each round of responsiveness gating verification, only a few steps of gradient descent updates (typically 5 to 10 steps) are needed to update the variational parameters. Without waiting for the complete variational inference to converge, the updated posterior approximation can be obtained within milliseconds. It also calculates the latest answerability gating metric A(x); the complete variational inference converges precisely in the background in an asynchronous batch manner, and the results are updated to the state store before the next request arrives, without consuming computing resources on the user-perceived response path.

[0152] It should be noted that the optimal allocation of the global rendering budget (Examples 6-7) and the responsiveness gating (this example) are two independent optional mechanisms that can be implemented individually or in combination. When implemented in combination, to maintain a consistent logical order, this example specifies that the responsiveness gating decision is a prerequisite for both rendering budget allocation and protocol assembly. The specific execution order is as follows:

[0153] After completing component selection and chart type decision in step S2, the answerability gating determination is performed first (step AC in this embodiment). If A(x) is less than the preset gating threshold... If the evidence is deemed insufficient, proactive information gathering (user clarification, data supplementation, or historical backtracking) is initiated. Once A(x) reaches the gating threshold after information gathering, rendering budget allocation (Example 6) and protocol assembly (Example 3) are performed based on the component selection result when the evidence is sufficient. If A(x) is not less than the gating threshold, the rendering budget allocation and protocol assembly process is directly initiated. This sequence ensures that when the component type selection is not yet reliable, optimization computing resources for rendering budget allocation are not invested, avoiding improper budget allocation due to component type uncertainty.

[0154] When only answerability gating is implemented without rendering budget allocation, the protocol assembly and incremental update proceed directly after gating. When only rendering budget allocation is implemented without answerability gating, budget allocation is executed directly after component selection. The above combination order only applies to scenarios where both are implemented simultaneously and does not change the execution position when each mechanism is implemented individually.

[0155] Example 9

[0156] Based on Example 8, this embodiment further explains the three specific scenarios of information acquisition based on the target information source in step S5.3.

[0157] Step S5.3.1: When the target information source is a user clarification request, a component invocation protocol of component type clarification card is generated. The data mapping field of the clarification card contains a candidate array. The candidate array contains a preset number of candidate component types with the highest posterior probability, chart type, preview description and data summary. The event field of the clarification card defines the clarification selection event. The clarification card component is rendered, and the Bayesian posterior distribution is updated based on the user's selection event on the clarification card component.

[0158] When the target information source i *When clarifying a user's request, the intelligent agent's decision engine sorts the candidate component types according to their posterior probabilities and selects the top N (default N=3) candidate component types with the highest posterior probabilities. For each type, it generates a candidate description object containing a chart type (chart_type), a preview description (preview_description, a textual description of the chart type's display style and presented information dimensions), and a data summary (data_summary, a summary of the key numerical values ​​of the current data under that chart type), forming a candidate array (candidates). This is used to construct the component invocation protocol for the component type "clarification_card". Its data mapping field, the candidates array, contains the aforementioned N candidate object objects, its event field defines the on_clarification_select event, and its payload_schema is { "selected_chart_type": "string"}. The front-end renders this clarification card component, displaying previews and summaries of the N candidate visualizations to the user, guiding them to select the chart type that best suits their needs. After a user selects an option on the clarification card, the on_clarification_select event is triggered. The selected_chart_type field in the event payload is fed back as strong deterministic observation evidence (likelihood close to 1) and appended to the historical interaction data D, driving the Bayesian posterior distribution to converge quickly to the component type selected by the user, and the answerability gating index A(x) is greatly improved.

[0159] Step S5.3.2: When the target information source is recruitment data supplementation, the intelligent agent decision engine performs additional recruitment data query to update the Bayesian posterior distribution with the updated recruitment context state.

[0160] When the target information source i * When supplementing recruitment data, the agent decision engine automatically generates supplementary data query instructions based on the additional data dimensions required by the candidate component type with the highest probability in the current posterior distribution, and sends additional query requests to the recruitment data service layer (such as querying supplementary dimension data like the distribution of candidates' education level and years of work experience). After the additional query results are returned, the recruitment context management submodule merges the new data into the current recruitment context state, updates the context feature vector x, and re-executes variational inference with the updated x to update the Bayesian posterior distribution. Since additional data dimensions can typically provide effective distinguishing criteria for component type determination, the posterior entropy is thus narrowed, and the answerability gating metric A(x) is correspondingly improved. This information acquisition method is fully automated and does not require interruption of the user, making it suitable for scenarios where posterior uncertainty mainly stems from insufficient data rather than ambiguity in user intent.

[0161] Step S5.3.3: When the target information source is context history backtracking, load the dialogue history to supplement the recruitment context state and update the Bayesian posterior distribution, wherein the user clarification request, the recruitment data supplementation and the context history backtracking are respectively configured with successively decreasing acquisition costs.

[0162] When the target information source i * When performing contextual history backtracking, the recruitment context management submodule loads historical interaction records from earlier dialogue rounds in the current session. It extracts historical recruitment intent types, historical component selection results, and user satisfaction feedback for historical components. This historical interaction information is then used as prior context to supplement the current context features. Variational inference is then re-executed with the expanded historical context to update the Bayesian posterior distribution. Historical backtracking effectively utilizes continuous information within a session, helping to mitigate posterior uncertainty caused by insufficient information in a single instruction round. The acquisition costs of the three information sources are configured sequentially as follows: user clarification request cost = 2.0 (consuming user attention and interrupting the user's current operation flow), recruitment data supplementation cost = 1.0 (requiring waiting for data service response), and contextual historical backtracking cost = 0.5 (only reading the local session cache, with negligible latency). This sequentially decreasing acquisition cost configuration ensures that the system prioritizes low-cost information sources under the cost-calibrated Bellman strategy, only initiating clarification requests to the user when the expected gain from low-cost information sources is insufficient.

[0163] Coordination Mechanism between Sparse Gaussian Process Slot Machine and Answerability Gating: It should be noted that the graph type incremental optimization based on sparse Gaussian process slot machine (Example 4) and user clarification based on answerability gating (step D.1 of this embodiment) operate at different decision levels. The two operate in coordination with "answerability gating as the main method and slot machine as the auxiliary method", rather than being parallel decisions that conflict with each other.

[0164] The specific coordination logic is as follows: In each round of interaction, the responsiveness gating first determines whether the current evidence is sufficient (A(x)≥ If the evidence is sufficient, the sparse Gaussian process slot machine selects the chart type according to the upper confidence bound strategy, and outputs the selection result as the adaptive chart selection result; if the evidence is insufficient... If the target information source is a user clarification request, a clarification card is rendered for the user to choose from. The user's explicit choice serves as strong deterministic observational evidence, taking precedence over the slot machine's upper confidence bound selection based on historical data—that is, the component and chart types determined by the user's clarification in this round are prioritized, overriding the slot machine's implicit selection results. Simultaneously, the user's explicit choice on the clarification card is asynchronously written into the historical interaction dataset as a high-confidence satisfaction signal under the context's feature vector, participating in the update of the variational sparse Gaussian process posterior and inducement points, allowing the slot machine to adjust its chart type preference in this context accordingly.

[0165] The core principle of the aforementioned coordination mechanism is that the answerability gating is responsible for determining "whether clarification is needed," while the slot machine is responsible for automatically selecting the optimal chart type when "clarification is not needed." The answerability gating quantifies decision uncertainty through posterior entropy, assigning scenarios with high uncertainty (low A(x)) to explicit user decision-making and scenarios with low uncertainty (high A(x)) to implicit optimization by the slot machine, thus achieving an intelligent division of labor between "user decision-making and machine learning." Furthermore, if the component type selected by the user for clarification is not within the previous candidate component type combination, the component at the corresponding position in the candidate component type combination is replaced with the user-selected component type, and the structured component invocation protocol for the recruitment domain is reassembled accordingly.

[0166] Example 10

[0167] This embodiment, based on Embodiment 1, illustrates the implementation process of the progressive task management function in the recruitment process.

[0168] Step S6.1: Based on user instructions, break down the recruitment process into multiple task steps according to the recruitment funnel stages. Each task step corresponds to a stage of the recruitment funnel. Generate a task list component calling protocol that includes task identifier, task name, task status, responsible person, deadline, and inter-task dependencies, and render the task list component.

[0169] Once the user's natural language input is recognized as an intent type of "task decomposition and follow-up," the intelligent agent decision engine, based on the job posting information specified in the instruction, decomposes the recruitment process according to the standard stage sequence of the recruitment funnel (job posting → resume screening → initial telephone screening → interview arrangement → offer negotiation → hiring and onboarding), generating a list of task steps for each stage. Each task step object contains the following fields: task identifier (task_id, a unique string identifier), task name (task_name, such as "posting JD", "screening resumes", etc.), task status (status, the first task is "in progress" at initialization, and the remaining tasks are "pending"), assignee (assigned from the recruitment team member list according to job responsibilities), due date (due_date, configured evenly according to the overall recruitment timeline and stages), and dependencies between tasks (represented by a list of task_ids of the dependent tasks, forming a directed acyclic graph structure). The above task step list is encapsulated according to the RCCP protocol with component_type as task_list, and passed to the front-end dynamic rendering middleware to render the task list component. The task status dashboard of the complete recruitment process is presented in the dialog interface in the form of a visual list.

[0170] Step S6.2: Based on the user's operation event on the task list component, the operation event is sent back to the intelligent agent decision engine, which updates the task status of the corresponding task step to the completed state, and advances the task status of subsequent task steps to the in-progress state according to the inter-task dependency relationship, generating an updated task list component calling protocol.

[0171] When a user checks the "complete" checkbox for a specific task step on the task list component, the component's event handler is triggered. This event handler encapsulates the event type (event_type=task_complete), the completed task identifier (task_id), and the timestamp into a structured event message, which is then sent to the agent decision engine via a WebSocket return channel. Upon receiving the task completion event, the agent decision engine updates the task status field of the corresponding task_id to "completed" (status=completed) in the task list data of the recruitment context. It then traverses the dependency graph, searching for all subsequent task steps that depend on that task_id, and checks if all its dependencies are completed. If so, it advances the task status of that subsequent task step from "pending" to "in progress" (status=in_progress), thus automating the recruitment process. Based on the updated task list data, it reassembles the RCCP protocol of type task_list to generate an updated task list component call protocol.

[0172] Step S6.3: Based on the updated task list component call protocol, incrementally update the task list component to obtain the automatically advanced task list component.

[0173] The front-end dynamic rendering middleware, based on the updated task list RCCP protocol, performs a virtual DOM differential comparison on the rendered task list component. It only partially updates task row nodes whose task status has changed (completed tasks and subsequent tasks newly marked as "in progress"), while leaving the remaining task rows unchanged, achieving incremental rendering with the smallest granularity. The updated task list component clearly presents the current recruitment process progress status visually (e.g., completed tasks are displayed with a strikethrough, and in-progress tasks are highlighted), enabling visualized tracking and dependency-driven automated advancement of the entire recruitment process, helping recruitment managers monitor the execution status of each stage in real time.

[0174] A linkage mechanism triggering further reasoning by the agent after task status updates: To further enhance the deep linkage between the task list component and the agent's core reasoning, when a user marks a task step as "completed," the agent's decision engine not only advances the status of subsequent tasks in the task list but also performs a round of recruitment bottleneck detection and suggestion generation based on the updated recruitment context status. Specifically, after completing the task status update, the agent's decision engine automatically checks the overall progress of the current recruitment process: if it detects that the conversion rate of a certain recruitment funnel stage is significantly lower than the benchmark (e.g., the pass rate in the resume screening stage is lower than 10%), it automatically generates a recruitment suggestion component call protocol (see Example 11), renders the recruitment suggestion component after the task list component, and alerts the user to the bottleneck and provides improvement suggestions. This linkage mechanism makes task management no longer an isolated state advancement but combined with the agent's proactive decision-making capabilities, forming a complete intelligent closed loop of "task advancement → status update → bottleneck detection → suggestion generation → user adoption → parameter adjustment → data refresh," thereby improving the intelligence level of recruitment process management.

[0175] Furthermore, when the recruitment parameters modified by the user's adopted recruitment suggestion (such as education screening criteria, work experience requirements, etc.) happen to be parameters that a certain task step in the task list component depends on, the intelligent agent decision engine further searches the task list component for task steps whose dependent parameters have been modified by this adoption. It then performs a corresponding re-evaluation and update of the task status or content of that task step—for example, resetting the "resume screening" task step, which depends on this screening parameter, to a state of re-execution. Based on this, it generates an updated task list component call protocol and performs incremental updates to the task list component. Thus, the parameter changes caused by the adoption of the recruitment suggestion are synchronously propagated to the affected task steps in the task list component, achieving cross-component state linkage between the recruitment suggestion component and the task list component.

[0176] Example 11

[0177] This embodiment, based on Embodiment 1, illustrates the implementation process of the executable recruitment suggestion component and the bidirectional closed-loop execution function.

[0178] Step A: Based on the recruitment bottlenecks identified by the intelligent agent decision engine during the recruitment process, a recruitment suggestion component invocation protocol is generated, which is an executable suggestion component. The recruitment suggestion component invocation protocol includes suggestion text, suggestion reason and executable action buttons. The executable action buttons include an adopt button, a modified adopt button and an ignore button. The recruitment suggestion component is then rendered.

[0179] During the execution of recruitment data analysis or resume screening tasks, the intelligent agent decision engine continuously performs anomaly detection and bottleneck identification on key indicators (such as the number of resumes submitted, pass rate, and interview conversion rate for each position) in the current recruitment context. When a recruitment bottleneck is identified (such as the initial screening pass rate for a certain position being significantly lower than the benchmark level, possibly due to overly strict screening criteria causing the resume funnel to close too quickly), the intelligent agent decision engine generates improvement suggestions for the bottleneck and encapsulates the suggestions into an RCCP protocol with component_type as actionable_suggestion. Its data_mapping field contains the suggestion text (suggestion_text, describing the specific suggestion content, such as "suggest relaxing the educational requirement to a bachelor's degree"), the suggestion reason (suggestion_reason, providing data support, such as "under the current educational screening conditions, the initial screening pass rate is only 12%, lower than the industry benchmark of 30%), and the configuration of executable action buttons (an array of actions, containing three operation items: an accept button, a modified accept button, and an ignore button, each button associated with a different event type identifier). The front-end renders a recruitment suggestion component, which presents the agent's optimization suggestions and data basis to the recruitment manager in a structured card format. It also supports the recruitment manager to make different levels of decision-making responses through three operation buttons.

[0180] Step B: Based on the user's adoption of the recruitment suggestion component, the adoption event is sent back to the intelligent agent decision engine, which updates the recruitment parameters, re-executes the recruitment data query based on the updated recruitment parameters, and generates updated component calling protocols for the statistical card component and resume list component.

[0181] When a user clicks the "Accept" button on the recruitment suggestion component, the component's event handler is triggered. This triggers a structured event message containing the event type (event_type=suggestion_adopt), the corresponding suggestion component identifier (component_id), and the suggestion payload (containing the suggestion operation type and parameter values, such as {"action_type": "relax_education", "new_value":"Bachelor's degree or above"}). This message is then sent to the agent decision engine via a WebSocket return channel. The agent decision engine parses the suggestion parameters in the event message and automatically updates the corresponding recruitment parameters (such as educational background screening criteria) in the recruitment context state to the suggested values. Based on the updated recruitment parameters, it re-initiates a data query to the recruitment data service layer to obtain statistical data on the number of candidates after the relaxation of screening criteria and a list of matching resumes. Based on the new query data, it generates updated statistical card components (component_type=stat_card, presenting the adjusted total number of resumes, pass rate, and other key indicators) and resume list components (component_type=resume_list, presenting a list of candidates meeting the new screening criteria) using the RCCP protocol.

[0182] Step C: Perform incremental rendering based on the component calling protocol of the updated statistics card component and resume list component to obtain the refreshed statistics card component and resume list component.

[0183] The front-end dynamic rendering middleware, based on the updated statistics card and resume list RCCP protocol, performs incremental updates on the corresponding component instances already rendered in the dialogue flow: numerical fields (such as total number of resumes, pass rate) in the statistics card component are replaced with the latest queried values, and the list data in the resume list component is replaced with a set of candidate records under the new filtering conditions. Only DOM nodes with changed data content are partially re-rendered, keeping other interface elements unchanged. The refreshed statistics card component and resume list component reflect the latest status of recruitment data after the adoption of suggestions in real time, enabling recruitment managers to instantly verify the effect of parameter adjustments. This forms a complete closed loop of "suggestion → adoption → execution → update," seamlessly connecting the agent's decision-making suggestions with the actual execution of recruitment operations, significantly improving the intelligence level and operational efficiency of the recruitment management platform.

[0184] Furthermore, when a passive display component triggered by a user command (such as the task list component triggered by the "task decomposition and follow-up" intent as described in Embodiment 10) and an active display component actively pushed by the agent to detect recruitment bottlenecks (such as the recruitment suggestion component as described in this embodiment) coexist in the same dialogue round, the presentation order of the two components in the dialogue flow is determined according to the display priority of the passive display component over the active push component: when assembling the recruitment domain structured component call protocol, a smaller layout order value is configured for the passive display component triggered by the user command, and a larger layout order value is configured for the recruitment suggestion component actively pushed by the system, so that the task list component is rendered first and the recruitment suggestion component follows closely behind. Moreover, the recruitment suggestion component is presented after the task list component in the form of an executable suggestion card embedded in the dialogue flow, rather than in the form of a modal pop-up that interrupts the user's current operation, so as to present bottleneck improvement suggestions in a timely manner without interfering with the user's viewing and operation of the task list. The passive-over-active display sorting rule is independent of the rule in Example 1 that merges candidate components according to intent type priority when multiple user intent rules are concurrently hit in the same round, and applies to the trigger source dimension and intent type dimension respectively.

[0185] Furthermore, regarding the cross-component state linkage between the recruitment suggestion component and the task list component: when the recruitment parameters modified by the user's adopted recruitment suggestion (such as education screening criteria, work experience requirements, etc.) happen to be parameters that a certain task step in the task list component depends on, the intelligent agent decision engine, while re-executing the recruitment data query, refreshing the statistics card component and the resume list component based on the updated recruitment parameters, further searches the task list component for task steps whose dependent parameters have been modified by this adoption. It then re-evaluates and updates the task status or content of that task step accordingly—for example, resetting the "resume screening" task step that depends on this screening parameter to a state that needs to be re-executed. Based on this, it generates an updated task list component call protocol and performs an incremental update on the task list component. Thus, the parameter changes caused by the adoption of recruitment suggestions are synchronously transmitted to the affected task steps in the task list component, achieving cross-component state linkage between the recruitment suggestion component and the task list component, and preventing the task list state from lagging behind the actual recruitment progress after parameter changes.

[0186] Example 12

[0187] This embodiment provides an intelligent agent-driven dynamic user interface generation system for recruitment scenarios, including a processor and a memory. The memory stores a computer program, and when the processor executes the computer program, it implements the steps of the methods described in Embodiments 1 to 11.

[0188] Specifically, the system includes the following functional modules at the software architecture level: a large language model intent recognition module, responsible for recognizing recruitment intent and parsing business semantics based on the recruitment domain knowledge base, and outputting a structured description of recruitment intent type and business semantics; a recruitment data feature recognition module, responsible for performing multi-dimensional feature analysis on recruitment data queried from the data service layer, identifying data dimension types, and outputting adaptive chart selection results according to mapping rules; an intelligent agent decision engine, responsible for performing component selection and chart type decisions based on the recruitment context state, maintaining the Bayesian posterior distribution, performing answerability gating before incremental updates, and outputting a structured component calling protocol for the recruitment domain; an RCCP protocol generation submodule, responsible for assembling candidate component type combinations, data dependencies between components, and adaptive chart selection results into a formatted structured component calling protocol for the recruitment domain according to the JSONSchema specification, field by field; and a recruitment context... The management submodule is responsible for loading and maintaining the recruitment context state according to the dialogue session identifier, and updating the state in response to interactive events and information acquisition results. The front-end dynamic rendering middleware is responsible for parsing the structured component calling protocol in the recruitment domain, loading component definitions from the recruitment-specific front-end component library on demand, performing recruitment data queries and attribute injection, mounting component instances to the specified positions in the dialogue flow according to the layout configuration, and binding event handling functions to component instances according to event binding instructions. The recruitment-specific front-end component library includes predefined components such as statistical cards, grouped bar charts, line charts, pie charts / donut charts, recruitment funnel charts, job matching radar charts, resume lists, task lists, executable suggestion cards, and clarification cards. Each component encapsulates the display logic and interaction logic of the recruitment business domain. The WebSocket event return channel is responsible for pushing user interaction events to the server-side intelligent agent decision engine in real time, forming a real-time communication infrastructure for a two-way interactive closed loop.

[0189] The memory can specifically be a read-only memory (ROM), random access memory (RAM), flash memory, or a hard disk; the processor can be a central processing unit (CPU), a graphics processing unit (GPU), or a dedicated inference chip with tensor acceleration capabilities. In deployment scenarios with intensive large language model inference tasks, GPUs or dedicated inference chips are preferred to meet the real-time requirement of less than 2 seconds for end-to-end response latency in recruitment dialogue scenarios; in lightweight deployment scenarios with limited computing power, the inference task of the large language model intent recognition module can be offloaded to a cloud server, while the remaining modules run locally, using a hybrid architecture of cloud inference and local rendering to balance intelligence level and response efficiency.

[0190] It should be noted that the above embodiments are illustrative of this application and not restrictive, and those skilled in the art can design alternative embodiments without departing from the scope. Unless otherwise specified, the steps in the above embodiments should not be construed as limiting the order of execution.

[0191] The above description is merely a specific embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the technical scope disclosed in the present invention should be included within the scope of protection of the present invention. Therefore, the scope of protection of the present invention should be determined by the scope of the claims.

Claims

1. An agent-driven dynamic user interface generation method for a recruitment scenario, characterized in that, include: By combining a large language model with a knowledge base in the recruitment domain, recruitment intent and business semantics are identified from the natural language commands input by users, resulting in a structured description of recruitment intent type and business semantics. Based on the structured description of the recruitment intent type and business semantics, and combined with the recruitment context state and the multi-dimensional features of the queried recruitment data, component selection and chart type decision are made to obtain candidate component type combinations, data dependencies between components, and adaptive chart selection results. Based on the candidate component type combination, the data dependency relationship between the components, and the adaptive chart selection result, a structured component calling protocol for the recruitment field is assembled. The structured component calling protocol in the recruitment field is parsed, components are loaded on demand from the recruitment-specific front-end component library and recruitment data query results are injected, and interactive rendering components are rendered. Based on the user's interaction with the interactive rendering component, the interaction event is sent back to the intelligent agent decision engine and the recruitment context state is updated. The updated recruitment domain structured component calling protocol is regenerated, and the interactive rendering component is incrementally updated to obtain the updated interactive interface.

2. The method of claim 1, wherein, The assembly of the structured component invocation protocol for the recruitment domain, based on the candidate component type combination, the data dependencies between components, and the adaptive chart selection result, includes: The assembled structured component calling protocol for the recruitment domain includes fields such as protocol version, component type, component identifier, data mapping, layout, event, and metadata. The data mapping field contains the data source identifier and query statement; the layout field contains the position, sorting and width; the event field contains the event binding definition of the component; and the metadata field carries the chart selection confidence level. The method further includes: the data mapping field also includes tag field mapping, series field mapping and numeric field mapping; when parsing the recruitment domain structured component calling protocol, recruitment data query is performed based on the data source identifier and the query statement, and the query results are mapped and injected into the attributes of the loaded component according to the tag field mapping, the series field mapping and the numeric field mapping.

3. The method of claim 1, wherein, The process of combining the recruitment context state with multi-dimensional features of the retrieved recruitment data to select components and make chart type decisions yields candidate component type combinations, data dependencies between components, and adaptive chart selection results, including: The retrieved recruitment data is subjected to multi-dimensional feature analysis to identify data dimension types, including comparative, trend, proportion, funnel, and multi-dimensional evaluation types. Based on the mapping rules between data dimension types and chart types, comparative charts are mapped to grouped bar charts, trend charts are mapped to line charts, percentage charts are mapped to pie charts or donut charts, funnel charts are mapped to recruitment funnel charts, and multi-dimensional evaluation charts are mapped to job matching radar charts, resulting in adaptive chart selection results.

4. The method of claim 3, wherein, The selection of the chart type is achieved through progressive optimization of the chart type based on the sparse Gaussian process slot machine, including: The data dimension type, job category, and user historical preference vector are concatenated into a context feature vector; The expected satisfaction and uncertainty of each chart type are calculated by a variational sparse Gaussian process posterior, which uses a radial basis kernel function and represents the posterior with induced points, which are learned offline from historical interaction data by maximizing the variational lower bound. According to the upper confidence bound strategy, the sum of the expected satisfaction and the uncertainty value after weighting by the exploration and utilization of the trade-off parameter is used as the upper confidence bound score of each chart type. The chart type with the highest upper confidence bound score is selected as the adaptive chart selection result, and the inverse of the uncertainty is output as the chart selection confidence level to the metadata field of the recruitment domain structured component calling protocol. The exploration and utilization of the trade-off parameter decreases inversely proportional to the square root of the number of interactions as the number of interactions increases. Based on the chart satisfaction signal in user interaction feedback, the posterior of the variational sparse Gaussian process and the induction point are updated asynchronously to form a learning loop for chart selection.

5. The method of claim 1, wherein, The process involves parsing the structured component calling protocol for the recruitment domain, loading components on demand from a recruitment-specific front-end component library, injecting recruitment data query results, and rendering interactive rendering components, including: The component type field, data mapping field, layout field, and event field of the structured component calling protocol in the recruitment field are parsed to obtain component loading instructions, data query instructions, layout configuration, and event binding instructions. Based on the component loading instruction, the corresponding component definition is loaded on demand from the recruitment-specific front-end component library; based on the data query instruction, recruitment data is queried and the query result is injected into the component property to obtain the component instance after data injection. Based on the layout configuration, the component instance is mounted to a specified position in the dialog flow, where the specified position includes a dialog bubble, a standalone panel, or a sidebar. Based on the event binding instruction, an event handling function is bound to the component instance to obtain an interactive rendering component.

6. The method of claim 1, wherein, After obtaining the candidate component type combinations and before assembling the recruitment domain structured component invocation protocol, a global rendering budget optimization allocation is performed on the candidate component type combinations, including: For each candidate component in the candidate component type combination, an inference utility function is constructed. The inference utility function increases with the amount of rendering resources allocated to the candidate component and decreases to saturation at the marginal utility level. The utility cap of the inference utility function is weighted by the inherent informational significance of the candidate component for the current recruitment decision. A global constraint optimization problem is constructed with the total amount of rendering resources that the current dialog interface can support as a constraint and the goal of maximizing the sum of the inference utilities of all candidate components. The global constraint optimization problem is solved, and the global shadow price is output so that the marginal utilities of each candidate component that receives positive rendering resource allocation are equal. Allocate zero rendering resources to candidate components whose marginal utility is always lower than the global shadow price to perform rational abstention, and reallocate the rendering resources released by the abstaining candidate components to candidate components whose inference utility is about to enter a rapid increase phase, to obtain the globally optimal rendering budget allocation scheme. The subset of candidate components with positive rendering resource amounts in the globally optimal rendering budget allocation scheme is used as the basis for assembling the structured component calling protocol in the recruitment field.

7. The method of claim 6, wherein, The step of constructing an inference utility function for each candidate component in the candidate component type combination includes: The amount of rendering resources allocated to the candidate component is measured as the number of rendering tokens weighted by the component complexity; The inherent information saliency is determined as the support score of the component type of the candidate component for the current recruitment decision; The inference utility function is constructed as follows: in the initial stage when the amount of rendering resources is lower than the information emergence threshold, the inference utility increases as the amount of rendering resources increases; after the amount of rendering resources exceeds the information emergence threshold, the marginal increment of the inference utility tends to saturate. The step of reallocating the rendering resources released by the abstaining candidate components to candidate components whose inference utility is about to enter a rapid increase phase includes: allocating the rendering resources released by the abstaining candidate components to candidate components whose inference utility is about to exceed the information emergence threshold, based on the principle of prioritizing those closer to the information emergence threshold.

8. The method of claim 1, wherein, After the agent decision engine regenerates the updated recruitment domain structured component invocation protocol and before the interactive rendering component is incrementally updated, answerability gating is performed, including: The agent decision engine maintains the Bayesian posterior distribution of recruitment intention type and optimal component type. The posterior approximation of the Bayesian posterior distribution is calculated by variational inference. The normalized complement of the posterior entropy of the posterior approximation with respect to the optimal component type relative to the maximum possible entropy is used as the answerability gating index. When the answerability gating index is not less than the preset gating threshold, the current evidence is deemed sufficient, and the updated recruitment domain structured component calling protocol is used for the incremental update. When the answerability gating index is less than the preset gating threshold, it is determined that the current evidence is insufficient, and active information acquisition is initiated: from the candidate information source set including user clarification requests, recruitment data supplementation and context history backtracking, the information source with the largest ratio of expected answerability improvement to acquisition cost is selected as the target information source. Information acquisition is performed based on the target information source, and the acquired information is sent back to update the Bayesian posterior distribution. After narrowing the posterior entropy, the next round of answerability gating is triggered.

9. The method of claim 8, wherein, The process of acquiring information based on the target information source includes: When the target information source is a user clarification request, a component invocation protocol of the component type of clarification card is generated. The data mapping field of the clarification card contains a candidate array. The candidate array contains a preset number of candidate component types with the highest posterior probability, chart type, preview description and data summary. The event field of the clarification card defines the clarification selection event. The clarification card component is rendered and the Bayesian posterior distribution is updated based on the user's selection event on the clarification card component. When the target information source is a supplementary recruitment data query, the intelligent agent decision engine performs additional recruitment data queries to update the Bayesian posterior distribution with the updated recruitment context state. When the target information source is context history backtracking, the dialogue history is loaded to supplement the recruitment context state, and the Bayesian posterior distribution is updated. The user clarification request, the recruitment data supplementation and the context history backtracking are respectively configured with acquisition costs that decrease sequentially.

10. The method of claim 1, wherein, The method further includes: Based on user instructions, the recruitment process is broken down into multiple task steps according to the recruitment funnel stages. Each task step corresponds to a stage of the recruitment funnel. A task list component calling protocol is generated, which includes task identifier, task name, task status, responsible person, deadline, and inter-task dependencies. The task list component is then rendered. Based on the user's operation events on the task list component, the operation events are sent back to the intelligent agent decision engine, which updates the task status of the corresponding task step to the completed state, and advances the task status of subsequent task steps to the in progress state according to the inter-task dependencies, generating an updated task list component calling protocol. Based on the updated task list component call protocol, the task list component is incrementally updated to obtain an automatically advanced task list component.

11. The method of claim 1, wherein, The method further includes: Based on the recruitment bottlenecks identified by the intelligent agent decision engine during the recruitment process, a recruitment suggestion component invocation protocol is generated, which is an executable suggestion component. The recruitment suggestion component invocation protocol includes suggestion text, suggestion reason and executable action buttons. The executable action buttons include an adopt button, a modified adopt button and an ignore button. The recruitment suggestion component is then rendered. Based on the user's adoption of the recruitment suggestion component, the adoption event is sent back to the intelligent agent decision engine, which updates the recruitment parameters, re-executes the recruitment data query based on the updated recruitment parameters, and generates updated component calling protocols for the statistical card component and resume list component. Incremental rendering is performed based on the component calling protocol of the updated statistics card component and resume list component to obtain the refreshed statistics card component and resume list component.