An audit-based multi-agent collaborative reasoning method and system

Abstract

The application provides an audit multi-agent collaborative reasoning method and system; by constructing a knowledge graph fusing fact triplets and counter-evidence anchor points, an audit problem is mapped to an activated anchor point, a directed acyclic graph of atomic sub-tasks is generated through constraint propagation, and agents are dynamically bound to each sub-task based on a logic consistency score; for controversial sub-tasks, a three-agent debate game is started, a reliable conclusion is obtained through multiple rounds of evidence presentation, cross-examination and adjudication, during the execution process, a causal imprint chain based on data fingerprints is constructed, full traceability and abnormal self-healing are realized, and finally a structured audit report with complete evidence chain and debate record is output, the audit reasoning is reconstructed from forward search to reverse verification, and the explainability, reliability and audit efficiency are significantly improved.

Description

Technical Field

[0001] This invention relates to the field of auditing technology, specifically to a method and system for multi-agent collaborative reasoning in auditing. Background Technology

[0002] With the rapid development of the digital economy and the continuous improvement of enterprise informatization, the audit targets are shifting from traditional paper vouchers and financial statements to massive, multi-source, and heterogeneous electronic data. The widespread application of information systems such as Enterprise Resource Planning (ERP) systems, procurement management platforms, and financial shared service centers has led to an explosive growth in business data, richer data dimensions, and significantly enhanced data flow. At the same time, increasingly stringent regulatory requirements pose unprecedented challenges to the breadth of coverage, timeliness of response, and depth of problem identification in internal audits. Traditional audit models, primarily based on manual sampling and on-site inspections, are limited by human resources and inspection methods, making it difficult to achieve comprehensive, penetrating supervision of all data, resulting in delayed risk detection and widespread audit blind spots.

[0003] In recent years, the application of artificial intelligence technologies, especially natural language processing, knowledge graphs, and multi-agent systems, in the field of auditing has become increasingly active. Models such as BERT+CRF are used to extract entities and relationships from audit texts, knowledge graphs are used to construct relational networks between audit objects, and multi-agent collaborative technologies are used to decompose and execute complex audit tasks. However, existing technologies still face many limitations: most systems adopt a forward search reasoning paradigm, that is, searching for answer paths from known entities in the knowledge graph. This approach is prone to search space explosion and the conclusions lack interpretability; multi-agent systems often adopt a simple division of labor and cooperation model, lacking mechanisms for cross-validation of different viewpoints and adversarial debate, resulting in insufficient rebuttal of audit conclusions; the reasoning process is difficult to trace throughout, and once anomalies or disputes occur, it is difficult to accurately locate the source of the problem.

[0004] Therefore, how to construct an intelligent audit reasoning method that combines high efficiency, interpretability, argumentation, and traceability has become a technical problem that urgently needs to be solved in this field. Summary of the Invention

[0005] To address the shortcomings of the existing technologies, this invention aims to provide a method and system for collaborative reasoning among multiple agents in auditing, offering a feasible solution for intelligent auditing with interpretability, refutability, and traceability.

[0006] To solve the above problems, the present invention adopts the following technical solution: On one hand, the present invention provides a multi-agent collaborative reasoning method based on auditing, comprising: Based on audit business-related data, triples are extracted to construct an audit knowledge graph, and a TransE graph embedding representation is performed. Construct rebuttal anchor nodes and add them to the audit knowledge graph based on the relationship between the rebuttal anchor nodes and entities in the audit knowledge graph; Based on audit requirements, elements of the audit requirements are extracted, and the comprehensive similarity score between the elements and the triggering conditions of the counter-evidence anchor points is calculated. Based on the comprehensive similarity score, the audit requirement activation anchor points are selected. For each audit requirement, activate the anchor point, parse the atomic constraints in the triggering conditions, and use the atomic constraints as the starting point to propagate backward along the relationships in the audit knowledge graph. Collect the atomic subtasks of the smallest indivisible verification unit, and use the atomic subtasks as nodes to construct a directed acyclic graph based on the data dependencies between the atomic subtasks. For each atomic subtask in the directed acyclic graph, agent matching and task execution are performed. For controversial subtasks in the atomic subtasks, a debate game of prosecutor-defense-adjudication is used to determine whether the corresponding audit requirement activation anchor point is valid or to conduct manual review.

[0007] As one possible implementation, the task execution also includes the construction of a causal imprint chain; The causal imprint chain includes node identifier, atomic subtask identifier, executing agent identifier, input fingerprint, output fingerprint, data flow direction, timestamp, atomic subtask execution result status, and forward hash pointer; The construction of causal imprinting chains includes: Before the execution of the atomic subtask, all input data of the atomic subtask is collected, and the input fingerprint is calculated. The intelligent agent executes atomic subtasks, generates output data, and calculates the output fingerprint; The output data of the atomic subtask is determined based on the directed acyclic graph and is acquired by subsequent atomic subtasks, generating the data flow direction; The input fingerprint, output fingerprint, and data flow are packaged together, and the current timestamp and the execution result status of the atomic subtask are added to form an imprint node. Then, the hash pointer of the imprint node of the previous atomic subtask is obtained, the hash value of the current imprint node is calculated, and the hash value of the current imprint node is used as the identifier of the current imprint node. Imprinted nodes are linked together by forward hash pointers to form a causal imprint chain.

[0008] As one possible implementation, the counter-evidence anchor node includes an anchor identifier, triggering conditions, evidence chain template, rebuttal conditions, and priority weights; The addition of the relationship between the anchor node for counter-evidence and entities in the audit knowledge graph to the audit knowledge graph includes: The rebuttal anchor node is connected to the entity in the audit knowledge graph involved in the triggering condition through the triggering relationship, to the entity in the audit knowledge graph involved in the evidence chain template through the required evidence relationship, and to the entity in the audit knowledge graph involved in the rebuttal condition through the rebuttable relationship.

[0009] As one possible implementation, the anchor point identifier is a globally unique code using a domain-category-serial number encoding method; The triggering condition is a logical expression used to determine whether the current audit object has any suspicious points described by the anchor point; The evidence chain template is a description of the audit knowledge graph nodes and their relationship paths required to verify the doubts described by the anchor point. The rebuttal conditions are the audit knowledge graph nodes and their relationship paths required to negate or weaken the doubts described by the anchor point; The priority weights are numerical values ​​that reflect the risk level, historical hit rate, and current regulatory attention of the anchor point.

[0010] As one possible implementation, the comprehensive similarity score includes a weighted sum of vector similarity, keyword overlap, and domain matching; based on the comparison between the comprehensive similarity score and the activation threshold, audit requirement activation anchors are determined, and the anchors are sorted according to their priority weights.

[0011] As one possible implementation, the agent matching for each atomic subtask in the directed acyclic graph includes: Construct an intelligent agent pool and the capability profiles of each intelligent agent in the pool. The capability profiles include the capability tags of the intelligent agents' proficiency in task types, the historical execution records of the intelligent agents, the inference rule base, and resource consumption. The execution requirements of atomic subtasks are expressed as constraint logic formulas that include preconditions and expected results; The logical consistency score is calculated between the atomic subtasks in the directed acyclic graph and the agents in the agent pool. The logical consistency score is obtained by weighted summation of premise matching score, conclusion matching score and the historical success rate of the agent. For each atomic subtask in the directed acyclic graph, traverse all agents in the agent pool, calculate their logical consistency scores, and select the agent with the highest score as the executing agent for that atomic subtask.

