Intelligent agent scheduling and distribution system based on user interaction scene

Abstract

The invention discloses an agent scheduling and distribution system based on a user interaction scene, provides a page-level agent scheduling system for the first time, and breaks through the technical bottleneck that a traditional general AI model cannot adapt to a fine-grained scene. The method comprises the following steps: a function identification module, which is used for identifying a website or an application function module where a user is currently located; the page analysis module is used for analyzing the content structure of the current page and the user interaction context in the function identification module to obtain page features; the agent scheduling module is used for selecting and binding a corresponding agent from an agent resource pool according to the page features; and the life cycle management module is used for controlling the state storage, freezing or releasing of the intelligent agent when the page is loaded, switched or exited. The technical problems that although multi-agent cooperation is involved in the prior art, but most of the multi-agent cooperation is limited to back-end task scheduling, and dynamic mapping based on page granularity is not achieved are solved.

Description

TECHNICAL FIELD

[0001] The present application relates to the field of artificial intelligence and human-computer interaction, in particular to an agent scheduling and allocation system based on user interaction scenarios. BACKGROUND

[0002] The intelligent services in most current websites or Apps adopt the mode of "a single agent coping with the whole", that is, no matter what page the user is in or what operation the user is performing, only one general AI module provides services. This mode lacks scene adaptation ability and is difficult to apply to different situations, resulting in response redundancy, resource waste and fragmented user experience.

[0003] With the development of multi-agent architecture, personalized intelligent services have gradually emerged, but existing systems are mostly focused on backend scheduling or single-scene agents, and still lack complete mapping and scheduling mechanisms on the "function-page-task" chain, so they cannot achieve fine and dynamic agent configuration.

[0004] Although the existing technology involves multi-agent cooperation, it is mostly limited to backend task scheduling and has not yet realized dynamic mapping based on page granularity.

[0005] In view of the above problems, no effective solution has been proposed so far. SUMMARY

[0006] The embodiments of the present application provide an agent scheduling and allocation system based on user interaction scenarios to at least solve the technical problem that the existing technology involves multi-agent cooperation but is mostly limited to backend task scheduling and has not yet realized dynamic mapping based on page granularity.

[0007] The agent scheduling and allocation system based on user interaction scenarios provided by the present application mainly includes three aspects: user perception and page analysis mechanism, agent scheduling and state control mechanism, and personalized service and system deployment and expansion mechanism.

[0008] The main function of the user perception and page parsing mechanism is to identify user behavior intention and page module structure, which is used to lay the foundation for subsequent agent scheduling, and includes the following aspects: the agent scheduling and distribution system based on user interaction scenarios includes: a function identification module for identifying the website or application function module currently used by the user; a page parsing module for parsing the content structure and user interaction context of the current page in the function identification module to obtain page features; an agent scheduling module for selecting and binding corresponding agents from an agent resource pool according to the page features; and a life cycle management module for controlling the state saving, freezing or releasing of the agent when the page is loaded, switched or exited. The page parsing module includes a page structure analyzer and a behavior pattern analyzer. Each page is configured with an independent agent mounting area, and the instance of the agent is dynamically loaded and bound to the area.

[0009] The main function of the agent scheduling and state control mechanism is to dynamically allocate, schedule and manage the running life cycle of the agent, which includes the following aspects: the agent supports multi-page collaboration, including task division, data sharing and state migration; the life cycle management module further includes a page state listener and an agent state manager for sensing page in and / or out events and executing agent state processing; the function identification module determines the function scene intention according to the function identification module label or user path to guide the selection of the agent's ability set; the system is embedded in a website or mobile application to realize one-to-one mapping and scheduling between pages and agents in a modular way.

[0010] The main function of the personalized service and system deployment expansion mechanism is to provide personalized configuration, cross-device deployment, security authorization, resource pool and other expansion capabilities. It includes the following aspects: the system further includes an agent pool management module for dynamically expanding or shrinking the agent resource pool according to system load to realize flexible resource allocation and optimization; during the state saving or migration of the agent, the system encrypts or isolates user data to protect data security and privacy; the agent scheduling module supports priority allocation based on user personalized configuration to realize differentiated service scheduling; the agent scheduling module interfaces with the target system in the form of a plug-in to support on-demand loading and hot plug deployment; the system can be implemented in a local or cloud environment to adapt to different deployment requirements and operating environments.

[0011] Through the above structure, the technical problem that the existing technology involves multi-agent collaboration but is limited to back-end task scheduling and has not realized dynamic mapping based on page granularity is solved. BRIEF DESCRIPTION OF DRAWINGS

[0012] The accompanying drawings, which are included to provide a further understanding of the application and are incorporated in and constitute a part of this application, illustrate embodiments of the application and together with the description serve to explain the application. In the drawings:

[0013] Figure 1 is a structural schematic diagram of an intelligent agent scheduling and allocation system based on a user interaction scenario according to an embodiment of the application;

