A hierarchical intelligent agent constrained orchestration method and system oriented towards user security needs
By employing a hierarchical intelligent agent constrained orchestration method, the problems of security detection task interruption and repeated scanning are solved, achieving accuracy of detection results and environmental stability. The execution and re-orchestration of detection tasks are managed through task graphs and short-term leases.
Patent Information
- Application Number
- CN202611469727.3
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2026-09-21
- Publication Date
- 2026-11-17
AI Technical Summary
In security testing scenarios, existing technologies suffer from problems such as interrupted testing tasks, repeated scanning, and distorted testing results. In particular, when data sources change, tools are upgraded or become unusable, the recovery and reordering of testing tasks cannot be effectively managed, leading to instability in the target environment.
A hierarchical agent-constrained orchestration method is adopted, in which a central agent generates a task graph and short-term leases, and an terminal agent verifies and executes the tasks, ensuring that the input list is bound to the execution authorization. Capability contracts and state ledgers are used to manage the execution and re-orchestration of task nodes.
It effectively prevents unauthorized data access, reduces repetitive operations, ensures the accuracy and stability of test results, avoids the reuse of expired results, and improves the recovery capability of testing tasks.
Smart Images

Figure CN123122973A_ABST
Abstract
Description
Technical Field
[0001] This invention belongs to the field of computer security orchestration and intelligent agent cooperative control technology, specifically relating to a hierarchical intelligent agent constrained orchestration method and system oriented towards user security needs. Background Technology
[0002] In security testing scenarios, security testing tasks typically require data transfer and collaborative processing across multiple data sources, including asset lists, file information, process logs, and network logs. During actual testing, the testing orchestration system needs to parse and convert the dynamic testing conditions input by the user into call parameters that can be recognized by each execution tool.
[0003] The following shortcomings exist in the parameter conversion and tool invocation stages: the data collected by upstream modules may change, the execution tools may undergo version upgrades or service failures, and tasks may be interrupted due to successful tool invocation but failure to deliver execution receipts. When re-orchestrating and resuming execution of interrupted tasks, if historical authorization information is directly used, downstream consumer nodes may perform operations based on new input data, which has not obtained the corresponding access authorization; if all steps are re-executed when resuming the task, it is easy to cause duplicate scanning, or even cause duplicate state changes to the target asset, damaging the stability of the target environment; if the historical results of completed nodes are directly reused, expired historical data will be passed to the downstream processing stage, causing the detection results to be distorted. Summary of the Invention
[0004] To address the shortcomings of existing technologies, this invention provides a layered intelligent agent constrained orchestration method and system oriented towards user security needs, which can effectively solve the above-mentioned problems.
[0005] The technical solution adopted in this invention is as follows:
[0006] In a first aspect, the present invention provides a layered intelligent agent constrained orchestration method oriented towards user security needs, comprising:
[0007] The central agent obtains the security requirements submitted by the user and converts them into task constraint descriptions. Based on the task constraint descriptions and the capability contracts of the sub-agents, a task graph containing task nodes and task edges is generated. Among them, task nodes record operation types, input conditions and output conditions. Task edges record the data dependency relationships between production nodes and consumer nodes. The same task node is a consumer node relative to its direct upstream task node and a production node relative to its direct downstream task node.
[0008] The central agent determines the execution order of task nodes based on the data dependencies. After all the outputs of all necessary direct upstream production nodes of the same consumer node have been generated and verified, the agent collects the production node execution identifier, output content summary, and mode version of each production node to form the input list of the consumer node. A short-term lease is issued for the execution corresponding to the consumer node, and the short-term lease and the input list are sent to the terminal agent. The short-term lease includes the task graph version, consumer node summary, input list summary, sub-agent capability contract version, sub-agent capability contract summary, task constraint description, target terminal identifier, short-term lease validity period, checkpoint identifier, and issuer signature.
[0009] The terminal-side agent verifies short-term leases, including the issuer's signature and the lease's validity period. It checks the target terminal identifier, the local sub-agent capability contract version, and the sub-agent capability contract summary. Based on the received input list, it generates an input list summary and compares it with the input list summary bound to the short-term lease. After all checks pass, the agent schedules the corresponding sub-agent to execute a task in the sub-agent execution pool through the restricted tool interface. After execution is completed and the output verification passes, the agent returns the output content summary and mode version to the central-side agent to generate the input list for its downstream consumer nodes. This process is repeated to achieve the execution of each task node in the task graph.
[0010] When the sub-agent capability contract, task node input, or preconditions change, the affected nodes are identified along the dependencies of the task graph, the short-term leases associated with their incomplete execution are revoked, the validity of the inputs and outputs and the postconditions of the completed task nodes are reviewed, the completed task results that have passed the review are retained as the boundary inputs of the residual task graph, the affected incomplete task nodes and the task nodes corresponding to the unreusable results are rearranged, and new short-term leases are issued according to the new input list.
[0011] Secondly, the present invention provides a hierarchical intelligent agent constrained orchestration system for user security needs, including a security requirement compilation module, a capability contract catalog module, a task graph generation module, a short-term lease module, a central-side intelligent agent, a terminal-side intelligent agent, a sub-intelligent agent execution pool, a state ledger module, and a residual task re-orchestration module; the modules are configured to execute the aforementioned method.
[0012] The hierarchical intelligent agent constrained orchestration method and system provided by this invention, which addresses user security needs, has the following advantages:
[0013] This invention binds the actual upstream output to the consumption execution lease, enabling the terminal to identify input replacements or erroneous versions before invocation and preventing the consumption of unauthorized data under old leases. By separately validating tools, permissions, object scope, and field scope, it limits the scope expansion caused by natural language parsing errors and additional calls from sub-agents. Through execution state claiming and result verification, it reduces repetitive operations caused by retries. By saving verified boundary results, valid signature verification results can continue to be used when network acquisition fails, reducing unnecessary redundant calculations. When the input range changes, related results are invalidated, avoiding the reuse of expired results to pursue faster recovery. Attached Figure Description
[0014] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.
[0015] Figure 1 This is a structural diagram of the hierarchical intelligent agent constrained orchestration system for user security needs provided by the present invention. Detailed Implementation
[0016] To make the technical problems solved, the technical solutions, and the beneficial effects of this invention clearer, the invention will be further described in detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and are not intended to limit the invention.
[0017] This invention employs an input list-based authorization mechanism. The central side is responsible for demand transformation, capability matching, and lease issuance; the terminal side is responsible for actual input verification and resource and tool call control; and sub-agents are responsible for specific detection or handling operations. Downstream leases are issued only after the upstream completes and verifies the output, ensuring that the authorized object includes the actual input. During anomaly recovery, the same input list and checkpoints are used to verify the completion result and determine whether continued use is warranted. This association permeates task formation, scheduling, and re-arrangement.
[0018] The main idea of this invention is to compile the security requirements submitted by users in natural language or structured forms into task constraint expressions, and to perform constrained orchestration among central-side agents, terminal-side agents and multiple sub-agents based on capability contracts, short-term leases and residual task graphs.
[0019] See Figure 1 The present invention provides a hierarchical intelligent agent constrained orchestration method for user security needs, comprising:
[0020] Step S1: The central agent obtains the security requirements submitted by the user and converts them into a task constraint description. Based on the task constraint description and the capability contract of the sub-agent, a task graph containing task nodes and task edges is generated. Among them, the task node records the operation type, input conditions and output conditions. The task edge records the data dependency relationship between the producer node and the consumer node. The same task node is a consumer node relative to its direct upstream task node and a producer node relative to its direct downstream task node.
[0021] In this step, the security requirements submitted by the user can be either natural language or structured security requirements. Therefore, the compilation module of the central agent converts the natural language input into a set of candidate fields; structured security requirements can be structured security forms, which are directly entered into field validation. The field validation method is as follows: validation is performed using defined field types, operation directories, and permission rules. Each field saves the corresponding original statement fragment and parsing status, facilitating targeted supplementation of missing or ambiguous values.
[0022] For example, a user submits a request to "check unsigned programs started by R&D terminal group A in the past 24 hours, find programs accessing destination addresses outside the company's address range, output only file digests and destination addresses, without isolation or termination." The compilation module resolves the target group to a group identifier in the asset catalog, converts relative time to fixed start and end times, and resolves "unsigned" to a signature verification result equal to "Unsigned." The "Unknown" status, where the signature cannot be verified, is reported separately and is not directly equivalent to "Unsigned." The company address range is taken from the authorized network segment set and version, and cannot be guessed by the model.
[0023] The task constraint description includes allowed actions, prohibited actions, target asset scope, allowed data access scope, resource budget, and acceptance criteria.
[0024] As one implementation method, security requirements are converted into task constraint descriptions in the following way:
[0025] The system maps the detection objects, detection time ranges, filtering conditions, association conditions, and output fields in the security requirements to preset field types to generate candidate task constraint descriptions. Based on the correspondence between operation types and required permissions, it filters candidate actions that simultaneously satisfy user authorization and terminal policies, and excludes prohibited actions. For descriptions with unclear object scope, mismatched field types, or conflicts between allowed and prohibited actions, it returns fields to be supplemented and suspends the affected tasks. Actions that do not meet the capability contract are marked as non-executable.
[0026] In this step, the sub-agent capability contract includes the sub-agent identifier, the tool interface and version used by the sub-agent, the input / output mode, the action type, the permission set, the range of data that can be accessed, the validity period, and the issuer's signature.
[0027] Sub-agent capability contracts are expressed through a capability contract catalog. When building a task graph, the sub-agent capabilities need to be matched based on the task constraint description and the sub-agent capability contracts. One approach is to use a capability contract catalog to search for tools by operation type and input / output mode, verifying the issuer's signature, validity period, and tool version. The file signature verification tool declares that the input is a file stability identifier and content digest, and the output is the signature status, signer, and error code. The network query tool declares that the input is a process instance identifier and time range, and the output is connection records. The contract description tool defines the scope of its execution.
[0028] When building the task graph, set a mutex lock for task nodes with mutually exclusive actions for the same target object; set a serial dependency for task nodes whose action risk level exceeds a preset threshold; and set a manual confirmation requirement for task nodes that must be manually confirmed according to the authorization policy.
[0029] In this invention, the task graph is a directed acyclic graph. When a circular dependency is detected, the task graph is refused to be generated and the associated node is returned.
[0030] Step S2: The central agent determines the execution order of task nodes based on the data dependency relationship; after all the outputs of all necessary direct upstream production nodes of the same consumer node have been generated and verified, the production node execution identifier, output content summary and mode version of each production node are collected to form the input list of the consumer node.
[0031] The input list is sorted by task edge identifier and includes the corresponding task edge identifier, production node identifier, production node execution identifier, output content summary, mode version and snapshot identifier; the input list may also include restricted data reference or source version. Before calling, the terminal side relocates the data through restricted data reference, recalculates the content summary and compares it with the lease summary.
[0032] A short-term lease is issued for the execution corresponding to the consumer node, and the short-term lease and the input list are sent to the terminal-side intelligent agent. The short-term lease includes a task graph version, a consumer node summary, an input list summary, a sub-agent capability contract version, a sub-agent capability contract summary, a task constraint description, a target terminal identifier, a short-term lease validity period, a checkpoint identifier, and an issuer signature. The short-term lease also carries a unique lease identifier, a revocation generation, a list of allowed tools, and a set of operation permissions.
[0033] For root task nodes without incoming edges, the confirmed task constraint description and target asset snapshot are output as virtual entry nodes to generate the input list of the root task node and issue short-term leases; the signature covers the fields bound to the lease, and the summary is generated according to the preset normalized encoding rules.
[0034] For example, the nodes in the task graph include asset parsing node N0, process acquisition node N1, signature verification node N2, network acquisition node N3, and associated output node N4. N0 provides the target asset and time snapshot to N1; N1 provides process instances and file references to N2 and N3; the outputs of N2 and N3 converge at N4. N2 and N3 can run in parallel if the total budget allows, while N4 must wait for the two required inputs to complete.
[0035] Task nodes record operation type, versioning parameters, target selection conditions, required permissions, input / output modes, and preconditions and postconditions. During the orchestration phase, task edges record producers, consumers, and field mappings. Nodes that have not yet been executed do not have a real output content summary; only after the output is validated and persisted are the ledger filled with the output content summary, producer node execution identifier, and data snapshot identifier.
[0036] Multiple input nodes sort their input items according to task edge identifiers, forming an input list. Each item records the production node, execution identifier, output digest, mode version, snapshot, and validity period. Node digests are generated according to a fixed field order, UTF-8 encoding, and uniform null value representation; the input list digests are generated using the same rules. The digest is used to detect content differences; its authenticity is further guaranteed by the signature and trusted storage source. In practice, SHA-256 can be used, and the algorithm version should be included when switching digest algorithms.
[0037] The central server issues short-term leases after all required inputs have passed validation. Each task edge is associated with a lease identifier for the same consumption execution, and the consumption execution is bound to a complete input list to avoid verifying only one input. The lease includes the task graph version, node summary, input list summary, target terminal, capability contract summary, tool list, permissions, asset and data scope, budget, checkpoints, lease identifier, revocation generation, and validity period, and is signed by the authorization service. The signing key is not given to the sub-agents.
[0038] When the root task has no upstream execution results, a virtual entry point is constructed using confirmed requirements and a snapshot of the target asset; pure sequential dependency edges reference the digest of the preceding completion receipt. Downstream tasks must not use predicted output or empty digests to replace real inputs to obtain execution authorization. Checkpoint identifiers point to the initial state on the first execution and to a verified persistent checkpoint on the resumption of execution.
[0039] Step S3: The terminal-side agent verifies the short-term lease, including its issuer signature and the short-term lease validity period, checks the target terminal identifier, the local sub-agent capability contract version, and the sub-agent capability contract summary, and generates an input list summary based on the received input list, which is compared with the input list summary bound to the short-term lease. After all checks pass, the corresponding sub-agent is matched in the sub-agent execution pool through the restricted tool interface to execute the task. After the execution is completed and the output verification passes, the output content summary and mode version are returned to the central-side agent to generate the input list of its downstream consumer nodes. This process is repeated to realize the execution of each task node in the task graph.
[0040] In this step, the terminal-side intelligent agent verifies the short-term lease, specifically including: the terminal-side intelligent agent verifies that the operation permission is included in the lease permission set, the tool interface belongs to the allowed tool list, the target asset belongs to the target asset range, and the accessed object, field and access method meet the data range limited by the lease, and reserves execution quota within the resource budget; when all conditions are met and the lease has not expired or been revoked, the agent claims the execution through atomic state update of the state ledger, and each subsequent tool call is reviewed by the restricted tool interface for its operation and parameters;
[0041] After a sub-agent completes its task, it generates an execution receipt. The execution receipt includes the task graph version, task node identifier, lease identifier, execution identifier, input list summary, output summary, execution status, resource usage, error code, checkpoint, and post-verification results. The output is used as the input for downstream task nodes after being verified for mode, integrity, and acceptance conditions. When the lease expires or is revoked, new tool calls are stopped, and the actual status of calls that have been issued is recorded. The same status change operation shall not be reassigned before the result is determined.
[0042] As one example, the terminal-side intelligent agent receives the lease and performs verification. Specifically, the terminal-side intelligent agent reads the actual tool version, current asset identifier, and input list, verifies the issuer's signature, term, revocation code, and various summaries; then it checks the tool, permissions, assets, data fields, and budget respectively. Once all are satisfied, it updates the corresponding execution from ready to running through an atomic ledger update and obtains the occupancy record for this execution.
[0043] Sub-agents can only be invoked via restricted tool interfaces on the terminal side. The interface converts the structured operations and field rules in the lease into parameter validation, rejecting additional targets, out-of-bounds times, and disallowed fields. The running account only has the necessary permissions for its current node and does not provide an unrestricted command interpreter entry point. When reading files, it verifies the stable file identifier and content digest; if these changes, it returns an invalid input. Network association uses process instance identifiers and startup times to avoid misassociations caused by process ID reuse.
[0044] Resource budgets have clearly defined measurement ranges. In this example, the cumulative CPU time per terminal for this task can be limited to 30 seconds, concurrent working set to 256MB, log entries to 100,000, and wall clock duration to 120 seconds; these values are for illustrative purposes only. The terminal scheduler reserves a quota before starting parallel nodes, and usage is calculated by the tool adapter or operating system resource control interface during execution. When the budget is exhausted, a recoverable cursor is saved and the process returns to an incomplete state; partial results after interruption of read-only queries are not reported as fully completed.
[0045] For nodes undergoing state changes, mutual exclusion records are established based on terminal identifiers and stable object identifiers, and obtained using atomic operations; the conflict matrix stipulates that isolation and recovery operations cannot be performed simultaneously. High-risk nodes add a manual confirmation dependency, with confirmation records bound to the node digest and input version. Serial processing only resolves sequence conflicts and cannot replace authorization.
[0046] After the tool returns, it generates an execution receipt, verifies the output mode, content summary, coverage, and acceptance predicate in the ledger, and then marks the node as verified as completed. If the call return code is zero and the output fields are missing or incomplete, it is not marked as completed. Checkpoints save the input list summary, capability version, processed range, recovery cursor, and output position; these records must be written to disk before they can be used as the basis for recovery.
[0047] Step S4: Process the changes and generate the residual task graph:
[0048] When the sub-agent capability contract, task node input, or preconditions change, the affected nodes are identified along the dependencies of the task graph, the short-term leases associated with their incomplete execution are revoked, the validity of the inputs and outputs and the postconditions of the completed task nodes are reviewed, the completed task results that have passed the review are retained as the boundary inputs of the residual task graph, the affected incomplete task nodes and the task nodes corresponding to the unreusable results are rearranged, and new short-term leases are issued according to the new input list.
[0049] For completed task nodes, they are only retained if their input list and snapshot have not changed, their output content has not expired, and their postconditions are still met. The residual task graph uses the execution result of the completed task node through read-only boundary references, without re-executing the corresponding task node. Execution completion results that cannot be reused and their affected downstream task nodes re-enter the pending evaluation state. Before re-orchestration, old leases of task nodes are revoked and execution stop receipts are awaited, or task nodes with unclear results are placed in the pending verification state to prevent new and old executions from being used on the same object.
[0050] As an example, when the terminal detects input failure, capability change, or execution interruption, it records the changed object, corresponding version, and failed node. The central agent then searches for the affected consumer nodes along the data dependencies. Insufficient resources only affect incomplete executions; changes in input content simultaneously cause completed results that depend on that input to enter the review process. All completed nodes cannot be directly frozen.
[0051] The central server first elevates the undo order of the affected execution and issues an undo record. The terminal rejects new calls at the old order, cancels ongoing cancelable call requests, and returns to a stopped state and last checkpoint; if the stop or operation cannot be confirmed as effective, it is marked as pending verification. Before receiving a verifiable stop or completion confirmation, no new state change operation for the same object is reassigned. During the period of disconnection, local expiration checks prevent new calls, and already issued calls must have their results verified individually.
[0052] When reviewing the completion results, the input list and snapshot, capability compatibility rules, output validity period, and current postconditions are compared. Results that pass the review become read-only boundary references, retaining the production execution identifier and output summary; the corresponding compute nodes are no longer executed. Results that fail are not used as input for new graphs, and their production nodes and affected consumers are rearranged. Status changes that have already taken effect cannot be directly redone due to invalid results; the status must be confirmed first, and then subsequent actions are determined according to compensation or manual processing rules.
[0053] The residual task graph records the original graph version, a list of boundaries for retained results, new nodes, and new input relationships. New leases are issued when the new node summary or input summary changes; the recovery cursor is only used when the input snapshot and tool version are compatible. During retries, the ledger uses execution identifiers to deduplicate receipts and business operation idempotency identifiers to identify state changes; blind retries are prohibited when idempotent interfaces are unavailable and results are unclear.
[0054] In this example, after N2 completes, N3 times out reading the network log. If N1 uses a still accessible fixed log snapshot, and the N2 file digest and signature results are not invalid, then the results of N1 and N2 are retained, the old leases for N3 and N4 are revoked, only N3 is restored, and the N4 input list is rebuilt. If the user extends the observation period from the past 24 hours to 48 hours, a new requirement and graph version are formed. The N1 output no longer covers the new range, and N2, N3, and N4, which depend on this range, need to be re-evaluated and cannot use the original completion status.
[0055] If an upgrade of the tools used by N3 causes a change in the output mode, the central side checks whether N4 has compatible conversion capabilities. If a conversion operation that has passed contract verification exists, a conversion node is added and reauthorization is performed; otherwise, the capability is not met. Regardless of the recovery method chosen, the original execution record is retained, and failures are not hidden by overwriting the log.
[0056] It may further include: step S5, result output.
[0057] Results are summarized according to the user-confirmed output mode. In this embodiment, each hit record is supported by unsigned determination evidence and company-wide out-of-company connection evidence of the same process instance; if a historical signature cannot be obtained or the file has changed, an inability to confirm is reported, and the current file state cannot be used to impersonate a past state. Each target terminal provides a completed, partially completed, or unavailable status.
[0058] The present invention also provides a hierarchical intelligent agent constrained orchestration system for user security needs, including a security requirement compilation module, a capability contract catalog module, a task graph generation module, a short-term lease module, a central-side intelligent agent, a terminal-side intelligent agent, a sub-intelligent agent execution pool, a state ledger module, and a residual task re-orchestration module.
[0059] This invention binds the actual upstream output to the consumption execution lease, enabling the terminal to identify input replacements or incorrect versions before invocation and prevent the consumption of unauthorized data under old leases.
[0060] By validating tools, permissions, object scope, and field scope separately, the scope expansion caused by natural language parsing errors and additional calls from sub-agents is limited; by performing state claiming and result verification, repetitive operations caused by retries are reduced.
[0061] By saving the verified boundary results, valid signature verification results can continue to be used when network acquisition fails, reducing unnecessary duplicate calculations; when the input range changes, the relevant results become invalid, avoiding the reuse of expired results in pursuit of recovery speed.
[0062] The above description is only a preferred embodiment of the present invention. It should be noted that for those skilled in the art, several improvements and modifications can be made without departing from the principle of the present invention, and these improvements and modifications should also be considered within the scope of protection of the present invention.
Claims
1. A layered intelligent agent constrained orchestration method oriented towards user security needs, characterized in that, include: The central agent obtains the security requirements submitted by the user and converts them into task constraint descriptions. A task graph containing task nodes and task edges is generated based on the task constraint description and the sub-agent capability contract. The task nodes record the operation type, input conditions, and output conditions. The task edges record the data dependency relationship between the producer node and the consumer node. The same task node is a consumer node relative to its direct upstream task node and a producer node relative to its direct downstream task node. The central agent determines the execution order of task nodes based on the data dependencies. After all the outputs of all necessary direct upstream production nodes of the same consumer node have been generated and verified, the agent collects the production node execution identifier, output content summary, and mode version of each production node to form the input list of the consumer node. A short-term lease is issued for the execution corresponding to the consumer node, and the short-term lease and the input list are sent to the terminal agent. The short-term lease includes the task graph version, consumer node summary, input list summary, sub-agent capability contract version, sub-agent capability contract summary, task constraint description, target terminal identifier, short-term lease validity period, checkpoint identifier, and issuer signature. The terminal-side agent verifies short-term leases, including the issuer's signature and the lease's validity period. It checks the target terminal identifier, the local sub-agent capability contract version, and the sub-agent capability contract summary. Based on the received input list, it generates an input list summary and compares it with the input list summary bound to the short-term lease. After all checks pass, the agent schedules the corresponding sub-agent to execute a task in the sub-agent execution pool through the restricted tool interface. After execution is completed and the output verification passes, the agent returns the output content summary and mode version to the central-side agent to generate the input list for its downstream consumer nodes. This process is repeated to achieve the execution of each task node in the task graph. When the sub-agent capability contract, task node input, or preconditions change, the affected nodes are identified along the dependencies of the task graph, the short-term leases associated with their incomplete execution are revoked, the validity of the inputs and outputs and the postconditions of the completed task nodes are reviewed, the completed task results that have passed the review are retained as the boundary inputs of the residual task graph, the affected incomplete task nodes and the task nodes corresponding to the unreusable results are rearranged, and new short-term leases are issued according to the new input list.
2. The hierarchical intelligent agent constrained orchestration method for user security needs according to claim 1, characterized in that, The security requirements submitted by the user can be in natural language or structured language.
3. The hierarchical intelligent agent constrained orchestration method for user security needs according to claim 1, characterized in that, The task constraint description includes allowed actions, prohibited actions, target asset scope, allowed data access scope, resource budget, and acceptance criteria.
4. The hierarchical intelligent agent constrained orchestration method for user security needs according to claim 1, characterized in that, The way to translate security requirements into task constraint descriptions is as follows: The system maps the detection objects, detection time ranges, filtering conditions, association conditions, and output fields in the security requirements to preset field types to generate candidate task constraint descriptions. Based on the correspondence between operation types and required permissions, it filters candidate actions that simultaneously satisfy user authorization and terminal policies, and excludes prohibited actions. For descriptions with unclear object scope, mismatched field types, or conflicts between allowed and prohibited actions, it returns fields to be supplemented and suspends the affected tasks. Actions that do not meet the capability contract are marked as non-executable.
5. The hierarchical intelligent agent constrained orchestration method for user security needs according to claim 1, characterized in that, The sub-agent capability contract includes the sub-agent identifier, the tool interface and version used by the sub-agent, the input / output mode, the action type, the permission set, the range of data that can be accessed, the validity period, and the issuer's signature.
6. The hierarchical intelligent agent constrained orchestration method for user security needs according to claim 1, characterized in that, Set a mutex lock for task nodes with mutually exclusive actions on the same target object; set a serial dependency for task nodes whose action risk level exceeds a preset threshold; and set a manual confirmation requirement for task nodes that must be manually confirmed according to the authorization policy.
7. The hierarchical intelligent agent constrained orchestration method for user security needs according to claim 1, characterized in that, The input list is sorted by task edge identifier and includes the corresponding task edge identifier, production node identifier, production node execution identifier, output content summary, mode version, and snapshot identifier. The short-term lease also carries a unique lease identifier, revocation generation, list of allowed tools, and set of operation permissions. For root task nodes without incoming edges, the confirmed task constraint description and target asset snapshot are output as virtual entry nodes to generate the input list of the root task node and issue a short-term lease. The signature covers the fields bound to the lease, and the summary is generated according to the preset normalized encoding rules.
8. The hierarchical intelligent agent constrained orchestration method for user security needs according to claim 7, characterized in that, The terminal-side intelligent agent verifies short-term leases, specifically including: the terminal-side intelligent agent verifies that the operation permissions are included in the lease permission set, the tool interface belongs to the allowed tool list, the target asset belongs to the target asset scope, and the accessed objects, fields, and access methods meet the data scope limited by the lease, and reserves execution quota within the resource budget; when all conditions are met and the lease has not expired or been revoked, the agent claims the execution through atomic state update of the state ledger, and each subsequent tool call is reviewed by the restricted tool interface for its operation and parameters; The execution receipt includes the task graph version, task node identifier, lease identifier, execution identifier, input list summary, output summary, execution status, resource usage, error code, checkpoint, and post-validation results. The output is used as the input for downstream task nodes after being validated for mode, integrity, and acceptance conditions. New tool calls are stopped when the lease expires or is revoked. The actual status of the calls that have been issued is recorded, and the same status change operation shall not be reassigned before the result is determined.
9. The hierarchical intelligent agent constrained orchestration method for user security needs according to claim 1, characterized in that, Also includes: For completed task nodes, they are retained only if their input list and snapshot have not changed, their output content has not expired, and their postconditions are still met. The residual task graph uses the execution result of the completed task node through read-only boundary references, without re-executing the corresponding task node; the execution completion result that cannot be reused and its affected downstream task nodes re-enter the pending evaluation state; before reordering, the old lease of the task node is revoked and the execution stop receipt is awaited, or the task node with unclear result is placed in the pending verification state to prevent the old and new executions from being used on the same object.
10. A hierarchical intelligent agent constrained orchestration system oriented towards user security needs, characterized in that, It includes a security requirements compilation module, a capability contract catalog module, a task graph generation module, a short-term lease module, a central-side intelligent agent, a terminal-side intelligent agent, a sub-intelligent agent execution pool, a state ledger module, and a residual task reordering module; the modules are configured to perform the method described in any one of claims 1 to 9.