[0012] As one possible implementation, the method of using a prosecutor-defense-adjudication debate game to determine whether the corresponding audit requirement activation anchor point is valid or to conduct manual review for controversial subtasks in atomic subtasks includes: Set up an inspection agent, a defense agent, and a judgment agent; The inspection agent is used to generate or update the evidence chain based on the evidence chain template of currently available data and counter-evidence anchors; The defense agent is used to examine the chain of evidence generated by the inspection agent and to find rebuttal evidence or alternative explanations; The adjudicating agent is used to make a decision on the key issue or issue for the next round of debate based on the complete chain of evidence constructed by the inspecting agent and the rebuttal evidence or alternative explanations found by the defending agent. The key issue for the next round of debate is fed back to the inspecting agent and the defending agent. The process involves one or more rounds of debate and negotiation between the prosecutor, the defense, and the adjudicator, who then makes a final decision, including whether the anchor point is valid, invalid, or requires manual review.

[0013] On the other hand, the present invention provides an audit multi-agent collaborative reasoning system, including an audit knowledge graph construction module, a counter-evidence anchor node addition module, an audit requirement activation anchor filtering module, a directed acyclic graph construction module, and a task execution module; The audit knowledge graph construction module is used to extract triples from audit business-related data to construct an audit knowledge graph and perform TransE graph embedding representation. The rebuttal anchor node adding module is used to construct rebuttal anchor nodes and add them to the audit knowledge graph based on the relationship between the rebuttal anchor nodes and entities in the audit knowledge graph; The audit requirement activation anchor filtering module is used to extract elements of audit requirements based on audit requirements, calculate the comprehensive similarity score between the elements and the triggering conditions of the counter-evidence anchor node, and filter audit requirement activation anchors based on the comprehensive similarity score. The directed acyclic graph construction module is used to activate anchor points for each audit requirement, parse atomic constraints in the triggering conditions, and, starting from the atomic constraints, propagate backward along the relationships in the audit knowledge graph to collect atomic subtasks of the smallest indivisible verification unit. Using the atomic subtasks as nodes, a directed acyclic graph is constructed based on the data dependencies between the atomic subtasks. The task execution module is used to perform agent matching and task execution for each atomic subtask in the directed acyclic graph. For controversial subtasks in the atomic subtasks, a debate game of prosecutor-defense-adjudication is used to determine whether the corresponding audit requirement activation anchor point is valid or to conduct manual review.

[0014] As one possible implementation, a causal imprint chain construction module is also included, used to construct the causal imprint chain during the execution of the task; The causal imprint chain includes node identifier, atomic subtask identifier, executing agent identifier, input fingerprint, output fingerprint, data flow direction, timestamp, atomic subtask execution result status, and forward hash pointer; The construction of causal imprinting chains includes: Before the execution of the atomic subtask, all input data of the atomic subtask is collected, and the input fingerprint is calculated. The intelligent agent executes atomic subtasks, generates output data, and calculates the output fingerprint; The output data of the atomic subtask is determined based on the directed acyclic graph and is acquired by subsequent atomic subtasks, generating the data flow direction; The input fingerprint, output fingerprint, and data flow are packaged together, and the current timestamp and the execution result status of the atomic subtask are added to form an imprint node. Then, the hash pointer of the imprint node of the previous atomic subtask is obtained, the hash value of the current imprint node is calculated, and the hash value of the current imprint node is used as the identifier of the current imprint node. Imprinted nodes are linked together by forward hash pointers to form a causal imprint chain.

[0015] As one possible implementation, the counter-evidence anchor node includes an anchor identifier, triggering conditions, evidence chain template, rebuttal conditions, and priority weights; The addition of the relationship between the anchor node for counter-evidence and entities in the audit knowledge graph to the audit knowledge graph includes: The rebuttal anchor node is connected to the entity in the audit knowledge graph involved in the triggering condition through the triggering relationship, to the entity in the audit knowledge graph involved in the evidence chain template through the required evidence relationship, and to the entity in the audit knowledge graph involved in the rebuttal condition through the rebuttable relationship.

[0016] The beneficial effects of this invention are as follows: By pre-setting rebuttal anchor points and using a debate and game mechanism, each audit conclusion is accompanied by a complete chain of evidence from the original data to the final ruling, records of multiple rounds of debate, and causal imprint citations. Auditors can trace and verify step by step, completely changing the dilemma of the black box output of traditional AI audits.

[0017] The adversarial arguments of the prosecutorial and defense agents, combined with the independent adjudication by the adjudicating agent, effectively suppress the bias of a single model or data source; the causal imprint chain uses hash fingerprints and chain verification, which can accurately detect any data tampering and ensure the authority of the audit conclusions.

[0018] The anchor-driven proof-of-contrast approach restructures reasoning from forward exhaustive search to reverse doubt verification, significantly reducing the search space; the parallel scheduling of atomic subtasks and the dynamic binding mechanism of intelligent agents shorten the audit cycle for high-risk matters. Attached Figure Description

[0019] Figure 1 This is a flowchart of a multi-agent collaborative reasoning method based on auditing.

[0020] Figure 2This is a schematic diagram of a multi-agent collaborative reasoning system based on auditing. Detailed Implementation

[0021] The present invention will be further described in detail below with reference to specific embodiments.

[0022] It should be noted that these embodiments are only used to illustrate the present invention and are not intended to limit the present invention. Simple improvements to the method under the premise of the present invention are all within the scope of protection claimed by the present invention.

[0023] See Figure 1 This is a method for multi-agent collaborative reasoning based on auditing, including: S100. Based on audit business-related data, extract triples to construct an audit knowledge graph and perform TransE graph embedding representation.

[0024] Audit-related data includes: Auditing regulations and legal documents include national auditing standards, industry regulatory provisions, corporate internal audit charters, various management methods, and operational rules. These documents provide the normative basis for audit judgments.

[0025] Historical audit reports and case studies: Reports, working papers, issue confirmation forms, rectification records, etc., generated from past audit projects. These materials contain the judgment logic and experience patterns of audit experts in their actual work.

[0026] Enterprise Business Data Dictionary and System Model: This describes the information model of enterprise resource planning (ERP) systems, financial systems, procurement systems, contract management systems, etc., including data table structures, field meanings, and business master data definitions. This information is used to subsequently translate audit requirements into specific data query operations.

[0027] Extracting triples to construct an audit knowledge graph includes: First, the BERT+CRF model is used to extract entities and relationships from the unstructured text. BERT, as a pre-trained language model, can deeply understand contextual semantics and has good recognition capabilities for technical terms in audit texts (such as "goodwill impairment test," "related party transactions," and "internal control deficiencies"). The CRF (Conditional Random Field) layer, based on the BERT output, performs global optimization on the label sequence to ensure that the extracted entity boundaries are continuous and logical, avoiding errors such as "half-entities" or "entities spanning multiple sentences."

[0028] The extracted entity types include, but are not limited to: Main entities: auditee, department, supplier, customer, employee; Object-related entities: contracts, invoices, orders, warehouse receipts, payment vouchers, assets; Attribute-based entities: Amount, Quantity, Date, Status, Ratio; Rule-related entities: rules and regulations, control points, and risk indicators.

[0029] The types of relations extracted include, but are not limited to: Transactional relationships: payment, procurement, sales, approval, acceptance; Attribution: belonging to, holding, being responsible for, managing; Constraint relationships: greater than, less than, equal to, contain, exclude; Causal relationship: causing, triggering, preventing, alleviating.

[0030] In addition, numerical constraints (such as "the prepayment amount shall not exceed 30% of the contract amount") and time window constraints (such as "payment shall be completed within 30 days after the invoice is issued") are extracted from the business data dictionary and stored in the graph as a special form of relationship.

[0031] All extraction results are stored in the graph database as triples (head entity, relation, tail entity), with metadata attached to each triple, including source document identifier, extraction confidence, timestamp, etc.

