Methods, devices and electronic equipment for multi-agent analysis and handling of security incidents
By establishing a state link and queue collaboration mechanism for multi-agent analysis and handling of security incidents, the problem of state association between events, tasks, commands, execution results, and model requests in existing technologies has been solved. This has enabled an efficient, reliable, and controllable multi-round decision-making process for handling security incidents, improving the system's processing capacity and the traceability and consistency of results.
Patent Information
- Application Number
- CN202611620842.6
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2026-10-20
- Publication Date
- 2026-11-17
AI Technical Summary
In existing automated security incident handling solutions, there is a lack of a unified state association mechanism between incidents, tasks, commands, execution results, execution summaries, and model requests. The dependencies and successor relationships between multiple expert tasks lack machine-side control. Model invocation and business state processing are highly coupled. Command execution results are difficult to automatically backfill to drive subsequent analysis. The round boundaries in multi-round incident handling are unclear, leading to mixed processing and increased risks.
By establishing state chains for event objects, task objects, command objects, execution objects, message objects, and large language model request objects, asynchronous collaboration is achieved using event processing queues, task processing queues, operation execution queues, and large language model request queues to form a closed-loop processing, ensuring state tracking and dependency management. Request type identifiers are used to distribute response results and generate structured execution summaries to drive subsequent decisions.
It improves the traceability of security incident handling links, the consistency of state in task-dependent processing, the decoupling of model response and business processing, the reusability of command execution results, the distinguishability of multi-round processing results, and the recovery capability of asynchronous processing links, thereby reducing the risk of cross-module result loss.
Smart Images