[0014] Figure 2 is another structural schematic diagram of an intelligent agent scheduling and allocation system based on a user interaction scenario according to an embodiment of the application;

[0015] Figure 3 is a functional module-to-page mapping relationship diagram according to an embodiment of the application;

[0016] Figure 4 is an optional page life cycle state diagram according to an embodiment of the application;

[0017] Figure 5 is an optional multi-agent cooperation logic diagram according to an embodiment of the application;

[0018] Figure 6 is an optional scheduling strategy flowchart according to an embodiment of the application;

[0019] Figure 7 is an optional deployment and security expansion diagram according to an embodiment of the application;

[0020] Figure 8 is a flowchart of an intelligent agent scheduling and allocation method based on a user interaction scenario according to an embodiment of the application;

[0021] Figure 9 shows a structural schematic diagram of a computer device suitable for implementing embodiments of the present disclosure. DETAILED DESCRIPTION

[0022] In order to enable persons skilled in the art to better understand the present application, the technical solutions in the embodiments of the present application will be described clearly and completely below with reference to the drawings in the embodiments of the present application. Obviously, the described embodiments are only a part of the embodiments of the present application, rather than all the embodiments of the present application. Based on the embodiments in the present application, all other embodiments obtained by persons skilled in the art without creative work should fall within the protection scope of the present application.

[0023] It should be noted that the terms "first", "second", and the like in the description and claims of the application and above drawings are used to distinguish similar objects, and do not necessarily indicate a specific order or sequence. It should be understood that the data used in this way can be interchanged under appropriate circumstances, so that the embodiments of the application described herein can be implemented in an order other than those illustrated or described herein. In addition, the terms "include" and "have" and any variations thereof are intended to cover non-exclusive inclusion, for example, a process, method, system, product or device including a series of steps or units does not necessarily limit to those steps or units clearly listed, but can include other steps or units not clearly listed or inherent to these processes, methods, products or devices.

[0024] In order to facilitate the understanding of the content of the application, the following terms related to the application are first explained:

[0025] Agent refers to a computing entity with certain autonomy, which can perceive the environment, execute tasks and make decisions, and can complete specific tasks or interact with users autonomously according to external input or preset rules.

[0026] Lifecycle Management refers to the systematic management of the whole process of the agent from creation, deployment, operation, update to retirement, in order to ensure efficient use of resources and smooth execution of tasks.

[0027] SmartPage refers to a visual operation interface for displaying and managing the scheduling and allocation of agents, providing functions such as task allocation, state monitoring and priority adjustment.

[0028] Resource Pool refers to a collection of agent resources that can be centrally managed for scheduling, which can dynamically allocate, expand and recycle agent resources to improve resource utilization efficiency.

[0029] Mount Point refers to a location in a system or platform for connecting, accessing or binding specific resources, modules or data. Through the mount point, resources can be identified, managed and called to achieve interaction and integration with other system components.

[0030] The application proposes a complete interactive chain system architecture with a function module as a source, a page as a scheduling unit, and an intelligent agent as an execution node, referred to as a SmartPage system. The core is as follows: dynamically identifying the page where the user accesses the function module; the system perceives the page content structure and context state; scheduling the intelligent agent instance with corresponding capabilities from the intelligent agent resource pool to bind to the page; recycling and migrating the intelligent agent state when the page is closed or switched, to realize closed-loop management. The system has the following key advantages: on-demand loading and precise allocation, improving operation efficiency; page-level task mapping, strengthening scene association; intelligent agent life cycle control, realizing behavior continuity and controllability; multi-page intelligent agent collaboration, supporting cross-page task scheduling.

[0031] Figure 1 The application proposes a complete interactive chain system architecture with a function module as a source, a page as a scheduling unit, and an intelligent agent as an execution node, referred to as a SmartPage system. The core is as follows: dynamically identifying the page where the user accesses the function module; the system perceives the page content structure and context state; scheduling the intelligent agent instance with corresponding capabilities from the intelligent agent resource pool to bind to the page; recycling and migrating the intelligent agent state when the page is closed or switched, to realize closed-loop management. The system has the following key advantages: on-demand loading and precise allocation, improving operation efficiency; page-level task mapping, strengthening scene association; intelligent agent life cycle control, realizing behavior continuity and controllability; multi-page intelligent agent collaboration, supporting cross-page task scheduling. Figure 1

[0032] The function identification module 12 is used to identify the website or application function module where the user is currently located. The function identification module 12 judges the function scene intention according to the function identification module label or user path, to guide the screening of the intelligent agent's capability set.

[0033] The page analysis module 14 is used to analyze the content structure and user interaction context of the current page in the function identification module 12, to obtain page features; the page analysis module 14 includes a page structure analyzer and a behavior pattern analyzer. Each page is configured with an independent intelligent agent mounting area, and the instance of the intelligent agent is bound to the area through dynamic loading.