[0032] TransE graph embedding representation includes: To support subsequent semantic similarity calculations and pattern matching, the TransE model is used to vectorize entities and relations in the knowledge graph. The basic idea of ​​TransE is to map each entity to a point in a low-dimensional vector space and each relation to a translation vector within that space. For a correct fact triple (head entity, relation, tail entity), the sum of the head entity vector and the relation vector should approximately equal the tail entity vector; for incorrect triples, this equality does not hold. In this way, TransE encodes the semantic associations between entities as geometric relations in the vector space, ensuring that similar entities are close to each other in the vector space, and pairs of entities with the same relation type exhibit similar translation patterns.

[0033] In auditing scenarios, this property of TransE has special value: for example, although "overdue prepayments" and "overdue accounts receivable" are different in wording, they may have similar translation patterns in the vector space, thus supporting the generalization of risk patterns across domains. When training TransE, this scheme, in addition to using extracted fact triples, also introduces constraints from the proof-of-contrast anchors as additional training signals, enabling the vector space to better reflect the "normal" and "abnormal" boundaries in auditing logic.

[0034] S200. Construct rebuttal anchor nodes and add them to the audit knowledge graph based on the relationship between the rebuttal anchor nodes and entities in the audit knowledge graph.

[0035] The anchor nodes for proof by contradiction include: Anchor points are identified by a globally unique code using a domain-category-serial number encoding method. This globally unique code is used for indexing and referencing within the system. For example, "FIN-PREPAY-001" represents the first counter-evidence anchor point in the prepayment category of the financial domain.

[0036] Triggering conditions are logical expressions used to determine whether the current audit object contains the suspicious points described by the anchor point. Triggering conditions are typically composed of multiple atomic conditions combined using logical operators (AND, OR, NOT). Atomic conditions can be numerical comparisons (e.g., "prepayment amount greater than 500,000 yuan"), state matching (e.g., "supplier's active status equals inactive status"), or existence checks (e.g., "the same supplier has no transaction records for three consecutive months"). The semantics of triggering conditions are expressed as first-order predicate logic formulas, facilitating subsequent atomic constraint propagation and automated reasoning.

[0037] The evidence chain template describes the audit knowledge graph nodes and their relationship paths required to confirm the suspicions described by the anchor point. Essentially, the evidence chain template is a subgraph schema that specifies which entities to start from, which relationships to traverse, and which entities to reach in order to form a complete evidence chain. For example, for a suspicion of "false trade," the evidence chain template might include a path like "purchase order → warehouse receipt → payment voucher → supplier → business registration status." Each node in the template can have constraints attached (such as "warehouse receipt date is later than payment date"). The evidence chain template guides the generation of subsequent atomic subtasks and data collection.

[0038] Rebuttal conditions are the audit knowledge graph nodes and their relational paths required to negate or weaken the doubts described by the anchor point. While structurally similar to the evidence chain template, rebuttal conditions point to "legal" and "compliant" interpretation paths. For example, for the doubt of "overdue prepayment not reconciled," rebuttal conditions might include "the existence of subsequent receiving slips with receiving dates within 30 days of payment" or "the existence of a deferred payment agreement signed by both parties." The introduction of rebuttal conditions forms the basis of the debate game mechanism, providing pre-set rebuttal evidence for the defense agent, rather than relying on the model to generate it automatically.

[0039] The priority weight is a value that reflects the risk level, historical hit rate and current regulatory attention of the anchor point; it is a value between zero and one. The priority weight is used to determine which anchor points to verify first when resources are limited, and to affect the initial confidence setting of the decision-making agent in debate games.

[0040] The following elements are added to the audit knowledge graph based on the relationship between the anchor nodes for rebuttal and entities in the audit knowledge graph: The rebuttal anchor node is connected to the entity in the audit knowledge graph involved in the triggering condition through the triggering relationship, to the entity in the audit knowledge graph involved in the evidence chain template through the required evidence relationship, and to the entity in the audit knowledge graph involved in the rebuttal condition through the rebuttable relationship.

[0041] When a counter-evidence anchor is activated subsequently, the data type to be collected and the verification logic to be executed can be quickly located by following the special relationship between these counter-evidence anchors and the entity, thereby realizing the transformation from the traditional model of data to conclusion to the reverse model of doubt to evidence.

[0042] S300. Based on audit requirements, extract elements of audit requirements, calculate the comprehensive similarity score between the elements and the triggering conditions of the counter-evidence anchor nodes, and select audit requirement activation anchors based on the comprehensive similarity score.

[0043] The system automatically converts user-input natural language audit requests or audit requirements from the annual audit plan into a set of executable verification tasks. It establishes a mapping from audit issues to disproven anchors and generates a directed acyclic graph of atomic subtasks based on this mapping using atomic constraints. Specifically, this includes: User-inputted audit requests can take various forms: they can be natural language questions (such as "Please check whether Company A made large advance payments to inactive suppliers in 2024") or structured audit plan items (such as "Special audit on advance payment management"). This step first performs semantic parsing on these inputs.

[0044] Semantic parsing employs a two-stage strategy. The first stage is element extraction, which uses a lightweight named entity recognition model to extract key elements from the input, including: audit object (e.g., "Company A"), time range (e.g., "2024"), business area (e.g., "prepayment"), and risk type (e.g., "inactive supplier"). The second stage is anchor matching, which performs a comprehensive similarity calculation between the extracted elements and the triggering conditions of each constructed counter-evidence anchor.

[0045] Considering all similarity factors: Vector similarity: Vectorize the element representation of the audit requirement with the logical expression of the anchor trigger condition of the counter-evidence (by encoding the syntax tree of the logical expression) and calculate the cosine similarity.

[0046] Keyword overlap: The number of common keywords between the technical terms appearing in the audit requirements and the keywords in the anchor description of the counter-evidence.

[0047] Domain matching: Matching the domain labels specified in the audit requirements with the domain classification of the counter-evidence anchors.

[0048] The three similarity scores are weighted and summed to obtain a comprehensive similarity score. An activation threshold is set, and all anchors with scores exceeding this threshold are included in the activated anchor set. If no anchor is activated, manual intervention or downgrading is triggered. For multiple anchors with high scores, they are sorted from highest to lowest priority weight, and high-priority anchors are processed first during subsequent verification.

[0049] S400. For each audit requirement, activate the anchor point, parse the atomic constraints in the triggering conditions, and use the atomic constraints as the starting point to propagate backward along the relationships in the audit knowledge graph. Collect the atomic subtasks of the smallest indivisible verification unit, and use the atomic subtasks as nodes to construct a directed acyclic graph based on the data dependencies between the atomic subtasks.

[0050] For each activated proof-of-contrast anchor, resolve the atomic constraints in its triggering condition. An atomic constraint is the smallest indivisible unit of judgment, for example: Numerical constraint: Prepayment amount > 500,000 (unit: yuan); State constraint: supplier.activestate = 'inactive'; Existence constraint: Inbound Order (Inbound Order.Related Prepayment = Prepayment.Number); Timing constraint: Prepayment date > Contract signing date + 30 days.

[0051] Each atomic constraint is expressed as a formal logical predicate, containing the constraint type, comparison operator, left and right operands, and the data type of the operands. For constraints involving time windows or monetary thresholds, their boundary values ​​and units are also recorded.

[0052] In traditional methods, constraints are typically used for forward filtering, which involves imposing conditions on existing data to filter records. This approach starts with atomic constraints and propagates backward along the relationships in the audit knowledge graph to generate data collection requirements—atomic subtasks.

[0053] Backpropagation follows these rules: For numerical constraints, if the operand points to an entity attribute, the propagation requirement is "the value of this attribute of the entity needs to be retrieved". During the propagation process, the source system, field name, and access permissions of the attribute are recorded simultaneously.

[0054] For state constraints, if the state is calculated based on attributes of other entities, then the propagation extends to those underlying attributes. For example, "Supplier activity status" might be a derived state calculated based on "transaction amount in the last twelve months" and "date of the most recent transaction," so the propagation would break the constraint down into requirements for collecting transaction amount and transaction date.