Figure CN123116294A_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the field of network security technology, and in particular to a method, apparatus, and electronic device for multi-agent analysis and handling of security incidents. Background Technology
[0002] Security operations centers typically receive security incidents from alerting platforms, logging systems, traffic analysis systems, endpoint detection systems, manual input, or external messaging systems. In response to these incidents, the system needs to perform multiple actions, including log retrieval, asset verification, attack payload analysis, scenario handling, manual verification, impact assessment, and conclusion summarization. These actions are often asynchronous processes comprised of multiple expert tasks and tool commands.
[0003] Existing automated security incident handling solutions typically focus on rule matching, knowledge reasoning, and the execution of handling opinions or scripts. For example, some solutions generate handling results around the security incident to be handled, the set of facts, the set of handling rules, and the inference engine, which can enhance rule-based handling capabilities, but do not fully address issues such as managing dependencies between dynamically generated tasks, feedback of responses from large language models, generation of command execution summaries, and triggering subsequent tasks after the summary is completed. SOAR-like systems can execute security operation actions through pre-defined scripts, but SOAR scripts mainly focus on predefined action nodes and orchestration logic. For expert tasks, commands, and multi-round judgment processes dynamically generated by large language models, they lack a data processing mechanism that unifies and associates events, tasks, commands, execution records, summary results, and model requests. General workflow engines can express task dependencies, but they are usually geared towards fixed processes or batch processing tasks, making them difficult to apply to security incident handling scenarios where tasks are dynamically generated and execution results are uncertain. General agent or retrieval-enhanced generation solutions can call models and tools, but they mainly save session states or directly execute tools, lacking a mechanism to save model requests as asynchronous request objects with role identifiers and feed them back to different processing queues based on role fields.
[0004] In summary, the existing technology has at least the following drawbacks: First, there is a lack of a unified state association mechanism among events, tasks, commands, execution results, execution summaries, and model requests; Second, the dependencies and succession relationships between multi-expert tasks lack machine-side control mechanisms, which poses a risk that subsequent tasks may be executed prematurely if the preceding tasks are not completed. Third, the model invocation and business status processing are highly coupled, making it difficult for the system to reliably redirect the response back to different business processors based on the role to which it belongs. Fourth, the command execution results are difficult to automatically backfill and drive subsequent analysis. The original execution results may be long and have inconsistent formats, making it difficult to directly reuse them for subsequent tasks or event-level decisions. Fifth, the boundaries between rounds in multi-round event processing are not clear. Without a distinction between event rounds and task rounds, the results and states of different rounds are easily mixed.
[0005] Therefore, there is an urgent need for a multi-agent security incident analysis and handling technology that can achieve unified state association and tracking of events, tasks, commands, executions and model requests, automatically control task dependencies, divert model responses according to request type, convert execution results into summary backfilling to drive subsequent decisions, and ensure clear and controllable multi-round handling through round differentiation. Summary of the Invention
[0006] In view of the above-mentioned defects or deficiencies in the prior art, the present invention provides a method, apparatus and electronic device for multi-agent analysis and handling of security events. It establishes a traceable state link through event objects, task objects, command objects, execution objects, message objects and large language model request objects, and realizes asynchronous collaboration through event processing queues, task processing queues, operation execution queues and large language model request queues, so that security events can form a closed loop between multi-expert tasks, command execution and event-level re-decision, thereby solving the technical problems mentioned in the background art.
[0007] One aspect of the present invention provides a multi-agent method for judging and handling security events, comprising: Obtain security event data and create event objects; If the event type of the event object is a preset type, then a task object is created and sent to the task processing queue; otherwise, the event object is sent to the event processing queue. The task object, from which all preceding dependent tasks have been completed, is retrieved from the task processing queue. The task execution agent constructs the task context and generates a large language model request object carrying a task-level request type identifier, and sends it to the large language model request queue. The event object is retrieved from the event processing queue. The event coordination agent constructs the event context and generates a large language model request object carrying an event-level request type identifier, and sends it to the large language model request queue. When the operation execution queue needs to generate an execution summary, the summary generation agent constructs the summary context and generates a large language model request object carrying a summary-level request type identifier, and sends it to the large language model request queue. After the large language model request queue has finished processing, the response result is distributed to the event processing queue, the task processing queue, or the operation execution queue according to the request type identifier. The event processing queue and the task processing queue parse the response results that are routed to this queue. If the parsed response type is a task creation instruction, a new task object is created and sent to the task processing queue; if the parsed response type is a command execution instruction, a command object is created and sent to the operation execution queue; if the parsed response type is a task completion instruction, the state of the current task object is updated; if the parsed response type is a follow-up instruction, the follow-up message is recorded in the interaction history of the current task object. After the operation execution queue executes the command object, it generates an execution summary of the execution result, and triggers the current task object or the current event object to be re-enqueued according to the completion status of the execution summary; After the current task object is completed, the subsequent task is triggered according to the subsequent task configuration of the current task object, or after all task objects in the current event round have been completed, the event coordination agent generates an event round scheduling instruction and sends it to the event processing queue. Repeat the above steps until the preset iteration termination condition is met.
[0008] Another aspect of the present invention provides a multi-agent judgment and handling device for security events, comprising: The event object creation module is used to obtain security event data and create event objects. The event routing module is used to create a task object and send it to the task processing queue if the event type of the event object is a preset type; otherwise, it sends the event object to the event processing queue. The task scheduling module is used to retrieve task objects from the task processing queue where all preceding dependent tasks have been completed, construct task contexts and generate large language model request objects carrying task-level request type identifiers by the task execution agent, and send them to the large language model request queue; retrieve event objects from the event processing queue, construct event contexts and generate large language model request objects carrying event-level request type identifiers by the event coordination agent, and send them to the large language model request queue; when the operation execution queue needs to generate an execution summary, the summary generation agent constructs a summary context and generates large language model request objects carrying summary-level request type identifiers, and sends them to the large language model request queue. The response routing module is used to route the response result to the event processing queue, the task processing queue, or the operation execution queue according to the request type identifier after the large language model request queue has been processed. The result parsing and execution module is used by the event processing queue and the task processing queue to parse the response results diverted to this queue. If the parsed response type is a task creation instruction, a new task object is created and sent to the task processing queue; if the parsed response type is a command execution instruction, a command object is created and sent to the operation execution queue; if the parsed response type is a task completion instruction, the status of the current task object is updated; if the parsed response type is a follow-up instruction, the follow-up message is recorded in the interaction history of the current task object. The execution feedback module is used to generate an execution summary of the execution result after the operation execution queue executes the command object, and trigger the current task object or the current event object to be re-enqueued according to the completion status of the execution summary; The round coordination module is used to trigger subsequent tasks according to the subsequent task configuration of the current task object after the current task object is completed, or to generate an event round scheduling instruction and send it to the event processing queue after all task objects in the current event round have been completed. The iterative execution module is used to repeatedly execute the above steps until the preset iteration termination condition is met.
[0009] In another aspect, the present invention provides an electronic device comprising: one or more processors; and a storage device for storing one or more computer programs; wherein, when the one or more computer programs are executed by the one or more processors, the one or more processors implement the above-described multi-agent judgment and handling method for security events.
[0010] The security incident multi-agent analysis and handling method, apparatus, and electronic device provided by this invention have the following beneficial effects: Firstly, it improves the traceability of the security incident handling chain. Event objects, task objects, command objects, execution objects, message objects, and large language model request objects are associated through their respective object identifiers, jointly recording the complete state change chain of an event from creation, task processing, model response, command execution, summary backfilling to re-decision.
[0011] Secondly, it improves the consistency of task dependency handling. Before executing a task, the system checks whether all preceding dependent tasks have been completed, and after the task is completed, it triggers subsequent tasks through subsequent task configuration, effectively reducing the risk of incorrectly executing subsequent tasks when dependencies are not satisfied.
[0012] Thirdly, it improves the decoupling between model response and business processing. By carrying a request type identifier in the large language model request object, the system enables the model response to flow back to the event processing queue, task processing queue, or operation execution queue based on the request type identifier. This avoids the problem that the model call result only stays at the dialogue text layer and cannot drive business processing.
[0013] Fourthly, it improves the reusability of command execution results. After processing, the command execution results generate a structured execution summary, which is written to the execution object and message stream, allowing it to be directly read and reused by subsequent task processing and event-level re-decision.
[0014] Effect 5: Improves the distinguishability of multi-round processing results. Event rounds are used to distinguish multiple rounds of decision-making for the same event, and task rounds are used to distinguish multiple rounds of command execution for the same task, effectively preventing the mixing of results, summaries, commands, and task statuses from different rounds.
[0015] Effect 6: Improves the recovery capability of asynchronous processing links. Only the object identifier is transmitted in the queue message; the actual state is based on the persistent state object in the database, enabling the system to continue processing based on the persistent state object when recovering from an anomaly or when messages are delivered repeatedly.
[0016] Effect 7: Reduces the risk of cross-module result loss. Command objects and execution objects record event identifiers, task identifiers, and task rounds. Execution summary messages associate events, tasks, commands, and execution objects, which is beneficial for subsequent auditing and problem localization. Attached Figure Description
[0017] Other features, objects, and advantages of this application will become more apparent from the following detailed description of non-limiting embodiments with reference to the accompanying drawings: Figure 1 This is a flowchart illustrating a multi-agent analysis and handling method for security events provided in one embodiment of this application; Figure 2 This is a flowchart of task processing, dependency verification, and LLM response reflow provided in one embodiment of this application; Figure 3 This is a flowchart of command execution, summary backfilling, and event re-decision provided in one embodiment of this application; Figure 4 This is a schematic diagram of the structure of a multi-agent analysis and handling of security events provided in one embodiment of this application; Figure 5 This is a schematic diagram of the structure of an electronic device provided in one embodiment of this application. Detailed Implementation
[0018] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.
[0019] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the key terms used in the present invention are first defined and explained.
[0020] Event object: A data structure used to represent a security event, including at least one of the following: event identifier, event type, event status, event round, priority, automation mode, stop flag, and event content. Event objects are the higher-level related objects of task objects, command objects, execution objects, message objects, and large language model request objects.
[0021] Task object: A data structure representing an expert task, generated by an event creation process, an event coordinating agent, or other task processing logic. A task object includes at least one of the following: task identifier, event identifier, event round, task round, agent identifier, task state, prerequisite tasks, successor tasks, task opinion, and task result. The prerequisite task field controls whether the task can enter the actual processing flow, and the successor task field controls the continued triggering after the task is completed.
[0022] Command object: A data structure used to represent an action to be executed generated by an event coordinating agent or task execution agent. A command object includes at least one of the following: command identifier, event identifier, task identifier, task round, command type, tool identifier, tool parameters, command target, command description, and command status.
[0023] Execution object: refers to the data structure used to represent command execution records. An execution object includes at least one of the following: execution identifier, command identifier, event identifier, task identifier, task round, execution result, execution summary, AI summary, and execution status.
[0024] Message objects are data structures used to record process data such as user messages, task assignment messages, large language model response messages, execution summary messages, system notification messages, and acknowledgment messages. Message objects enable traceability of the event processing chain and provide context for subsequent task processing and event-level re-decision.
[0025] Large Language Model Request Object: This refers to the data structure used to record a single large language model call request. The large language model request object includes at least one of the following: request identifier, request type identifier, system prompt word, user prompt word, event identifier, whether it is a long text request, response content, inference content, token usage information, execution time, and request status. After the large language model request object is processed successfully or fails, the system sends the response back to the corresponding processing queue based on the request type identifier.
[0026] Request type identifier: This refers to the identification information carried in the large language model request object, which identifies the type of the request and routes the response result to the corresponding processing queue accordingly. The request type identifier includes event-level type, task-level type, and summary-level type.
[0027] Agent identifier: This refers to the identifier information bound to a task object, which indicates the agent responsible for processing that task object. Different task objects can be bound to the same or different agent identifiers to achieve multi-agent collaborative processing.
[0028] Prerequisite tasks: These are other tasks recorded in the task object that need to be completed before the current task can be executed. The system checks whether all prerequisite tasks have been completed before allowing the current task to enter the actual processing flow.
[0029] Successor tasks: These refer to the follow-up tasks recorded in the task object that need to be triggered and executed after the current task is completed. After the current task is completed, the system automatically sends the successor tasks to the task processing queue according to the successor task configuration.
[0030] Event round: refers to the round number of the event-level decision-making process for the same security event. Each event coordination agent completes a full decision (including creating subtasks, generating commands, recording follow-up questions, and ending the event), and the event round number increases sequentially.
[0031] Task Round: Refers to the round number of command execution and summary backfilling experienced by the same task object. Each time a task is executed, the agent re-determines whether the task is completed based on the execution summary, and the task round number increments.
[0032] Execution summary: This refers to the structured summary information generated after semantic extraction of the original result of command execution. The execution summary is written to the execution object and can be directly read by subsequent task processing and event-level re-decision.
[0033] Event coordination agent: refers to an agent that is responsible for generating the next round of handling decisions based on the task results and execution summary when all task objects in the current event round have been completed.
[0034] Task execution agent identifier: refers to the agent identifier bound to the task object created when the event is accessed, used to indicate the agent responsible for handling the initial task object.
[0035] The method for multi-agent analysis and handling of security events provided by the present invention will be described in detail below with reference to the accompanying drawings.
[0036] like Figure 1 As shown, the method provided by the present invention includes the following steps: Step S101: Obtain security event data and create an event object.
[0037] The system receives security event data or processing requests through application programming interfaces (APIs), user input, external messaging systems, or execution result feedback entry points. Security event data includes at least one or more of the following: event name, event type, event source, event description, alarm identifier, alarm time, event level, load, priority, automation mode, and user organizational permissions.
[0038] The system performs normalization processing on the received security event data. This normalization process includes one or more of the following: null character removal, payload length truncation, alarm time format conversion, event level value conversion, and user identifier format verification. The purpose of normalization is to convert security event data from different data sources and with different data formats into a unified standard data format within the system, thereby reducing the data parsing complexity in subsequent processing stages.
[0039] After standardization, the system creates an event object. The event object includes at least an event identifier, an event coordinating agent identifier, an event type, an event state, an event round, a priority, an automation mode, a stop flag, and event content. The event identifier is a globally unique identifier generated by the system, used to uniquely identify the security event throughout the entire processing chain. The event coordinating agent identifier specifies the event coordinating agent responsible for task orchestration and round scheduling for this event object, enabling the event processing queue to route the event object to the corresponding event coordinating agent for processing based on this identifier. The event type indicates the category to which the security event belongs, such as: analysis and handling, collaboration, chat, file detection, or threat hunting. The event state records the current processing stage of the event, such as: pending, processing, completed, or failed. The event round records the number of rounds of event-level decision-making for the event, with an initial value of the first round. The priority indicates the urgency of the event's processing; the system can sort events according to priority. The automation mode indicates which steps in the event processing can be executed automatically and which require manual intervention. The stop flag indicates whether the processing of the event has been paused. The event content carries the core payload information of the security event, such as alarm details, attack payloads, or log fragments.
[0040] The creation of event objects provides a unified state carrier for the entire security incident handling chain. All subsequently generated task objects, command objects, execution objects, message objects, and large language model request objects are associated with the event object through event identifiers, thereby achieving state traceability throughout the entire handling chain.
[0041] Step S102: Select the processing entry path according to the event type.
[0042] The system determines whether the event type of the event object is a preset type. If the event type is a preset type, a task object bound to a task execution agent identifier is created, and the task object is sent to the task processing queue. In one embodiment, the preset type is a judgment and disposal type event. For judgment and disposal type events, the system directly generates an initial task object when the event is created. This initial task object carries the event summary and judgment target. The task allocation object is a judgment expert agent (a type of task execution agent), the task status is pending, the event round is the first round, and the task round is the initial round. The initial task object has no preceding dependent tasks and no subsequent tasks.
[0043] If the event object's event type is not a preset type, the event object is sent to the event processing queue. In one embodiment, the non-preset type includes at least one of collaboration events, chat events, file detection events, and threat hunting events. For collaboration, chat, file detection, or threat hunting events, the system does not create an initial task object, but directly sends the event object to the event processing queue, where the event coordinating agent makes macro-level decisions.
[0044] For assessment and handling events, the above steps allow the task-level processing chain to start before the event-level processing chain, enabling the expert agent to directly perform preliminary analysis of the event without waiting for the event coordinating agent to complete macro-level decisions before breaking down tasks. This task-first processing path shortens the response latency for assessment and handling events while preserving the event coordinating agent's ability to make overall decisions subsequently.
[0045] Step S103: The task execution agent generates a large language model request object.
[0046] The parts related to the task processing queue in this step and subsequent steps S104 and S105 will be handled according to... Figure 2 The process shown describes the complete process of reading the task object from the task processing queue, verifying the prerequisite dependent tasks, constructing the task context, generating and sending the large language model request object, and the response flowing back to the task processing queue.
[0047] Specifically, after the task execution agent in the task processing queue reads the task object, it checks whether all the preceding dependent tasks of the task object have been completed.
[0048] Specifically, the task execution agent queries the current status of each prerequisite task based on the list of prerequisite tasks recorded in the task object. If all prerequisite tasks are in the completed state, it is determined that all prerequisite tasks are completed; if any prerequisite task is in the incomplete or in-process state, the current task object does not continue to execute and waits for all prerequisite tasks to be completed before triggering processing.
[0049] Once all prerequisite tasks are completed, the task execution agent constructs the task context and generates a large language model request object.
[0050] The steps of constructing the task context specifically include: extracting the system prompt word template corresponding to the agent identifier bound to the current task object; obtaining the historical handling records of the event object, the completed operation records of the current event round, and asset information; and concatenating the system prompt word template, historical handling records, completed operation records, and asset information according to a preset format to generate a structured task context.
[0051] The task context serves as the information foundation for expert analysis by the large language model. It integrates basic information about the current task (task name), the execution results of previous tasks, system prompt templates, historical processing records, completed operation records, and asset information into structured input data for the large language model to reason and analyze. By piecing together information scattered across different state objects into a structured task context according to a preset format, the system ensures that the large language model obtains all the contextual information needed for professional judgment, while avoiding interference from irrelevant information.
[0052] The task execution agent generates a large language model request object. This large language model request object includes at least a request identifier, a request type identifier, a system prompt, a user prompt, an event identifier, whether it is a long text request, response content, inference content, token usage information, time consumption, and request status. The request type identifier is a task-level type, indicating that the request was initiated by the task execution agent, ensuring that the response can correctly flow back to the task processing queue after completion. Once the large language model request object is created, the system sends it to the large language model request queue.
[0053] The creation of a large language model request object decouples model calls from business processing logic. In traditional solutions, model calls typically employ a synchronous blocking approach, where the business processor directly calls the model interface and waits for a response. This blocks the business processor during model calls, preventing it from handling other tasks and reducing system throughput and responsiveness. This invention encapsulates model calls into independent request objects and sends them to a large language model request queue, achieving asynchronous decoupling between model calls and business processing. After generating the request object and sending it to the queue, the business processor can continue processing other tasks, while the model service asynchronously reads requests from the queue for processing. Neither blocks the other, significantly improving the system's concurrent processing capabilities.
[0054] Step S104: The event coordinating agent generates a large language model request object.
[0055] After reading the event object, the event coordinating agent constructs the event context and generates a large language model request object.
[0056] The event context includes at least one or more of the following: basic information of the current event, event payload, historical handling records, existing assessment conclusions, existing handling conclusions, the latest user input, a list of available expert capabilities, and workflow configuration. The construction method of the event context is similar to that of the task context, but with a higher information dimension; that is, the event context focuses on the macro-state of the entire security event, rather than the micro-state of a specific task.
[0057] The request type identifier of the large language model request object generated by the event coordinating agent is designated as an event-level type. This indicates that the request was initiated by the event coordinating agent, ensuring that the response can be correctly routed back to the event processing queue upon completion. The event coordinating agent then sends the generated large language model request object to the large language model request queue.
[0058] The large language model request objects generated by the event coordination agent and the task execution agent are distinguished by request type identifiers. This allows the system to differentiate between macro-level decision-making requests initiated by the event coordination agent and specific analysis requests initiated by the task execution agent, thus enabling the system to correctly route responses to the corresponding processing queues upon return. This routing mechanism based on request type identifiers is one of the core technical means by which this invention achieves model response routing.
[0059] Step S105: When the operation execution queue needs to generate an execution summary, the summary generation agent constructs a summary generation context and generates a large language model request object carrying a summary-level request type identifier, and sends it to the large language model request queue.
[0060] Step S106: The large language model service processes the request and distributes the response according to the request type identifier.
[0061] The large language model service in the request queue reads the large language model request objects to be processed from the queue and calls the large language model to perform inference processing. After the large language model has completed processing, the system writes the response content, inference content, token usage information, time consumption, and request status into the large language model request object.
[0062] The system distributes the response results of the large language model to the corresponding processing queues based on the request type identifier in the large language model request object, including: If the request type is identified as an event-level type, the response result will be routed to the event processing queue. If the request type is identified as a task-level type, the response result will be routed to the task processing queue. If the request type is identified as a digest-level type, the response result will be routed to the operation execution queue.
[0063] The technical principle behind the aforementioned traffic splitting mechanism is as follows: the request type identifier serves as the basis for response routing. It is written into the large language model request object when the request is created and travels through the entire model invocation process along with the request. When the model response is returned, the system only needs to read the request type identifier field to determine the target processing queue for that response, and can complete the routing decision without parsing the response content.
[0064] This identifier-based routing mechanism has the following technical advantages: First, routing decisions are decoupled from response content, so the system can complete routing without waiting for response content parsing, reducing response processing latency. Second, requests and responses from different sources are automatically isolated into different processing queues, avoiding interference between responses from different levels of processors; Third, even if the system restarts abnormally, the request type identifier in the persistently stored large language model request object remains available, ensuring the reliability of response routing.
[0065] Step S107: The event processing queue and task processing queue parse the response results and perform processing operations.
[0066] After receiving the response results from the large language model that have been routed to the event processing queue, the event coordination agent performs structured parsing on the response results. Structured parsing refers to extracting structured processing instructions from the natural language output of the large language model according to a preset response format. The output of the large language model is required to be organized according to a preset JSON format or a similar semi-structured format so that the system can identify the response type and corresponding parameters by parsing specific fields.
[0067] Furthermore, the event coordination agent executes corresponding scheduling and handling operations based on the parsed response type, specifically including: (1) Task creation and scheduling.
[0068] When the response type is a task creation instruction, the event coordinating agent generates one or more new task objects and sends them to the task processing queue. Each new task object is bound to a specified task execution agent identifier, indicating that the corresponding task execution agent will take over the subsequent processing. By binding the same or different task execution agent identifiers to different new task objects, serial processing by a single agent or collaborative parallel processing by multiple agents can be achieved.
[0069] In one specific implementation, the event coordination agent extracts a task list and the dependencies between tasks from the parsing results, generates an internal task identifier for each task, and maps the dependencies to a pre-dependency field of a new task object. The new task object carrying this field is then sent to the task processing queue. For example, agents with different specializations, such as judgment, handling, log analysis, and asset retrieval, can be bound to corresponding new task objects, allowing each agent to execute in parallel or sequentially based on pre-dependencies without blocking each other.
[0070] (2) Command execution scheduling When the response type is a command execution instruction, the event coordinating agent generates an event-level command object and sends the event-level command object to the operation execution queue.
[0071] (3) Confirmation of the final state of the task When the response type is a task completion instruction, the event coordinating agent generates a state update instruction, which is used to mark the state of the task object that triggered the response as completed.
[0072] (4) Adding interaction records When the response type is a follow-up instruction, the event coordinating agent generates a message append instruction, which is used to write the follow-up message into the interaction record of the task object to be executed that triggered the response result.
[0073] Furthermore, after receiving the response results of the large language model that have been routed to the task processing queue, the task execution agent in the task processing queue performs structured parsing on the response results. The parsing logic of the task execution agent is similar to that of the event coordination agent, but the types of execution operations differ: If the parsed response type is a command execution instruction, then a task-level command object is created and the task-level command object is sent to the operation execution queue.
[0074] If the parsed response type is a task completion instruction, then write the task result and update the status of the task object to complete.
[0075] The difference in handling operations between the task execution agent and the event coordination agent reflects the design philosophy of this invention: event-level overall decision-making and task-level specific execution. The event coordination agent can create new task objects (i.e., split into new sub-tasks), which is its core function as a macro-level decision-maker; it can decide whether to introduce new expert tasks to analyze the event from different perspectives based on the overall state of the current event. In contrast, the task execution agent can only create command objects or mark task completion; it cannot create new task objects. This is to prevent the task execution agent from overstepping its authority and creating new tasks, leading to a loss of control at the task hierarchy. Through this separation of responsibilities, the system ensures that the distribution and scheduling of tasks are centralized in the hands of the event coordination agent, while the task execution agent is only responsible for performing specific, specialized analysis work.
[0076] Step S108: Execute the command object in the operation execution queue and generate an execution summary.
[0077] This step and subsequent steps S109 and S110 will be carried out in accordance with Figure 3 The process shown describes the complete process of a command object being read from the operation execution queue, executed, having an execution summary generated, being re-enqueued based on the summary completion status, triggering a task or event, and finally triggering a subsequent task or event-level re-decision.
[0078] Specifically, the operation executors in the operation execution queue read the command object and execute the corresponding operation. The operation executors route commands to the corresponding execution paths based on the command type. Command types can include one or more of the following: script execution, agent invocation, MCP tool invocation, manual processing, load analysis, ClickHouse database query, or PostgreSQL database query.
[0079] After the command is executed, the executor creates or updates the execution object. The execution object includes at least an execution identifier, a command identifier, an event identifier, a task identifier, a task round, an execution result, an execution summary, and an execution status. The execution result records the raw output data of the command execution, and the execution status records whether the command execution was successful or failed.
[0080] The execution digest processor in the operation execution queue generates an execution digest of the execution result and writes the execution digest to the execution object.
[0081] Furthermore, the method for generating the execution summary varies depending on the command type: For structured query commands (such as ClickHouse database queries and PostgreSQL database queries), the execution summary processor can directly generate a structured execution summary based on the structured fields of the query results. For example, for query results that return tabular data, the execution summary processor can extract the number of rows, statistical information of key fields (such as maximum, minimum, average, and duplicate counts), and a list of key records hit, and organize this information into structured summary data.
[0082] For unstructured tool execution commands (such as load analysis and agent invocation), the execution summary processor can create a summary-level large language model request object and send it to the large language model request queue. The large language model then performs semantic extraction on the execution result to generate an execution summary. After receiving the large language model response result that has been routed back to the operation execution queue, the execution summary processor writes the execution summary into the execution object.
[0083] The technical role of execution summaries is to extract the raw output of command execution (which may contain thousands of lines of logs or a large amount of raw data) into structured summary information that can be directly read by subsequent task processing and event-level decision-making. Execution summaries eliminate the need for subsequent processing steps to re-parse the raw execution results or process the large amount of irrelevant information that may be contained in the raw results, thereby improving the efficiency and accuracy of subsequent processing. Simultaneously, the execution summary is written to the execution object as persistent state data, making the decision-making basis of the entire handling chain traceable and auditable.
[0084] Step S109: Trigger the task object or event object to be re-enqueued based on the completion status of the execution summary.
[0085] Specifically, the execution digest processor performs the following operations based on the completion status of the execution digest: If the execution digests of all command objects associated with the current task object in the same task round have reached the completion state, the current task object is resent to the task processing queue, and the task execution agent determines whether the current task object has been processed and whether it is necessary to generate new command objects based on the execution digests.
[0086] If the execution digests of all command objects associated with the current event object in the same event round have reached the completion state, the current event object is resent to the event processing queue. The event coordination agent then determines, based on the execution digests, whether the current event object has been processed and whether an event round scheduling instruction needs to be generated.
[0087] The technical principle behind the aforementioned re-queueing mechanism lies in the fact that the execution summary is a semantic extraction of the command execution result. Its completion signifies that the command's execution result can be understood and reused by subsequent processing stages. When all commands in the same task round have generated execution summaries, it means that all tool calls required for the task have been executed and the execution results have been extracted into usable summary information. At this point, the task object should be re-entered into the task processing queue, and the task execution agent should determine whether the task is completed or whether new commands need to be generated to obtain more information based on these execution summaries. Similarly, when all event-level commands in the same event round have generated execution summaries, the event object should be re-entered into the event processing queue, and the event coordination agent should make event-level re-decision based on the execution summaries.
[0088] This re-enqueue mechanism based on the completion status of the execution digest is the core technical means of this invention to automatically drive subsequent decisions based on command execution results. The execution digest, acting as a bridge between command execution results and subsequent decisions, seamlessly connects the originally isolated command execution stage with the subsequent analysis and decision-making stage, forming a complete closed loop of execution, summarization, and re-decision.
[0089] Step S110: After the task object is completed, trigger subsequent tasks or event-level re-decision.
[0090] Once a task in the task processing queue is completed, the system triggers a successor task to enter the task processing queue based on the successor task configuration configured in that task. The successor task configuration records one or more successor tasks that need to be automatically started after the current task is completed. Through the successor task configuration, the system achieves chained triggering between tasks, automatically advancing the processing flow without the intervention of an event coordination agent.
[0091] Alternatively, the system can trigger an event-level re-decision once all tasks in the current event round have been completed. Specifically, the system sends an event completion message to the event processing queue, where the event coordinating agent generates the next round's handling decision based on the task results and execution summaries. The event coordinating agent reads the task results of all tasks in the current event round and the execution summaries of all executed objects, combines this information to generate a new event-level large language model request, and decides, based on the new structured response, whether to further split into new tasks, generate event-level commands, raise follow-up questions, or terminate the event.
[0092] The introduction of event rounds allows the same security event to undergo multiple rounds of iterative processes, including task decomposition, task execution, summary backfilling, and event-level re-decision. Each round of event-level decision-making generates a new set of tasks, and the execution results of each set of tasks are backfilled into the event context through execution summaries, providing a more comprehensive information basis for the next round of event-level decision-making. This multi-round iterative mechanism enables the system to initiate the handling process even with incomplete information, gradually improving its understanding of the event as execution results are continuously backfilled, ultimately leading to an accurate handling conclusion.
[0093] Step S111: Repeat until the preset iteration termination condition is met.
[0094] The system repeats steps S103 to S110 until a preset iteration termination condition is met. The preset iteration termination condition includes at least one of the following: the state of the event object is updated to be handled or failed; the event round reaches a preset maximum round threshold; the event round scheduling instruction generated by the event coordinating agent contains an event termination identifier; the user manually terminates the event handling process; the system detects that the stop flag in the event object is set.
[0095] The setting of iterative termination conditions ensures that the entire process will inevitably end, preventing it from falling into an infinite loop due to continuous task generation or command execution. Meanwhile, multiple termination conditions provide flexible process control: termination via an event termination flag upon normal completion, termination via a failure status or maximum round threshold in abnormal situations, and termination via a stop flag upon manual intervention.
[0096] The following example of a web attack alert analysis and handling method will be used to illustrate the multi-agent analysis and handling method for security events provided by the present invention in detail.
[0097] In this embodiment, the system receives a Web attack alert via the API interface. The alert data includes: alert name is SQL injection attack, alert source is Web Application Firewall, alert time is 10:23:15 on July 4, 2026, alert level is high risk, attack payload is an SQL injection statement "'OR'1'='1", source IP address is 203.0.113.45, target URL is " / api / user / login", and target server hostname is web-srv-01.
[0098] The system performs standardization processing on the received alarm data, including: removing empty characters from the alarm data, converting the alarm time to the system's internal timestamp format, converting the alarm level "high risk" to a numerical level of 9, and verifying the user identifier format. After standardization, the system creates an event object. The event object's event identifier is a globally unique identifier EVT-20260704-001 generated by the system, the event type is analysis and handling, the event status is pending, the event round is 1, the priority is high, the automation mode is fully automatic, the stop flag is no, and the event content contains all the standardized data of the aforementioned alarm.
[0099] The system determines that the event type of this event object is a judgment and assignment event, and therefore creates a task object bound to a task execution agent identifier. The task identifier of this task object is TASK-001, the event identifier is EVT-20260704-001, the event round is 1, the task round is 1, the task assignment object (task execution agent identifier) is judgment expert-01, the task status is pending, the preceding dependent tasks are empty, and the successor tasks are empty.
[0100] After reading task object TASK-001 in the task processing queue, the task execution agent checks whether all its prerequisite tasks have been completed. Since the prerequisite tasks are empty, it is determined that all are completed. The task execution agent constructs the task context: extracting the system prompt word template corresponding to the judgment expert-01 (containing instructions and rules for security event judgment), obtaining the historical handling record of the event object (currently no historical record), the completed operation record of the current event round (currently no completed operation record), and asset information (querying the asset information of the target server web-srv-01 from the asset database, including the operating system being Linux, the business belonging to user authentication service, and the asset importance being high). The task execution agent concatenates the above information into a structured task context according to a preset format. The task execution agent generates a large language model request object, identifies the request type as a task-level type, and sends it to the large language model request queue.
[0101] The large language model service in the request queue reads the request and invokes the large language model for processing. The model analyzes the request based on the task context and outputs a structured response. The system then distributes the response results to the task processing queue according to the request type identifier (task-level type).
[0102] After receiving the response result, the task execution agent in the task processing queue performs structured parsing. The parsed response type is a command execution instruction, and the response content is "Query all access logs of the target server within the past 24 hours, focusing on the request records from the source IP address 203.0.113.45". The task execution agent creates a task-level command object, with the command type being a ClickHouse database query, the tool identifier being log-query-tool, and the tool parameters including: target server identifier web-srv-01, time range "2026-07-03 10:23:15 to 2026-07-04 10:23:15", and filter condition "source IP = 203.0.113.45". The task execution agent then sends the command object to the operation execution queue.
[0103] After reading the command object from the operation execution queue, the operation executor routes the command to the ClickHouse database query execution path based on the command type (ClickHouse database query), and performs the log query operation. The query returned 856 access log records, including multiple SQL injection attempts. The operation executor creates an execution object, records the execution result (complete data of the 856 log records) and the execution status (success).
[0104] The execution digest processor in the operation execution queue generates an execution digest of the execution result. Since the command type is a ClickHouse database query (structured query class), the execution digest processor directly generates a structured execution digest based on the structured fields of the query result: a total of 856 records extracted, 47 request records from the source IP 203.0.113.45, the time distribution of SQL injection attempts, and a list of hit key URLs. The execution digest processor writes the execution digest to the execution object and resends the task object to the task processing queue.
[0105] The task execution agent in the task processing queue reads the task object TASK-001 again. At this point, the task context contains records of completed operations (i.e., the execution summary from the aforementioned log query). Based on this execution summary, the task execution agent determines whether the current task is complete. Since the log query result has been obtained, the task execution agent considers the assessment criteria for the current task sufficient, therefore updates the task status to "completed" and generates a task completion message, which is sent to the event processing queue.
[0106] After receiving the task completion message, the event processing queue queries the status of all tasks in the current event round (round 1). Only task TASK-001 is present in the current event round, and its status is completed. Therefore, the event-level "all tasks completed" processing logic is triggered.
[0107] The event coordination agent generates new event-level large language model requests based on the task results and execution summaries, identifies the request type as an event-level type, and sends it to the large language model request queue. After the large language model service completes its processing, it distributes the response to the event processing queue according to the request type identifier (event-level type).
[0108] After receiving the response, the event coordination agent performs structured parsing. The parsed response type is a task creation instruction, containing two sub-tasks: sub-task one involves the asset retrieval expert confirming whether the target server has been implanted with a backdoor, and sub-task two involves the handling expert generating a handling opinion for the SQL injection attack. The event coordination agent creates two task objects, binds each task to a corresponding agent identifier (asset retrieval expert-03 and handling expert-05, respectively), sets the dependency between the two tasks to parallel (i.e., no mutual dependency), and sends both tasks to the task processing queue.
[0109] The processors in the task processing queue read two task objects respectively, check their prerequisite tasks (both of which are empty), construct task contexts and generate large language model request objects, and send them to the large language model request queue respectively. The two tasks are processed in parallel without blocking each other.
[0110] The asset retrieval expert's task generates a command object, with the command type being asset scan. After the executor performs the asset scan, an execution summary is generated, confirming that no backdoor program was found on the target server. The disposal expert's task generates a command object, with the command type being script execution. After the executor performs the disposal script, an execution summary is generated, confirming that a disposal opinion has been generated.
[0111] Once both tasks are completed, each sends a task completion message to the event handling queue. The event handling queue confirms that all tasks in the current event round (round 1) have been completed and triggers an event-level re-decision.
[0112] The event coordinating agent generates another event-level large language model request, performing a comprehensive analysis based on all task results and execution summaries. The model output response type is a task completion instruction, concluding that: the SQL injection attack has been confirmed, the attack source IP has been blocked, no backdoor was found on the target server, and it is recommended to close this event. The event coordinating agent updates the event object's status to "handled" and generates an event round scheduling instruction (including an event termination identifier) which is sent to the event processing queue.
[0113] The event processing queue parses the event round scheduling instructions, identifies the event termination identifier, updates the status of the event object to "processed", archives the full-link processing log of the event object (including event creation record, task processing record, command execution record, execution summary record, and model request record), and the event processing process ends.
[0114] This embodiment fully demonstrates the complete processing flow of the method of the present invention. Throughout the process, event objects, task objects, command objects, execution objects, message objects, and large language model request objects establish a complete association link through their respective object identifiers, making the entire processing process traceable and auditable. The execution summary, acting as a bridge between the command execution result and subsequent decisions, extracts the original log query results into structured summary information, driving subsequent task completion judgments and event-level re-decision-making.
[0115] See Figure 4 Another embodiment of the present invention provides a security event multi-agent analysis and handling device 200, including an event object creation module 201, an event diversion module 202, a task scheduling module 203, a response diversion module 204, a result parsing and execution module 205, an execution feedback module 206, a round coordination module 207, and an iterative execution module 208. The security event multi-agent analysis and handling device 200 is capable of executing the security event multi-agent analysis and handling method in the method embodiment.
[0116] Specifically, the security incident multi-agent analysis and handling device 200 includes: The event object creation module 201 is used to obtain security event data and create event objects. The event routing module 202 is used to create a task object and send it to the task processing queue if the event type of the event object is a preset type; otherwise, it sends the event object to the event processing queue. The task scheduling module 203 is used to obtain task objects from the task processing queue where all preceding dependent tasks have been completed, construct a task context and generate a large language model request object carrying a task-level request type identifier by the task execution agent, and send it to the large language model request queue; obtain event objects from the event processing queue, construct an event context and generate a large language model request object carrying an event-level request type identifier by the event coordination agent, and send it to the large language model request queue; when the operation execution queue needs to generate an execution summary, the summary generation agent constructs a summary context and generates a large language model request object carrying a summary-level request type identifier, and sends it to the large language model request queue. The response routing module 204 is used to route the response result to the event processing queue, the task processing queue, or the operation execution queue according to the request type identifier after the large language model request queue has been processed. The result parsing and execution module 205 is used by the event processing queue and the task processing queue to parse the response results diverted to this queue. If the parsed response type is a task creation instruction, a new task object is created and sent to the task processing queue; if the parsed response type is a command execution instruction, a command object is created and sent to the operation execution queue; if the parsed response type is a task completion instruction, the state of the current task object is updated; if the parsed response type is a follow-up instruction, the follow-up message is recorded in the interaction history of the current task object. The execution feedback module 206 is used to generate an execution summary for the execution result after the operation execution queue executes the command object, and trigger the current task object or the current event object to be re-enqueued according to the completion status of the execution summary; The round coordination module 207 is used to trigger subsequent tasks according to the subsequent task configuration of the current task object after the current task object is completed, or to generate an event round scheduling instruction and send it to the event processing queue after all task objects in the current event round have been completed. The iterative execution module 208 is used to repeatedly execute the above steps until the preset iteration termination condition is met.
[0117] It should be noted that the technical solutions corresponding to the security event multi-agent analysis and handling device 200 provided in this embodiment, which can be used to execute various method embodiments, have similar implementation principles and technical effects to the methods, and will not be repeated here.
[0118] Figure 5 This is a schematic diagram of an electronic device 300 provided in another embodiment of the present invention. The electronic device 300 is used to implement the multi-agent analysis and handling method for security events in the method embodiment. The electronic device 300 in the embodiments of the present invention may include, but is not limited to, smartphones, tablet computers, PCs, laptops, etc. Figure 5 The electronic device 300 shown is merely an example and should not be construed as limiting the functionality and scope of use of the embodiments of the present invention.
[0119] like Figure 5As shown, the electronic device 300 may include a processing device (e.g., a central processing unit, a graphics processing unit, etc.) 301, which can perform various appropriate actions and processes to implement the methods of the embodiments described herein, based on a program stored in a read-only memory (ROM) 302 or a program loaded from a storage device 308 into a random access memory (RAM) 303. The RAM 303 also stores various programs and data required for the operation of the electronic device 300. The processing device 301, ROM 302, and RAM 303 are interconnected via a bus 305. An input / output (I / O) interface 304 is also connected to the bus 305.
[0120] Typically, the following devices can be connected to I / O interface 304: input devices 306 including, for example, touchscreens, touchpads, keyboards, mice, cameras, microphones, accelerometers, gyroscopes, etc.; output devices 307 including, for example, liquid crystal displays (LCDs), speakers, vibrators, etc.; storage devices 308 including, for example, magnetic tapes, hard disks, etc.; and communication devices 309. Communication device 309 allows electronic device 300 to communicate wirelessly or wiredly with other devices to exchange data. Although Figure 5 An electronic device 300 with various devices is shown; however, it should be understood that it is not required to implement or possess all of the devices shown. More or fewer devices may be implemented or possessed alternatively.
[0121] The above description is merely a preferred embodiment of the present invention. Those skilled in the art should understand that the scope of disclosure in this invention is not limited to the specific combination of the above-described technical features, but should also cover other technical solutions formed by any combination of the above-described technical features or their equivalents without departing from the above-described concept. For example, technical solutions formed by substituting the above features with (but not limited to) technical features with similar functions disclosed in this invention.
Claims
1. A multi-agent method for judging and handling security incidents, characterized in that, Includes the following steps: Obtain security event data and create event objects; If the event type of the event object is a preset type, then a task object is created and sent to the task processing queue; otherwise, the event object is sent to the event processing queue. The task object, from which all preceding dependent tasks have been completed, is retrieved from the task processing queue. The task execution agent constructs the task context and generates a large language model request object carrying a task-level request type identifier, and sends it to the large language model request queue. The event object is retrieved from the event processing queue. The event coordination agent constructs the event context and generates a large language model request object carrying an event-level request type identifier, and sends it to the large language model request queue. When the operation execution queue needs to generate an execution summary, the summary generation agent constructs the summary context and generates a large language model request object carrying a summary-level request type identifier, and sends it to the large language model request queue. After the large language model request queue has finished processing, the response result is distributed to the event processing queue, the task processing queue, or the operation execution queue according to the request type identifier. The event processing queue and the task processing queue parse the response results that are routed to this queue. If the parsed response type is a task creation instruction, a new task object is created and sent to the task processing queue; if the parsed response type is a command execution instruction, a command object is created and sent to the operation execution queue; if the parsed response type is a task completion instruction, the state of the current task object is updated; if the parsed response type is a follow-up instruction, the follow-up message is recorded in the interaction history of the current task object. After the operation execution queue executes the command object, it generates an execution summary of the execution result, and triggers the current task object or the current event object to be re-enqueued according to the completion status of the execution summary; After the current task object is completed, the subsequent task is triggered according to the subsequent task configuration of the current task object, or after all task objects in the current event round have been completed, the event coordination agent generates an event round scheduling instruction and sends it to the event processing queue. Repeat the above steps until the preset iteration termination condition is met.
2. The method for multi-agent analysis and handling of security events according to claim 1, characterized in that, Also includes: The current status of each dependent task is queried based on the list of preceding dependent tasks. When the status of all dependent tasks is "completed", it is determined that all preceding dependent tasks are completed. Otherwise, the current task object is temporarily stored in the waiting queue, and the check is retried when the status of any dependent task is updated to "completed".
3. The method for multi-agent analysis and handling of security events according to claim 1, characterized in that: The steps of constructing a task context by the task execution agent include: extracting the system prompt word template corresponding to the task execution agent; obtaining the historical handling records of the event object, the completed operation records of the current event round, and the associated asset information; and concatenating the system prompt word template, historical handling records, completed operation records of the current event round, and associated asset information according to a preset format to generate a structured task context. The steps for constructing the event context include: extracting the system prompt word template corresponding to the event coordinating agent; obtaining the original alarm data, historical handling records, execution summaries of all task objects in the current event round, and associated asset information of the event object; and concatenating the system prompt word template, original alarm data, historical handling records, execution summaries of all task objects, and associated asset information in a preset format to generate a structured event context.
4. The multi-agent analysis and handling method for security events according to claim 1, characterized in that, The step of routing the response result to the event processing queue, the task processing queue, or the operation execution queue according to the request type identifier includes: When the request type is identified as an event-level type, the response result is routed to the event processing queue; when the request type is identified as a task-level type, the response result is routed to the task processing queue; when the request type is identified as a summary-level type, the response result is routed to the operation execution queue.
5. The multi-agent analysis and handling method for security events according to claim 1, characterized in that, The steps for creating a task object include: Extract the target agent identifier and task parameters from the parsed content of the response result of the large language model request; create a task object based on the task parameters, bind the target agent identifier to the task object, and set the prerequisite dependencies between each task object according to the parsed content.
6. The method for multi-agent analysis and handling of security events according to claim 1, characterized in that, The step of triggering the re-enqueueing of the current task object or the current event object based on the completion status of the execution digest includes: If the execution digests of all command objects associated with the current task object in the same task round have reached the completion state, the current task object is resent to the task processing queue, and the task execution agent determines whether the current task object has been processed and whether new command objects need to be generated based on the execution digests. If the execution digests of all command objects associated with the current event object in the same event round have reached the completion state, the current event object is resent to the event processing queue. The event coordination agent then determines, based on the execution digests, whether the current event object has been processed and whether an event round scheduling instruction needs to be generated.
7. The method for multi-agent analysis and handling of security events according to claim 1, characterized in that, Also includes: The event coordination agent parses the event round scheduling instruction. When the event round scheduling instruction contains a list of tasks for the next round, it creates the corresponding task objects in sequence and sends them to the task processing queue. When the event round scheduling instruction contains an event termination identifier, it updates the status of the event object to "processed" and archives the full-link processing log of the event object.
8. The multi-agent analysis and handling method for security events according to claim 1, characterized in that, The step of recording the follow-up message in the interaction history of the current task object if the parsed response type is a follow-up instruction includes: When the parsing result contains a user interaction request, a follow-up message object is generated, the follow-up message object is associated with the current event object and the current task object, and the follow-up message is recorded.
9. A multi-agent judgment and handling device for security events, characterized in that, include: The event object creation module is used to obtain security event data and create event objects. The event routing module is used to create a task object and send it to the task processing queue if the event type of the event object is a preset type; otherwise, it sends the event object to the event processing queue. The task scheduling module is used to retrieve task objects from the task processing queue where all preceding dependent tasks have been completed, construct task contexts and generate large language model request objects carrying task-level request type identifiers by the task execution agent, and send them to the large language model request queue; retrieve event objects from the event processing queue, construct event contexts and generate large language model request objects carrying event-level request type identifiers by the event coordination agent, and send them to the large language model request queue; when the operation execution queue needs to generate an execution summary, the summary generation agent constructs a summary context and generates large language model request objects carrying summary-level request type identifiers, and sends them to the large language model request queue. The response routing module is used to route the response result to the event processing queue, the task processing queue, or the operation execution queue according to the request type identifier after the large language model request queue has been processed. The result parsing and execution module is used by the event processing queue and the task processing queue to parse the response results diverted to this queue. If the parsed response type is a task creation instruction, a new task object is created and sent to the task processing queue; if the parsed response type is a command execution instruction, a command object is created and sent to the operation execution queue; if the parsed response type is a task completion instruction, the status of the current task object is updated; if the parsed response type is a follow-up instruction, the follow-up message is recorded in the interaction history of the current task object. The execution feedback module is used to generate an execution summary of the execution result after the operation execution queue executes the command object, and trigger the current task object or the current event object to be re-enqueued according to the completion status of the execution summary; The round coordination module is used to trigger subsequent tasks according to the subsequent task configuration of the current task object after the current task object is completed, or to generate an event round scheduling instruction and send it to the event processing queue after all task objects in the current event round have been completed. The iterative execution module is used to repeatedly execute the above steps until the preset iteration termination condition is met.
10. An electronic device, characterized in that, include: One or more processors; as well as Storage device for storing one or more computer programs; When the one or more computer programs are executed by the one or more processors, the one or more processors implement a multi-agent security event assessment and handling method as described in any one of claims 1 to 8.