[0034] The intelligent agent scheduling module 16 is used to select and bind the corresponding intelligent agent from the intelligent agent resource pool according to the page features; the intelligent agent supports multi-page collaboration, including task division, data sharing, and state migration. The instance of each intelligent agent has an identity ID, a skill list, and a task record table, to support fine scheduling and personalized response. The intelligent agent scheduling module 16 supports priority allocation based on user personalized configuration, to realize differentiated service scheduling.

[0035] ​Specifically, the agent scheduling module 16 is linked to the state-aware model through a preset strategy rule engine. The system evaluates the current context state in real time at each page load or user behavior trigger, including page type, interaction intent, device performance, and historical behavior records, to form a context semantic vector. This vector is input into the multi-agent scheduling engine, which dynamically selects the optimal or suboptimal matching agent by matching task tags (Task Tag), capability tags (Capability Tag), and context semantic weight distribution, and mounts it to the current page mount point (Mount Point).

[0036] The scheduling process supports asynchronous concurrency and master-slave agent structure, and cooperates with the life cycle management mechanism to implement the complete process of "wakeup -> initialization -> service -> freeze / destruction" for each agent instance. The system also has a behavior prediction function, which predicts the user's potential intent before they complete the operation, realizes preheating scheduling, rapid response, and low delay feedback, thereby guaranteeing intelligent collaboration effect in multiple scenarios and multiple devices.

[0037] The life cycle management module 18 is used to control the state saving, freezing, or release of the agent when the page is loaded, switched, or exited. The life cycle management module 18 further includes a page state listener and an agent state manager, which are respectively used to perceive page in and / or out events and execute agent state processing.

[0038] In some embodiments, the system can also include an agent pool management module for dynamically expanding or shrinking the agent resource pool according to system load, to realize flexible resource allocation and optimization.

[0039] The system provided by the present embodiment can be embedded in a website or mobile application to realize one-to-one mapping and scheduling between pages and agents in a modular manner. In addition, the system can also be implemented in a local or cloud environment to adapt to different deployment requirements and running environments.

[0040] Next, the architecture and logical structure of the present system will be described.

[0041] First stake: functional level entry node.

[0042] Define functional modules, such as learning module, shopping module, customer service module. Each functional module contains multiple accessible pages. The page scheduling logic dispatches task attribute tags based on this as an anchor point.

[0043] Second stake: page level scheduling node.

[0044] The page serves as the smallest unit for scheduling, and the system analyzes its structure, elements, and behavior records in real time. Intelligent agent attachment points are registered within the page (e.g., voice assistant area, side recommendation bar, floating Q&A box). Intelligent agents are scheduled and bound when entering a page, and frozen or reclaimed when exiting.

[0045] The third node: the agent execution node.

[0046] Each agent possesses a unique identity (ID), skill set (capability definition), and state storage module. It features lifecycle management (activation—execution—suspend—reclaim). Multi-agent collaboration is supported (e.g., data sharing, task delegation).

[0047] The process of this system will be described below.

[0048] User access function module → The system tags the current intent (e.g., "learning", "shopping"); Page loading → The page parser perceives the structure and content and submits a scheduling request; Agent scheduling manager → Matches and schedules suitable agents based on the tags and completes the binding; Agent operation phase → Receives user input, provides feedback, calls service APIs, etc.; Page exit event trigger → Triggers the state saving or Agent recycling mechanism; Subsequent pages → The state of the agent on the previous page can be reused to achieve a continuous service experience.

[0049] This system can be applied in the following scenarios: 1) Online education platforms. Each chapter page automatically matches a knowledge-explaining AI, supporting voice Q&A and key point annotation; 2) E-commerce platforms. Product detail pages are assigned a price comparison assistant, and search pages are assigned a trend analyst; 3) Social media platforms. Post browsing pages are linked to a sentiment analyzer, and posting pages are linked to a content optimization assistant; 4) Medical platforms. Consultation pages are linked to health Q&A AI, and examination pages are linked to report interpretation AI; 5) Financial and government affairs platforms. Risk control and review pages are assigned to a compliance AI, and government service acceptance pages are assigned to a business interpretation AI.

[0050] This system offers the following advantages: 1) Complete mapping loop: Function → Page → Agent → Task → Page exit → State recycling. 2) High modularity: Can be embedded into any App or Web system without affecting the existing architecture. 3) Efficient resource utilization: Avoids resource waste caused by persistent global agents. 4) Natural and smooth experience: One-to-one correspondence between agents and page behaviors, resulting in a more immersive interaction. 5) Strong scalability: Supports personalized configurations and different deployment environments, adapting to future evolution.

[0051] Figure 2 This is another intelligent agent scheduling and allocation system based on user interaction scenarios according to embodiments of the present invention, which is Figure 1 Functional expansion diagram, such as Figure 2As shown, the system includes: Global Entry Agent, Functionality, Pages, Page-bound Agents, Orchestration / Management, and Lifecycle Management.