[0055] For existence constraints, the propagation requirement is "to query whether a relational chain that satisfies the condition exists". The system generates a graph query pattern based on the path defined in the evidence chain template.

[0056] During the propagation process, the system simultaneously detects closed-loop dependencies. A closed-loop dependency refers to two or more constraints that depend on each other, forming a cycle. For example, determining whether "revenue has been inflated" requires knowing the "ending accounts receivable balance," while calculating the "ending accounts receivable balance" depends on "current period sales revenue" and "current period cash collection amount," with "current period sales revenue" being the target to be determined. This type of closed loop is very common in audit reasoning. This solution identifies closed loops by constructing a constraint dependency graph and marks the constraint groups within the closed loop as cyclic constraint groups. These are then transformed into cyclic atomic subtasks with attached iteration termination conditions (such as "the number of iterations does not exceed the maximum value" or "the difference between the results of two adjacent iterations is less than a threshold").

[0057] After backpropagation, each indivisible smallest verification unit is defined as an atomic subtask. The design of atomic subtasks follows the "single responsibility" principle: each subtask performs only one type of operation, and its input and output are explicit.

[0058] Atomic subtasks are classified into the following categories according to their operation type: Data Acquisition Subtask: Retrieves data from a specified data source (database, API, file system), possibly with additional filtering conditions and aggregation rules. Its output is a set of records.

[0059] Rule-based decision subtask: Apply hard rules (such as amount comparison, date verification) to the input data and output a Boolean value or enumerated status.

[0060] Logical reasoning subtask: Perform multi-step inference based on input data and domain knowledge, and output reasoning conclusions and supporting evidence.

[0061] Pattern matching subtask: Match the input data with a predefined pattern (such as the evidence chain template in the counter-evidence anchor) and output the matching score and matching position.

[0062] Each atomic subtask is encapsulated as a data structure containing the following fields: subtask identifier, task type, input data specifications (data type, source, optionality), output data specifications, a list of dependent preceding subtasks, loop identifier (if it belongs to a loop constraint group, it also needs to include the iteration variable and termination condition), timeout threshold, and maximum number of retries.

[0063] Based on the data dependencies between atomic subtasks, construct a directed acyclic graph. Each node in the graph represents an atomic subtask, and directed edges indicate the data flow (i.e., the output of one atomic subtask is the input of another).

[0064] The construction process is as follows: Initialize an empty graph and add all atomic subtasks to the node set.

[0065] For each atomic subtask, check if the data referenced in its input data specification was generated by another atomic subtask. If so, add a directed edge from that other atomic subtask to this atomic subtask.

[0066] The system checks if a cycle (i.e., a circular dependency) exists in the graph. If it exists, and the cycle corresponds to a marked group of circular constraints, the cycle is retained and the circular handling mechanism is used in subsequent executions. If it is an unexpected cycle, a design error is triggered, requiring manual intervention to adjust the constraints.

[0067] Perform topological sorting on the directed acyclic graph to obtain the execution order. Simultaneously, identify nodes without incoming edges (i.e., nodes that do not depend on any other subtasks) as starting nodes; these nodes can be executed in parallel.

[0068] Atom subtask groups that can be parallelized: All atom subtasks that have no direct or indirect dependencies can be assigned to different agents for parallel execution.

[0069] S500 performs agent matching and task execution for each atomic subtask in the directed acyclic graph. For controversial subtasks in the atomic subtasks, a debate game of prosecutor-defense-adjudication is used to determine whether the corresponding audit requirement activation anchor point is valid or to conduct manual review.

[0070] For each generated atomic subtask, the most suitable agent is selected from the agent pool. The selection is based not only on the agent's general capabilities but also on the logical consistency between its historical execution record and the constraints of the current subtask. This binding mechanism based on logical reasoning avoids the coarse approach of matching capability keywords commonly found in traditional task scheduling, achieving a more refined and reliable agent allocation.

[0071] Agent matching is performed for each atomic subtask in a directed acyclic graph, including: A pool of intelligent agents is pre-built, containing various types of specialized intelligent agents. Each intelligent agent is an autonomous software entity with the ability to perceive the environment, make autonomous decisions, execute actions, and communicate with other intelligent agents. The specific implementation of the intelligent agents can adopt a method based on a large language model or a traditional method based on a rule engine. This solution does not limit its internal technology, but only focuses on its exposed capability interfaces and historical performance.

[0072] Each agent maintains a capability profile, which contains the following information: Capability Tags: A set of tags describing the types of tasks the agent excels at, such as "structured data query", "natural language document analysis", "numerical calculation and verification", "temporal pattern recognition", and "causal inference".

[0073] Historical execution records: A list that records detailed information about each subtask the agent has executed in the past, including input data summary, output result summary, execution time, success or failure, and user feedback rating.

[0074] Inference rule base: Input-output mapping rules abstracted from historical execution records. Each rule is in the form of "If the input satisfies condition X, then the probability of output Y is P". The rule base is automatically generated through an inductive learning algorithm and is updated regularly.

[0075] Resource consumption: Describes the expected consumption of computing resources (CPU, memory, network bandwidth) when the agent performs different types of tasks.

[0076] The aforementioned reasoning rule base is a formalized summary of its historical behavior. The rule base is constructed using the following methods: For each historical execution record of the agent, the input state vector and output state vector are extracted. The input state vector consists of the statistical characteristics of the input data (such as the number of records, field missing rate, and numerical distribution) and environmental parameters; the output state vector consists of the success or failure of the execution result, the quality indicators of the output data, and the actual execution time.

[0077] Association rule mining algorithms (such as variants of the Apriori algorithm) are used to discover frequently occurring "input pattern-output pattern" pairs from these records. Each rule consists of three parts: Prerequisite pattern: The set of conditions that the input state vector must satisfy; Conclusion Pattern: The set of features that the output state vector will present; Confidence level: The frequency with which a conclusion holds true in a historical record where the premises are met.

[0078] For example, for a data query agent, a rule might be discovered such as: "If the input query involves joins to more than three tables and the data volume exceeds one million rows, then the probability that the execution time exceeds ten seconds is 0.85." This type of rule is subsequently used to determine whether the agent is suitable to execute a certain subtask.

[0079] The inference rule base is not static. Each time the agent performs a new task, the system updates the rule base based on the execution result: if the actual result is consistent with the prediction of an existing rule, the confidence of that rule is increased; if it is inconsistent, the confidence is decreased or a new candidate rule is generated. At the same time, a sliding window mechanism is used to retain only the most recent N execution records (e.g., N=1000), so that the rule base can reflect the latest changes in the agent's capabilities.

[0080] For each atomic subtask, its execution requirements are expressed as a constraint logic expression of a first-order predicate. The structure of the constraint logic expression is: preconditions to expected results.

[0081] The prerequisites consist of the following parts: Input data constraints: Input data must meet requirements regarding type, format, value range, and integrity. For example, for a data acquisition subtask, prerequisites might include "data source is accessible," "query fields exist," and "filter condition syntax is correct."

[0082] Resource constraints: Maximum execution time, maximum memory usage, and allowable network latency allocated to this subtask.

[0083] Environmental constraints: External conditions such as current system time, network status, and number of concurrent tasks.

[0084] The expected result consists of the following parts: Output data specifications: the type, structure, accuracy requirements, and percentage of null values ​​allowed for the output data.

[0085] Quality requirements: lower confidence limit of output results, interpretability requirements (whether the reasoning process needs to be included), and traceability requirements (whether intermediate states need to be recorded).

[0086] Each atomic predicate in a constraint logic expression points to a verifiable property. For example, the predicate "data source is accessible" can be verified by attempting to establish a connection, and "output confidence greater than 0.9" can be verified by comparing it with a historical benchmark.

[0087] For each (subtask, agent) pair, the system calculates a logical consistency score, representing the degree to which the agent satisfies the subtask constraints. The calculation consists of three steps: premise matching, conclusion matching, and overall scoring.

[0088] Premise matching: The premise conditions in the subtask constraint logic are decomposed into atomic predicate sequences. For each rule in the agent's reasoning rule base, its premise pattern is also decomposed into atomic condition sequences. Then, the structural isomorphism between the two sequences is calculated. Structural isomorphism considers not only the one-to-one correspondence of atomic conditions but also whether the logical relationships (AND, OR, NOT) between conditions match. Specifically, a tree edit distance algorithm is used: the logical expression is parsed into a syntax tree, the minimum edit cost (insertion, deletion, replacement of nodes) between the two trees is calculated, and the isomorphism score is obtained after normalization. The maximum isomorphism score for all rules is taken as the premise matching score.

[0089] Conclusion matching: The expected result in the subtask constraint logic is decomposed into a target state vector, with each dimension of the vector corresponding to a quality metric (such as confidence, response time, and data integrity). The conclusion patterns in the agent's reasoning rule base are also decomposed into actual state vectors. The weighted Euclidean distance between the two vectors is calculated; a smaller distance indicates that the agent's historical performance is closer to the subtask requirements. The reciprocal of the distance is mapped to the interval 0 to 1 to obtain the conclusion matching score. The mapping function uses a sigmoid form, ensuring a smooth score change at medium distances and a score approaching the boundary at extreme distances.

[0090] The overall score is calculated by weighting and summing the premise matching score and conclusion matching score with the agent's historical success rate (i.e., the number of successful executions divided by the total number of executions), resulting in a logical consistency score. The weights can be adjusted based on the audit scenario.

[0091] For each atomic subtask, iterate through all agents in the agent pool, calculate their logical consistency scores, and select the agent with the highest score as the executing agent for that subtask.

[0092] If the highest score is still below a preset acceptance threshold (e.g., 0.6), it indicates that no agent can reliably execute the subtask. At this point, the system triggers a degradation process: first, it attempts to further break down the subtask into finer-grained subtasks, and then re-binds agents to the newly generated subtasks; if a suitable agent still cannot be found after the breakdown, the subtask is marked as "requiring manual processing," and the auditor is prompted to intervene in the subsequent audit report.

[0093] For high-risk sub-tasks (such as those involving significant amounts of money or legal consequences), in addition to selecting the primary agent, the system will also select an agent with the second-highest logical consistency score as a backup agent. When the primary agent fails to execute or the confidence level of the output result is insufficient, the system will automatically switch to the backup agent to re-execute.

[0094] This process results in an agent-subtask binding table, with each row containing: subtask identifier, bound primary agent identifier, backup agent identifier (if any), logical consistency score, and binding timestamp. This binding table will serve as the basis for scheduling during execution.

[0095] While executing tasks for each atomic subtask in the directed acyclic graph, a causal imprint chain is also constructed to record the input, output, data flow, and execution status of each atomic subtask. When an anomaly occurs during execution (such as timeout, data inconsistency, or agent crash), the system can trace back to the source of the anomaly along the causal imprint chain and automatically generate alternative solutions for self-healing. This mechanism ensures the continuity and verifiability of the auditing process.

[0096] A causal imprinting chain is essentially a directed, timestamped, hash-pointer-based linked list. Each node in the chain corresponds to an execution instance of an atomic subtask. The imprinting nodes of a causal imprinting chain contain the following fields: node identifier, atomic subtask identifier, executing agent identifier, input fingerprint, output fingerprint, data flow direction, timestamp, atomic subtask execution result status, forward hash pointer, and additional metadata.

[0097] Node identifier: A globally unique UUID used for indexing and referencing.

[0098] Atomic subtask identifier: The identifier of the defined atomic subtask.

[0099] Executing agent identifier: The agent ID that executes this subtask.

[0100] Input fingerprint: A fixed-length string obtained by hashing all input data (including parameters, previous outputs, and configuration information) of the subtask. The hash algorithm used is SHA-256, ensuring a very high probability that different inputs will generate different fingerprints. The calculation of the input fingerprint is completed before the subtask is executed.

[0101] Output fingerprint: A string obtained by hashing all output data generated after the subtask is executed. The output fingerprint is calculated immediately after the subtask is completed.

[0102] Data Flow: A list that records which subsequent subtasks use the output data of this subtask as input. Each flow entry contains the identifier of the successor subtask and the name of the corresponding input parameter in that successor subtask.

[0103] Timestamp: The start and end times of the subtask (accurate to milliseconds).

[0104] Atomic subtask execution result status: Execution result status, including "success", "failure", "timeout", "partial success", "self-healing replacement", etc.

[0105] Forward hash pointer: The hash value of all fields of the previous imprint node, used to link them into a chain.

[0106] Additional metadata: such as execution log summary, exception information, resource consumption statistics, etc.

[0107] Imprinted nodes are linked together via forward hash pointers. Since each node contains a hash of the content of the previous node, any tampering with a historical node will invalidate the hash pointers of all subsequent nodes, thus making it detectable. This design borrows from the immutability principle of blockchain but does not require decentralized consensus, making it suitable for centralized environments for internal enterprise auditing.

[0108] The construction of causal imprinting chains includes: Before the execution of the atomic subtask, all input data of the atomic subtask is collected. For the output of the previous atomic subtask from the directed acyclic graph, the output data of the previous atomic subtask is used. For the data collected from the original data source, the identifier and query conditions of the original data source are recorded, and then the input fingerprint is calculated. The intelligent agent executes atomic subtasks, generates output data, and calculates the output fingerprint; The output data of the atomic subtask is determined based on the directed acyclic graph and is acquired by subsequent atomic subtasks, generating the data flow direction; Pack the input fingerprint, output fingerprint, and data flow direction, add the current timestamp and the execution result status of the atomic subtask to form an imprint node. Then, obtain the hash pointer of the imprint node of the previous atomic subtask (for the first node, the forward pointer is set to all zeros), calculate the hash value of the current imprint node, and use the hash value of the current imprint node as the node identifier of the current imprint node. Imprinted nodes are linked together by forward hash pointers to form a causal imprint chain.

[0109] In addition, the following anomaly types are continuously monitored during the execution of atomic subtasks: Execution timeout: The actual execution time of the atomic subtask exceeds the timeout threshold set in the step.

[0110] Data missing: The output data returned by the agent is empty, or key fields in the output data are missing.

[0111] Format error: The format of the output data does not match the subtask output specification (e.g., JSON was expected but XML was returned).

[0112] Logical contradiction: There is a logical inconsistency between the output data and the input data (e.g., different results are obtained from two queries from the same data source), or the output data conflicts with the constraints in the anchor point of the proof by contradiction.

[0113] Fingerprint mismatch: The input fingerprint of the subsequent subtask fails to match the output fingerprint of the previous subtask, indicating that the data may have been tampered with or damaged during transmission.

[0114] Agent crash: The agent process exits abnormally or returns an unrecoverable error code.

[0115] When any of the above anomalies are detected, the system triggers the exception handling procedure: Determine which subtask the root cause of the anomaly occurred in. This solution uses a causal imprint chain backtracking method for location.

[0116] Assuming in subtask T n An exception was detected during execution (e.g., T). n Input fingerprint and preceding subtask T n-1 (The output fingerprint is inconsistent). The system starts from T. n Starting with the imprint node, traverse backwards along the forward hash pointer, performing the following checks on each predecessor node: Check whether the output fingerprint of this node is consistent with the input fingerprint of the successor node recorded in its data flow.

[0117] Check if the node's status is successful. If the status is not successful, then the node itself is the source of the error.

[0118] Check whether the execution time of this node is within the normal range (based on the statistical distribution established by historical execution records).