[0052] User input is the starting point for system input, indicating that the user initiates an interactive operation through an App / Web page or API. It is used to guide the system to activate the global entry intelligent agent and convey intent and context information.

[0053] The global entry intelligent agent serves as the system's reception control center, used to initially identify user behavioral intent. The global entry intelligent agent initiates the scene recognition process, activates the corresponding functional modules and page mounting logic, and acts as the "first responder" for user interaction.

[0054] Functional modules are collections of business functions in the system, such as Learning, Shopping, and Customer Service modules. They are used to dispatch pages according to the instructions of the global entry intelligent agent, and at the same time send task requests (control chains) to the orchestration and control module.

[0055] The page layer consists of specific interactive pages within a functional module and is the smallest unit for attaching intelligent agents. Examples include HomePage, Product Detail Page, and Feedback Page. These are used to trigger intelligent agent attachment when the page loads. Each page can independently bind multiple intelligent agents of different types.

[0056] Page agents are dedicated agents bound to specific pages, each configured for page-specific tasks. For example, HomePage → Recommendation Agent; Course Page → Tutor Agent; Product Detail Page → Price Comparison Agent. Page agents handle tasks such as user intent, data requests, and content generation on the page.

[0057] The orchestration and management module is the central control module responsible for task coordination, scheduling, and lifecycle control. It consists of the following components: Agent Dispatcher, which schedules appropriate Agent instances based on the page and task context; Control Logic, which defines execution paths, constraints, and priorities; and Lifecycle Management, which manages the entire lifecycle of Agents, including activation, suspension, and recycling.

[0058] Lifecycle management is used to control the state of agents, ensuring resource release and state preservation. The main functions of lifecycle management are: freezing or saving the state after a page is switched out; restoring the agent context when the page is re-entered; and reclaiming and isolating the agent in abnormal situations.

[0059] This system adopts a multi-layered decoupled architecture with clearly defined responsibilities. A vertical closed loop is formed between the user entry point, page layer, agent scheduling layer, and lifecycle management layer; page agents can be flexibly replaced according to different scenarios, achieving "application based on materials"; this system has strong scalability, supporting horizontal expansion of functional modules and elastic scheduling of the agent pool.

[0060] The following describes the functional module → page mapping relationship. The structural mapping relationship between functional modules and specific pages in the SmartPage system is as follows: Figure 3 As shown, it embodies the basic logic of page scheduling and intelligent agent configuration in different business scenarios.

[0061] In this context, a function module refers to a first-level functional unit in the system, divided according to business logic, such as an "e-commerce module," a "learning module," or a "customer service module." Each function module contains multiple specific page entry points, serving as the carrier for user tasks and the execution platform for intelligent agents.

[0062] Figure 3The "E-Commerce Module" will be used as an example for explanation. The Pages layer represents the user interface within the app or website, and is the smallest unit for the system's intelligent agents. The Pages layer lies below the functional modules and directly corresponds to specific tasks and scenarios. Example pages include: Home Page: The system entry point, handling basic tasks such as recommendations and searches; Product Detail Page: Displays product information and specifications, supporting intelligent price comparison and recommendations; Cart Page: Manages selected products and associates with price optimization or compliance agents; Checkout Page: Handles payment, invoices, address verification, and other functions, with agents supporting process guidance and information confirmation.

[0063] The mapping relationship will be described below. There is a one-to-many mapping between functional modules and pages, meaning: one functional module can contain multiple pages; the number and type of pages are flexibly defined based on business complexity and system requirements; there can be jump relationships between pages, but... Figure 3 This will not be elaborated upon further, but will only emphasize the structural layering between modules and pages; subsequent agent scheduling logic will all rely on this mapping structure as the input basis.

[0064] The system provided in this application is designed to logically decouple "functions" and "pages" and to structurally layer them; this provides a scheduling basis for subsequent functions such as "page binding to intelligent agents", "page state management", and "task scheduling and execution".

[0065] Figure 3 yes Figure 2 The system architecture diagram details the structure of the middle layer, namely the page layer, to support the implementation path descriptions of the "function identification module" and the "page parsing module".

[0066] Figure 4 This demonstrates the complete lifecycle management process of a page under user interaction and system control within the SmartPage system. Figure 4 The CCP contains five main state nodes. The system uses a scheduling module and a lifecycle management module to dynamically control and manage the resources of the page and its bound intelligent agents.

[0067] The state nodes will be explained in detail below.

[0068] 1. Mounted

[0069] The page is recognized and loaded by the system, and the agent's mounting point is initialized; this indicates that the page is ready and awaits subsequent activation; it is usually triggered when the user first enters the page.

[0070] 2. Activate

[0071] The intelligent agent on the page is scheduled and activated, entering the task execution phase; the user can interact normally during this phase, and the system processes the instructions in real time; activation may be triggered automatically by user operation or system policy.

[0072] 3. Suspended

[0073] When a user switches pages, minimizes an application, or when system resources are scarce, the page enters a suspended state. After suspension, the page and the agent are temporarily frozen, but the state information is retained. This helps save computing resources and improve the overall operating efficiency of the system.

[0074] 4. Reactivated

[0075] When a user re-enters a suspended page, the system restores it to an active state; it retains previous context information to ensure a continuous experience; and it avoids repeated initialization, thus shortening response time.

[0076] 5. Released

[0077] When a page is completely closed or its lifecycle ends, the system releases its resources; the corresponding agent is also destroyed or put into a cold standby state; this avoids resource leakage or unnecessary occupation and keeps the system running lightweight.

[0078] The lifecycle flow path is described below. The main flow of the page lifecycle is: Mount → Activate → Suspend → Resume → Activate → Release. All states are converted to unidirectional control and are uniformly managed by the system scheduling module and the lifecycle management module; changes in the state of each page do not affect other pages, supporting parallel operation of multiple pages; the activation and suspension behaviors of the agent are synchronized with the page state.

[0079] Figure 4 Supporting the "Lifecycle Management Module," this feature demonstrates the completeness, intelligence, and resource-saving capabilities of the SmartPage system in controlling the interaction between pages and intelligent agents; it also shows how the system maintains task continuity and resource scheduling flexibility in high-concurrency, multi-page scenarios.

[0080] Figure 5 This is a logic diagram for multi-agent collaboration. Figure 5 This demonstrates the logical relationships between different agents bound to multiple pages in the SmartPage system, collaborating in the system background. From... Figure 5 It is clear that although each page's bound agent performs its own function, the system supports cross-page agent collaborative processing during task execution and context passing.

[0081] The following describes the binding relationship between pages and agents. Each page is attached to one or more agents whose functions match its own, forming a one-to-one or one-to-many binding structure; for example, Product Detail Page → bound to Price Analysis Agent; Recommendation Page → bound to Recommendation Agent; Q&A Page → bound to Q&A Response Agent; the page itself does not directly collaborate, all collaboration is carried out through the agents it is attached to.

[0082] The following describes the collaboration path between agents. Agents interact with each other and coordinate tasks through the system's internal task bus, context sharing pool, or policy module; Figure 5 The dashed arrows used in the diagram represent collaborative relationships, indicating that these data flows / control flows exist at the logical level and are not visible to the user.

[0083] Example collaboration path: The recommendation agent can call the price analysis agent to obtain price sensitivity information to assist in result ranking; the Q&A agent can refer to the content provided by the recommendation agent as candidate answer context; the collaboration mechanism supports asynchronous calls and result backfilling, and has good concurrency and scalability.

[0084] The system support mechanism is explained below. The collaborative behavior of all agents is controlled by the system's internal scheduling module; agents are not bound to each other or directly referenced, but rather their collaboration is decoupled through "capability registration + scheduling triggering".

[0085] This system supports the following key capabilities: context sharing: multiple agents can access the same user session or task context; event triggering: after one agent completes its processing, it can trigger other agents to execute tasks; collaborative caching: intermediate results can be stored and shared with multiple downstream agents to reduce redundant processing. Furthermore, the context pool in this application supports three sharing formats: state snapshots, session contexts, and structured data objects.

[0086] Figure 5 This demonstrates the core capabilities of the SmartPage system in achieving "collaborative division of labor and asynchronous linkage" at the agent level; and... Figure 2 (System architecture diagram) and Figure 3 (Page mapping diagram) forms a coherent structure, fully supporting the design loop of "from page to agent, and then to agent collaboration"; it provides intuitive support for the technical solutions of "agent collaboration module" and "task decomposition and composite capability invocation".

[0087] Figure 6 This is a flowchart of the scheduling strategy. Figure 6 This demonstrates the entire workflow in the SmartPage system, from receiving a task request to completing scheduling and execution. This workflow is led by the system's scheduling strategy module, combining context awareness and task recognition capabilities to achieve efficient and intelligent task execution.

[0088] The steps of each process are described below.

[0089] Step S602, Identify Task.

[0090] First, the system is started. Upon receiving an external trigger event, such as a page loading, user interaction, or a scheduled task, the system initiates the task scheduling process.

[0091] Next, the scheduling module analyzes the current task intent based on context information, user behavior, and page type; and identifies the task type, such as recommendation generation, price comparison analysis, and question-and-answer response.

[0092] Step S604, Match Agent.

[0093] The system searches for candidate agents with relevant capabilities from the intelligent agent resource pool; the matching logic considers factors such as capability tags, context adaptability, usage frequency, and cold start overhead.

[0094] The following code example demonstrates how the system matches the current user's context vector with the registered agent's capability vector to achieve the core process of semantic scheduling and page mounting. This logic is adaptable to the agent model registration structure and input / output interfaces of different platforms, exhibiting strong scalability and feasibility.

[0095] class SmartAgentDispatcher:

[0096] def __init__(self, context_vector, available_agents):