[0119] The traversal continues until one of the following occurs: (1) the first node whose state is not successful is found; (2) the first node whose output fingerprint is inconsistent with the subsequent input fingerprint is found; (3) if no anomaly is found after backtracking to the head of the chain, it is determined to be a systemic error (such as a storage system failure). The found node is the source node of the anomaly.

[0120] Once the source node of the anomaly is located, the system extracts the anomaly feature vector of that node. The feature vector includes: the anomaly type (timeout / missing data / format error, etc.), the context in which the anomaly occurred (input data summary, execution time, resource consumption), the relevant data fingerprint, and the rebuttal anchor information associated with the subtask.

[0121] After locating the source of the anomaly, an alternative solution is automatically generated. The generation of the alternative solution follows this strategy: Strategy 1: Data Source Switching. If the anomaly is due to data source inaccessibility (e.g., database connection failure), the system queries the knowledge graph to determine if other data sources (such as backup databases, data warehouses, or offline files) exist with the same data content. The query is based on semantic equivalence (not just technical equivalence). For example, financial data can be obtained from the ERP system's main database or from a daily snapshot table in the data warehouse. If a usable alternative data source is found, the system dynamically generates an alternative subtask to perform the same data acquisition operation using the alternative data source.

[0122] Strategy 2: Agent Replacement. If the anomaly is due to the failure of the bound agent (e.g., a crash or an error return), the system selects the agent with the second-highest logical consistency score from the agent pool as a replacement. If the second-highest score agent is also unavailable, the selection continues downwards until an available agent is found or the list is exhausted.

[0123] Strategy 3: Rule Relaxation. If the anomaly is caused by overly strict rule enforcement that fails to find matching data (e.g., requiring "amount greater than 500,000" but the actual maximum amount is 490,000), the system can automatically relax the constraints and generate an alternative subtask using a more lenient threshold (e.g., "amount greater than 400,000"). The relaxed rule will be marked as "relaxed mode," and auditors will be alerted to this adjustment in the audit report. The relaxation level is dynamically calculated by the system based on historical data distribution, generally not exceeding 20% ​​of the original threshold.

[0124] Strategy 4: Degradation. If the above strategies fail to recover, the system marks the abnormal subtask as "requiring manual handling" and generates a placeholder to replace the subtask, whose output is "awaiting manual confirmation." The audit process continues to execute other branches that do not depend on this subtask to avoid overall blockage.

[0125] After generating alternative subtasks, the system inserts them into the original directed acyclic graph, either replacing the anomalous node or adding them as compensation nodes after the anomalous node. The execution of the alternative subtasks is also recorded in the causal imprint chain and marked as "self-healing alternative" in the status field, while also recording the reason for the alternative and the strategy adopted. This transparent recording method ensures that even if self-healing occurs, the integrity and traceability of the audit process are still guaranteed.

[0126] For controversial subtasks within atomic subtasks, a debate-playing game of prosecutorial-defense-adjudication is employed to determine whether the corresponding audit requirement activation anchor point is valid or requires manual review, including: Based on the risk level of the subtask and the priority weight of the associated counter-evidence anchor, the system divides the subtasks into two categories: Ordinary subtasks: These have low risk levels (e.g., amounts less than a set threshold), clear rules (e.g., pure numerical comparison), and do not involve subjective judgment. These subtasks are executed directly by the bound intelligent agent in a conventional manner, with the results output directly without entering the debate process.

[0127] Controversial subtasks are classified as such if any of the following conditions are met: (1) the priority weight of the associated counter-evidence anchor is higher than 0.7; (2) the subtask involves a judgment on whether a violation exists; (3) the input data of the subtask is uncertain (e.g., missing data, inconsistent format); (4) the historical execution success rate of the subtask is lower than 0.8. These subtasks will enter the debate game process.

[0128] Three types of agents are set up, including an inspecting agent, a defending agent, and a adjudicating agent; each agent is undertaken by one or more agents.

[0129] The prosecutorial agent is used to generate or update the evidence chain based on currently available data and evidence chain templates that provide counter-evidence. Essentially, it identifies all facts and reasoning paths supporting the establishment of a "suspicion." The prosecutorial agent's output includes: the evidence chain (a series of data records and logical deduction steps), the confidence level of each piece of evidence, and the overall support score. The agent labels the source (data fingerprint, timestamp), reasoning basis (referenced rules, models, or agents), and the evidence's position within the entire evidence chain for each piece of evidence. The agent also proactively identifies weaknesses in the evidence chain and explains them during presentation (e.g., "This evidence relies on a third-party data source; its update delay may affect accuracy"). After presenting evidence, the prosecutorial agent submits the complete evidence package to the adjudication agent. The prosecutorial agent can employ various strategies to construct the evidence chain, including forward chains (deriving conclusions from known facts), reverse chains (inferring necessary evidence from the conclusion), or hybrid strategies.

[0130] Defense agent: Used to examine the chain of evidence generated by the inspection agent, looking for rebuttal evidence or alternative explanations, that is, to attempt to disprove the conclusion that "the doubt is established".

[0131] Upon receiving the chain of evidence against the inspected agent, a systematic review is conducted. The review includes: At the data level: Check whether the data referenced by the agent is missing, incorrect, outdated, or tampered with. The defending agent can use fingerprint information in the causal imprint chain for integrity verification.

[0132] At the logical level: The examiner checks whether the agent's reasoning process contains logical jumps, circular arguments, or omissions of alternative interpretations. The defense agent focuses on whether the examiner has ignored the refutation conditions defined in the anchor of proof by contradiction. If a refutation condition is not excluded in the examiner's chain of evidence, the defense agent raises it as a core refutation point.

[0133] Confidence level: Check whether the confidence level assigned by the agent to each piece of evidence is reasonable and consistent with historical benchmarks or industry standards.

[0134] After cross-examination, the defense agent submits its rebuttal report, listing each rebuttal point and its supporting evidence. If the defense agent can construct a complete alternative explanation (i.e., interpret all data without acknowledging the validity of the doubts), it is output as a strong rebuttal.