[0097] self.context = context_vector # Generated from user behavior and page structure

[0098] self.agents = available_agents

[0099] def match_agent(self):

[0100] matched = []

[0101] For the agent in self.agents:

[0102] score = self.calculate_match_score(agent)

[0103] if score > 0.75: # Set matching threshold

[0104] matched.append((agent, score))

[0105] matched.sort(key=lambda x: x[1], reverse=True)

[0106] return matched[:1] # Returns the best matching agent

[0107] def calculate_match_score(self, agent):

[0108] return dot_product(agent.capability_vector, self.context)

[0109] # Example usage

[0110] user_context = get_context_vector(user_behavior, current_page)

[0111] agents_pool = load_agents_from_registry()

[0112] dispatcher = SmartAgentDispatcher(user_context, agents_pool)

[0113] selected_agent = dispatcher.match_agent()[0]

[0114] mount(selected_agent, current_mount_point)

[0115] Step S606, Check Policy (policy judgment).

[0116] The system employs multi-dimensional policy judgments based on factors such as execution permissions, priority, resource utilization, and user profiles to determine whether execution is permitted, whether a delay is necessary, or whether queuing or degrading is required.

[0117] Step S608, Dispatch Agent.

[0118] Once a match is found, the system will distribute the task to the corresponding Agent; the Agent will then become active and begin processing the task request.

[0119] Step S610, Task Executed (Task completed).

[0120] After the agent completes the task, it returns the result. The system records the task status, updates the context, or triggers subsequent tasks. The task scheduling process is now complete. The system releases resources or waits for the next task to start.

[0121] The entire process of this application follows the core scheduling concept of "task-driven → intelligent dispatch → policy control → effective execution" in the SmartPage system; it supports multi-task concurrent scheduling, agent reuse, and dynamic policy configuration; and it provides support for the "scheduling policy module", "Agent selection mechanism", and "context recognition process".

[0122] Figure 7 This diagram illustrates the deployment and security expansion. Figure 7 The overall structure of the SmartPage system at the level of actual deployment and security strategy is shown, demonstrating its key capabilities in intelligent agent resource expansion, lifecycle management, security protection mechanisms, and adaptation to multiple deployment scenarios.

[0123] The modules and processes will be described below.

[0124] Agent Pool: All available agents in the system are managed in a unified manner as a resource pool; it supports dynamic expansion or contraction based on the current system load and task requirements; resources in the agent pool can be scheduled, suspended, released or reallocated by the lifecycle management module; this capability supports the system's "elastic scalability" and "intelligent task adaptation".

[0125] Lifecycle Management Module: The central control component of the system, responsible for sensing task status and resource requirements; it can decide whether to activate, freeze, or terminate a certain agent based on task type, page status, and user context; it works in conjunction with the security module and scheduling logic to ensure the security and consistency of agent calls; it is a key control point for system resource conservation and scheduling closed loop.

[0126] Security Module: Used for authentication and encryption. All agent scheduling behaviors and deployment operations must pass through the authentication mechanism. User data, model calls, API communications, etc. are all encrypted end-to-end. The security module works in conjunction with lifecycle management to form a dynamic protection mechanism throughout the entire process.

[0127] Deployment Paths: The system supports two deployment modes to meet diverse business scenarios: 1) Cloud Deployment: Suitable for centralized data and high-performance scenarios; it can quickly schedule various intelligent agents in the resource pool; the security module ensures privacy and data integrity on the public cloud. 2) On-Premises Deployment: Suitable for enterprise environments with high requirements for security isolation or compliance; it supports intelligent agents running in local containers, ensuring that data does not leave the local machine; the system can perform synchronous updates and authentication verification to ensure functional consistency.

[0128] Terminal connectivity (Client App / Internal Server). All deployments ultimately connect to the terminal (such as mobile applications, enterprise internal servers, etc.); ensuring the delivery capability of intelligent services; interfaces support standardization, auditability, and secure access control.

[0129] This system has the following advantages: 1) Scalability: Through Agent Pool + lifecycle management module 18, the system can expand its capability units as needed, avoiding resource waste; 2) Security: Full-process authentication and encryption measures cover agent scheduling, data transmission and deployment execution; 3) Adaptability: Flexible switching between cloud and local deployment to meet different scenarios, regions and regulatory requirements; 4) System closed loop: From resource management, policy control, task distribution to secure access, it forms a complete system implementation path.

[0130] This system establishes a collaborative paradigm of "page as entry point and intelligent agent as assistant," providing a more refined, intelligent, and secure scheduling infrastructure for the next generation of human-computer interaction systems.

[0131] This application provides a method for intelligent agent scheduling and allocation based on user interaction scenarios. The method is as follows: Figure 8 As shown, it includes:

[0132] Step S802: Identify the task.

[0133] After a user accesses a functional module, the system receives an external trigger event, which can be a page load, a user click, an input operation, or a system scheduled task trigger. The system analyzes the user's behavior path, the type of page accessed, and the functional module identifier through the function identification module to generate a set of candidate tasks. Each candidate task is encapsulated as a task description object upon generation, containing the task type, priority, capability requirements, and state constraints. Simultaneously, the system encodes the task context, generating a context version number to mark the page's state version at the time the task is triggered.

[0134] During task recognition, the behavioral feature vector of the user's operation sequence is weighted and combined with the page element structure vector to generate a task context vector, providing basic data for subsequent agent matching. By encoding the timestamps, operation types, page element hierarchies, and relationships of the user's operation sequence, the task context vector can comprehensively reflect the user's intent and take into account the user's personalized preferences, providing data support for accurate task recognition.

[0135] Step S804: Select candidate agents from the agent resource pool.

[0136] After receiving the task description object, the system filters candidate agents from the agent resource pool. The matching logic includes consistency checks between capability tags and task requirements, as well as context adaptation based on the similarity between the task context vector and the agent's historical execution context vector, and evaluates the agent's cold start overhead and usage priority.

[0137] During the matching process, a context version number comparison mechanism is introduced to ensure that the state of the candidate agent is consistent with the page version at the time of task triggering, avoiding state inconsistencies. To improve matching accuracy, this application adopts a context-aware adaptation algorithm, which calculates the matching degree between the task context vector and the agent capability vector through cosine similarity, and dynamically selects the optimal agent instance by combining the weighted calculation of the most recent historical state transition records. In addition, based on the agent's historical execution load and the number of concurrent tasks, a load prediction model is used for comprehensive evaluation to ensure that the selected agent can meet the task requirements without causing performance bottlenecks.

[0138] Step S806: Determine the degree of matching between the agent's current state and the task context version.

[0139] The matched candidate agents are subject to policy evaluation. This evaluation considers agent execution permissions, task priority, system resource constraints, and user profile suitability. This embodiment uses state consistency scoring, which measures the degree of match between the agent's current state and the task context version, to ensure that in high-concurrency, multi-page switching scenarios, scheduling decisions prioritize the agent with the best state match, thereby guaranteeing the continuity and stability of task execution.

[0140] In addition to using current load, network latency, and task execution complexity for policy determination, a scheduling policy score can be automatically generated during policy determination. The scheduling policy score is combined with task priority to form the final dispatch decision weight. This ensures that high-priority tasks can still receive timely support from the agent when resources are scarce, while low-priority tasks can be delayed or degraded according to the policy.

[0141] Step S808: Dispatch the intelligent agent.

[0142] First, candidate agents are selected based on the policy judgment results. Simultaneously, it is checked whether the current state version number of each candidate agent matches the task context version number. If the agent's state version lags behind the task context version, the difference between the agent's state and the task context version is incrementally calculated, loading only the state difference between the two to achieve incremental recovery. This incremental state recovery mechanism is implemented through state snapshots and differential mapping; each state update only records the incremental data compared to the previous snapshot.

[0143] Then, using the predictive activation module, possible subsequent tasks or page transitions are predicted based on the current task context vector and the user's action behavior sequence, and the states of relevant agent modules, such as recommendation, question answering, or data analysis modules, are pre-loaded. The predictive activation module uses a multi-step time series prediction algorithm to weight the user's historical behavior patterns, page access frequency, and functional module jump probability to generate a distribution of future operation probabilities, and dynamically prepares the necessary resources in conjunction with agent capability tags.

[0144] In cross-page or cross-task scenarios, agent state migration can also be performed. Agent state migration uses incremental snapshots to migrate the agent's execution state from page A to the mount point on page B, while simultaneously updating the context version number and ensuring data consistency and task continuity during the migration process. The migration operation is broken down into three sub-processes: state snapshot migration, context remapping, and event registration. This ensures that the agent can be immediately activated and continue task execution on the target page after migration, without requiring a full re-initialization.

[0145] During the dispatch phase, agents also undergo dynamic binding and lifecycle event registration. After each agent is bound to a page mount point, it registers lifecycle listeners and state events, including page exit, suspension, resumption, and release events. When the page exits or is suspended, the agent's state snapshot is automatically frozen and saved; when the page resumes, the agent quickly resumes based on the latest version number, achieving context continuity; when the page is closed or the lifecycle ends, the agent is released or put into a cold standby state, achieving efficient resource management.

[0146] Step S810: The agent performs the task.

[0147] Activated agents receive user input and execute tasks, including recommendation generation, price comparison analysis, question-and-answer response, content optimization, and data analysis. During task execution, agents write intermediate results to a shared context pool, which can then be accessed by other agents on the same page or across pages, enabling multi-agent collaboration. Agents continuously update state snapshots and generate new version numbers. Through versioned state management, only incremental differences are saved for each state change, ensuring data consistency and task continuity during multi-agent collaboration.

[0148] Step S812, trigger page state.