[0135] The output of the defense agent includes: a list of rebuttal points (indicating flaws, data inconsistencies, and logical jumps in the agent's chain of evidence), alternative explanatory paths (other possibilities that could legally explain the same set of data), and an overall rebuttal strength score. The defense agent relies on predefined rebuttal conditions in the rebuttal anchors, which provide clear targets for the defense.

[0136] The adjudicating agent: Based on the chain of evidence constructed by the examining agent and the rebuttal evidence or alternative interpretations found by the defending agent, the adjudicating agent makes a ruling on the key issues or issues for the next round of debate.

[0137] Evaluation of the evidence chain of the inspecting agent: indicating which parts are fully supported, which parts remain questionable, and which parts are effectively refuted.

[0138] Evaluation of the rebuttals of the defending agent: indicating which rebuttals are valid, which are unfounded, and which require further action from the agent.

[0139] Current ruling tendencies: could be "leaning towards support", "leaning towards opposition", or "insufficient evidence".

[0140] The focus of the next round of debate: The adjudicating agent will raise one to three specific questions that the examining and defending agents will address in the next round.

[0141] If the adjudicating agent deems the current evidence sufficient for a definitive ruling, or if neither party presents new substantive evidence in two consecutive rounds (the number of new evidences is below a threshold), or if the number of debate rounds reaches a preset limit (e.g., five rounds), the debate terminates and proceeds to the adjudication phase. Otherwise, the next round of debate begins, and the checking agent and the defense agent update their arguments based on feedback from the adjudicating agent.

[0142] The adjudicating agent does not directly participate in the construction of evidence, but acts as a neutral arbitrator. The adjudicating agent's decision is based on the following criteria: the completeness of the chain of evidence (whether it covers all types of evidence required for the anchor point of rebuttal), logical consistency (whether there are contradictions between the pieces of evidence), the satisfaction of the rebuttal conditions (whether the defense agent successfully triggered the predefined rebuttal conditions), and a comparison of the confidence levels of the arguments presented by both sides.

[0143] After the debate concludes, the adjudicating agent shall make a final ruling according to the following rules: If the evidence chain of the examining agent fully covers all the evidentiary requirements of the anchor point, and all the rebuttals of the defending agent are effectively refuted without triggering any predefined rebuttal conditions, then the ruling is "anchor point established," that is, the existence of the doubt is confirmed.

[0144] If the defense agent successfully triggers one or more predefined rebuttal conditions, and the checking agent cannot provide additional evidence to exclude these rebuttals, the ruling is "anchor not established," meaning the doubt is excluded.

[0145] If the evidence chain of the examining agent is incomplete, but the rebuttal of the defending agent is also insufficient, or if both sides have partial valid points, the ruling will be "insufficient evidence, requiring manual review." In this case, the system will package the materials submitted by both parties and mark them as items awaiting manual review in the audit report.

[0146] The ruling is accompanied by detailed reasoning, including specific pieces of evidence, counterarguments, and the logical reasoning process of the defending agent. The length and detail of the reasoning are positively correlated with the risk level of the subtask: for high-risk subtasks, the reasoning needs to be "independently verifiable," meaning that a third party can reconstruct the entire reasoning process based on the reasoning.

[0147] All submitted materials in each round of debate (examining the agent's evidence package, defending agent's rebuttal report, and adjudicating agent's comments) are fully recorded and stored in association with a causal imprint chain. These records are used not only to generate interpretability audit reports but also for subsequent system optimization: for example, the adjudicating agent's comments can serve as a reward signal for reinforcement learning to improve the agent's argument generation strategy.

[0148] Before the debate begins, the system initializes by providing the input data of the subtasks, the associated rebuttal anchors (including their evidence chain templates and rebuttal conditions), and the atomic constraint propagation results to both the checking and defending agents. Simultaneously, the adjudicating agent receives a debate rulebook, which specifies the maximum number of debate rounds, evidence acceptance criteria, and confidence level calculation methods.

[0149] All results generated from the preceding steps—including rebuttal anchor point verification conclusions, debate records, causal imprint chains, and anomaly self-healing records—are integrated into a structured report that conforms to auditing standards. The report not only presents conclusions but also provides a complete and verifiable chain of evidence and reasoning process, enabling auditors to trace the source of each judgment. Simultaneously, the experience and new knowledge gained during this audit are fed back into the system, enabling the continuous evolution of the knowledge base.

[0150] The integrated output data serves as the basis for the automatic generation of audit reports, and is processed on a per-point basis: each activated per-point corresponds to an evidence package.

[0151] The evidence package contains the following: Anchor point basic information: anchor point identifier, name, risk level, priority weight.

[0152] Verification results: The decision made by the adjudicating agent (valid / invalid / human review), and the confidence level of the decision.

[0153] Examine the agent's evidence chain: the complete path from input data to conclusion, presented in a structured form. Each evidence node includes the data source (database table name, file path, API endpoint), data fingerprint, collection timestamp, and the reasoning steps supporting the evidence (referenced rules or model outputs).

[0154] The defense agent's rebuttal record includes all raised rebuttals and the adjudicating agent's acceptance or rejection of each rebuttal. For rejected rebuttals, the reasons for rejection are provided.

[0155] The rationale for the decision by the adjudicating agent is a logical deduction process described in natural language, including key judgment nodes, the rules on which they are based, and the factors they weigh.

[0156] Causal imprint reference: A hash pointer to a related node in the causal imprint chain, allowing auditors to directly verify the integrity of the data and whether it has been tampered with.

[0157] Anomaly self-healing record: If anomaly self-healing has occurred in the subtask related to this anchor point, record the anomaly type, alternative solutions, and an assessment of the potential impact on the conclusion.

[0158] The evidence package allows auditors to manually review and supplement the report before it is generated.

[0159] The automatic generation of audit reports can utilize large AI models (or predefined template engines, which are not limited here) to generate initial drafts of audit reports for auditors to review and modify.

[0160] See Figure 2 The above-mentioned method is used to construct an audit-based multi-agent collaborative reasoning system, which includes an audit knowledge graph construction module 100, a counter-evidence anchor node addition module 200, an audit requirement activation anchor filtering module 300, a directed acyclic graph construction module 400, and a task execution module 500.

[0161] The audit knowledge graph construction module 100 is used to extract triples from audit business-related data to construct an audit knowledge graph and perform TransE graph embedding representation.

[0162] The rebuttal anchor node adding module 200 is used to construct rebuttal anchor nodes and add them to the audit knowledge graph based on the relationship between the rebuttal anchor nodes and entities in the audit knowledge graph.

[0163] The audit requirement activation anchor filtering module 300 is used to extract elements of audit requirements based on audit requirements, calculate the comprehensive similarity score between the elements and the triggering conditions of the counter-evidence anchor nodes, and filter audit requirement activation anchors based on the comprehensive similarity score.

[0164] The Directed Acyclic Graph (DAG) construction module 400 is used to activate anchor points for each audit requirement, parse atomic constraints in the trigger conditions, and propagate backward along the relationships in the audit knowledge graph starting from the atomic constraints. It collects atomic subtasks of the smallest indivisible verification unit, and constructs a DAG based on the data dependencies between atomic subtasks, using the atomic subtasks as nodes.

[0165] The task execution module 500 is used to perform agent matching and task execution for each atomic subtask in the directed acyclic graph. For controversial subtasks in the atomic subtasks, a debate game of prosecutor-defense-adjudication is used to determine whether the corresponding audit requirement activation anchor point is valid or to conduct manual review.

[0166] It also includes a causal imprint chain building module, which is used to build causal imprint chains during task execution; The causal imprint chain includes node identifier, atomic subtask identifier, executing agent identifier, input fingerprint, output fingerprint, data flow direction, timestamp, atomic subtask execution result status, and forward hash pointer; The construction of causal imprinting chains includes: Before the execution of the atomic subtask, all input data of the atomic subtask is collected, and the input fingerprint is calculated. The intelligent agent executes atomic subtasks, generates output data, and calculates the output fingerprint; The output data of the atomic subtask is determined based on the directed acyclic graph and is acquired by subsequent atomic subtasks, generating the data flow direction; The input fingerprint, output fingerprint, and data flow are packaged together, and the current timestamp and the execution result status of the atomic subtask are added to form an imprint node. Then, the hash pointer of the imprint node of the previous atomic subtask is obtained, the hash value of the current imprint node is calculated, and the hash value of the current imprint node is used as the identifier of the current imprint node. Imprinted nodes are linked together by forward hash pointers to form a causal imprint chain.

[0167] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and are not intended to limit it. Although the present invention has been described with reference to preferred embodiments, those skilled in the art should understand that various changes in form and detail can be made without departing from the spirit and scope of the invention as defined in the appended claims.

Claims

1. A multi-agent collaborative reasoning method based on auditing, characterized in that, include: Based on audit business-related data, triples are extracted to construct an audit knowledge graph, and a TransE graph embedding representation is performed. Construct rebuttal anchor nodes and add them to the audit knowledge graph based on the relationship between the rebuttal anchor nodes and entities in the audit knowledge graph; Based on audit requirements, elements of the audit requirements are extracted, and the comprehensive similarity score between the elements and the triggering conditions of the counter-evidence anchor points is calculated. Based on the comprehensive similarity score, the audit requirement activation anchor points are selected. For each audit requirement, activate the anchor point, parse the atomic constraints in the triggering conditions, and use the atomic constraints as the starting point to propagate backward along the relationships in the audit knowledge graph. Collect the atomic subtasks of the smallest indivisible verification unit, and use the atomic subtasks as nodes to construct a directed acyclic graph based on the data dependencies between the atomic subtasks. For each atomic subtask in the directed acyclic graph, agent matching and task execution are performed. For controversial subtasks in the atomic subtasks, a debate game of prosecutor-defense-adjudication is used to determine whether the corresponding audit requirement activation anchor point is valid or to conduct manual review.

2. The audit-based multi-agent collaborative reasoning method according to claim 1, characterized in that, The task execution also includes the construction of causal imprint chains; The causal imprint chain includes node identifier, atomic subtask identifier, executing agent identifier, input fingerprint, output fingerprint, data flow direction, timestamp, atomic subtask execution result status, and forward hash pointer; The construction of causal imprinting chains includes: Before the execution of the atomic subtask, all input data of the atomic subtask is collected, and the input fingerprint is calculated. The intelligent agent executes atomic subtasks, generates output data, and calculates the output fingerprint; The output data of the atomic subtask is determined based on the directed acyclic graph and is acquired by subsequent atomic subtasks, generating the data flow direction; The input fingerprint, output fingerprint, and data flow are packaged together, and the current timestamp and the execution result status of the atomic subtask are added to form an imprint node. Then, the hash pointer of the imprint node of the previous atomic subtask is obtained, the hash value of the current imprint node is calculated, and the hash value of the current imprint node is used as the identifier of the current imprint node. Imprinted nodes are linked together by forward hash pointers to form a causal imprint chain.

3. The audit-based multi-agent collaborative reasoning method according to claim 2, characterized in that, The rebuttal anchor node includes anchor identifier, triggering condition, evidence chain template, rebuttal condition, and priority weight; The addition of the relationship between the anchor node for counter-evidence and entities in the audit knowledge graph to the audit knowledge graph includes: The rebuttal anchor node is connected to the entity in the audit knowledge graph involved in the triggering condition through the triggering relationship, to the entity in the audit knowledge graph involved in the evidence chain template through the required evidence relationship, and to the entity in the audit knowledge graph involved in the rebuttal condition through the rebuttable relationship.

4. The audit-based multi-agent collaborative reasoning method according to claim 3, characterized in that, The anchor point identifier is a globally unique code using a domain-category-serial number encoding method; The triggering condition is a logical expression used to determine whether the current audit object has any suspicious points described by the anchor point; The evidence chain template is a description of the audit knowledge graph nodes and their relationship paths required to verify the doubts described by the anchor point. The rebuttal conditions are the audit knowledge graph nodes and their relationship paths required to negate or weaken the doubts described by the anchor point; The priority weights are numerical values ​​that reflect the risk level, historical hit rate, and current regulatory attention of the anchor point.

5. The audit-based multi-agent collaborative reasoning method according to claim 4, characterized in that, The comprehensive similarity score includes a weighted sum of vector similarity, keyword overlap, and domain matching. Based on the comparison between the comprehensive similarity score and the activation threshold, audit requirement activation anchors are determined and ranked according to the priority weights in the audit requirement activation anchors.

6. The audit-based multi-agent collaborative reasoning method according to claim 5, characterized in that, The agent matching for each atomic subtask in the directed acyclic graph includes: Construct an intelligent agent pool and the capability profiles of each intelligent agent in the pool. The capability profiles include the capability tags of the intelligent agents' proficiency in task types, the historical execution records of the intelligent agents, the inference rule base, and resource consumption. The execution requirements of atomic subtasks are expressed as constraint logic formulas that include preconditions and expected results; The logical consistency score is calculated between the atomic subtasks in the directed acyclic graph and the agents in the agent pool. The logical consistency score is obtained by weighted summation of premise matching score, conclusion matching score and the historical success rate of the agent. For each atomic subtask in the directed acyclic graph, traverse all agents in the agent pool, calculate their logical consistency scores, and select the agent with the highest score as the executing agent for that atomic subtask.

7. The audit-based multi-agent collaborative reasoning method according to claim 6, characterized in that, The aforementioned approach employs a prosecutorial-defense-adjudication debate to determine whether the corresponding audit requirement activation anchor point is valid or requires manual review for controversial subtasks within the atomic subtasks. This includes: Set up an inspection agent, a defense agent, and a judgment agent; The inspection agent is used to generate or update the evidence chain based on the evidence chain template of currently available data and counter-evidence anchors; The defense agent is used to examine the chain of evidence generated by the inspection agent and to find rebuttal evidence or alternative explanations; The adjudicating agent is used to make a decision on the key issue or issue for the next round of debate based on the complete chain of evidence constructed by the inspecting agent and the rebuttal evidence or alternative explanations found by the defending agent. The key issue for the next round of debate is fed back to the inspecting agent and the defending agent. The process involves one or more rounds of debate and negotiation between the prosecutor, the defense, and the adjudicator, who then makes a final decision, including whether the anchor point is valid, invalid, or requires manual review.

8. A multi-agent collaborative reasoning system based on auditing, characterized in that, It includes an audit knowledge graph construction module, a rebuttal anchor node addition module, an audit requirement activation anchor filtering module, a directed acyclic graph construction module, and a task execution module; The audit knowledge graph construction module is used to extract triples from audit business-related data to construct an audit knowledge graph and perform TransE graph embedding representation. The rebuttal anchor node adding module is used to construct rebuttal anchor nodes and add them to the audit knowledge graph based on the relationship between the rebuttal anchor nodes and entities in the audit knowledge graph; The audit requirement activation anchor filtering module is used to extract elements of audit requirements based on audit requirements, calculate the comprehensive similarity score between the elements and the triggering conditions of the counter-evidence anchor node, and filter audit requirement activation anchors based on the comprehensive similarity score. The directed acyclic graph construction module is used to activate anchor points for each audit requirement, parse atomic constraints in the triggering conditions, and, starting from the atomic constraints, propagate backward along the relationships in the audit knowledge graph to collect atomic subtasks of the smallest indivisible verification unit. Using the atomic subtasks as nodes, a directed acyclic graph is constructed based on the data dependencies between the atomic subtasks. The task execution module is used to perform agent matching and task execution for each atomic subtask in the directed acyclic graph. For controversial subtasks in the atomic subtasks, a debate game of prosecutor-defense-adjudication is used to determine whether the corresponding audit requirement activation anchor point is valid or to conduct manual review.

9. The audit-based multi-agent collaborative reasoning system according to claim 8, characterized in that, It also includes a causal imprint chain construction module for constructing causal imprint chains during the execution of the task; The causal imprint chain includes node identifier, atomic subtask identifier, executing agent identifier, input fingerprint, output fingerprint, data flow direction, timestamp, atomic subtask execution result status, and forward hash pointer; The construction of causal imprinting chains includes: Before the execution of the atomic subtask, all input data of the atomic subtask is collected, and the input fingerprint is calculated. The intelligent agent executes atomic subtasks, generates output data, and calculates the output fingerprint; The output data of the atomic subtask is determined based on the directed acyclic graph and is acquired by subsequent atomic subtasks, generating the data flow direction; The input fingerprint, output fingerprint, and data flow are packaged together, and the current timestamp and the execution result status of the atomic subtask are added to form an imprint node. Then, the hash pointer of the imprint node of the previous atomic subtask is obtained, the hash value of the current imprint node is calculated, and the hash value of the current imprint node is used as the identifier of the current imprint node. Imprinted nodes are linked together by forward hash pointers to form a causal imprint chain.

10. The audit-based multi-agent collaborative reasoning system according to claim 9, characterized in that, The rebuttal anchor node includes anchor identifier, triggering condition, evidence chain template, rebuttal condition, and priority weight; The addition of the relationship between the anchor node for counter-evidence and entities in the audit knowledge graph to the audit knowledge graph includes: The rebuttal anchor node is connected to the entity in the audit knowledge graph involved in the triggering condition through the triggering relationship, to the entity in the audit knowledge graph involved in the evidence chain template through the required evidence relationship, and to the entity in the audit knowledge graph involved in the rebuttal condition through the rebuttable relationship.

Images