[0149] When a user switches pages, minimizes, or closes a page, the page state event handling mechanism is triggered. The agent state management module determines the state handling method based on the event type: when a page is switched out or suspended, a snapshot of the agent state is frozen and a version number is recorded; when the page is resumed, the agent context is quickly restored using the version number; when the page is closed or its lifecycle ends, agent resources are released or the agent is put into a cold standby state. In cross-page switching scenarios, the state migration mechanism migrates the agent state from page A to the mount point of page B, achieving task continuity and agent collaboration.

[0150] After completing a task, the agent submits the result to the system, updates the task record table's completion status, and stores the result in a shared context pool for use by other agents or pages. The system determines the agent's next state based on its lifecycle policy, including suspending, freezing, or releasing. The entire process forms a complete closed-loop system from task identification, agent matching, policy judgment, agent dispatch, task execution, page state triggering to task closure, supporting concurrent scheduling of multiple tasks, state continuity, cross-page migration, and agent reuse. Through this method, the system can achieve efficient resource management, continuous interactive experience, and multi-agent collaboration.

[0151] Figure 9 A schematic diagram of a computer device suitable for implementing embodiments of the present disclosure is shown. It should be noted that... Figure 9 The computer device shown is merely an example and should not be construed as limiting the functionality and scope of use of the embodiments disclosed herein.

[0152] like Figure 9As shown, the computer device includes a central processing unit (CPU) 1001, which can perform various appropriate actions and processes according to a program stored in a read-only memory (ROM) 1002 or a program loaded from a storage section 1008 into a random access memory (RAM) 1003. The RAM 1003 also stores various programs and data required for system operation. The CPU 1001, ROM 1002, and RAM 1003 are interconnected via a bus 1004. An input / output (I / O) interface 1005 is also connected to the bus 1004.

[0153] The following components are connected to I / O interface 1005: an input section 1006 including a keyboard, mouse, etc.; an output section 1007 including a cathode ray tube (CRT), liquid crystal display (LCD), etc., and speakers, etc.; a storage section 1008 including a hard disk, etc.; and a communication section 1009 including a network interface card such as a LAN card, modem, etc. The communication section 1009 performs communication processing via a network such as the Internet. A drive 1010 is also connected to I / O interface 1005 as needed. A removable medium 1011, such as a disk, optical disk, magneto-optical disk, semiconductor memory, etc., is installed on drive 1010 as needed so that computer programs read from it can be installed into storage section 1008 as needed.

[0154] The above description is only a preferred embodiment of this application. It should be noted that for those skilled in the art, several improvements and modifications can be made without departing from the principle of this application, and these improvements and modifications should also be considered within the scope of protection of this application.

Claims

1. An intelligent agent scheduling and allocation system based on user interaction scenarios, characterized in that, include: The function identification module is used to identify the function module of the website or application that the user is currently in; The page parsing module is used to parse the content structure and user interaction context of the current page within the function recognition module to obtain page features; The agent scheduling module is used to select and bind the corresponding agent from the agent resource pool according to the page features; The lifecycle management module is used to control the state saving, freezing, or release of the agent when the page loads, switches, or exits.

2. The system according to claim 1, characterized in that, The page parsing module includes a page structure analyzer and a behavior pattern analyzer.

3. The system according to claim 1, characterized in that, Each page is configured with an independent smart agent mounting area, and instances of the smart agents are dynamically loaded and bound to this area.

4. The system according to claim 1, characterized in that, The intelligent agent supports multi-page collaboration, including task allocation, data sharing, and state transition.

5. The system according to claim 1, characterized in that, The lifecycle management module further includes a page state listener and an agent state manager, which are used to sense page entry and / or exit events and to perform agent state processing, respectively.

6. The system according to claim 1, characterized in that, The function recognition module determines the function scenario intent based on the function recognition module label or user path, which is used to guide the selection of the intelligent agent's capability set.

7. The system according to claim 1, characterized in that, The system is embedded in a website or mobile application to achieve one-to-one mapping and scheduling between pages and intelligent agents in a modular manner.

8. The system according to claim 1, characterized in that, Each instance of an intelligent agent has an identity ID, a skill list, and a task record table to support fine-grained scheduling and personalized responses.

9. The system according to claim 1, characterized in that, It further includes an intelligent agent pool management module, which is used to dynamically expand or shrink the intelligent agent resource pool according to the system load, so as to achieve flexible resource allocation and optimization.

10. The system according to claim 1, characterized in that, During the state saving or migration process of the intelligent agent, the system encrypts or isolates user data to ensure data security and privacy protection.

11. The system according to claim 1, characterized in that, The intelligent agent scheduling module supports priority allocation based on user-personalized configuration to achieve differentiated service scheduling; and / or the intelligent agent scheduling module interfaces with the target system in a plug-in manner, supporting on-demand loading and hot-swappable deployment.

12. The system according to claim 1, characterized in that, The system can be implemented in a local or cloud environment to adapt to different deployment needs and operating environments.

Images