RegReAct: Self-Correcting Regulatory Extraction

• RegReAct is a self-correcting multi-agent framework that extracts fully structured, machine-readable compliance criteria from regulatory texts.
• It employs a seven-stage pipeline with an Observe–Diagnose–Repair loop to ensure hierarchical consistency, eliminate hallucinations, and resolve inter- and extra-document references.
• The framework integrates a global typed criterion graph and criterion-conditioned RAG module to achieve accurate schema assembly and inline enrichment.

RegReAct is a self-correcting multi-agent framework for extracting fully structured, machine-readable compliance criteria from regulatory texts. It is designed to guarantee hierarchical consistency, eliminate LLM hallucinations, and resolve all inter- and extra-document references inline, producing self-contained outputs requiring no further consultation of source documents. The framework decomposes regulatory information extraction into seven specialized stages, each operating with an Observe–Diagnose–Repair (ODR) loop grounded in source HTML, and integrates their outputs through a global typed criterion graph and a criterion-conditioned RAG module (Ali et al., 13 Apr 2026).

1. Definition, scope, and design objectives

RegReAct addresses an open challenge in regulatory NLP: extracting structured, machine-readable compliance criteria from regulatory documents without losing hierarchical relationships, hallucinating structural elements, or failing to resolve inter-document dependencies. The system is explicitly framed against the limitations of single-pass LLMs, which the underlying work states can hallucinate structural elements, lose hierarchical relationships, and fail to resolve inter-document dependencies (Ali et al., 13 Apr 2026).

The stated goals are threefold: to extract fully structured, machine-readable compliance criteria from regulatory texts; to guarantee hierarchical consistency, eliminate LLM hallucinations, and resolve all inter- and extra-document references inline; and to produce self-contained outputs requiring no further consultation of source documents. The architecture couples decomposition with validation. A seven-stage pipeline of specialized agents handles structure, thresholds, logic, references, dependencies, footnotes, and assembly; a shared semantic memory carries forward thresholds, cross-reference mappings, and activity metadata for cross-stage consistency; a global typed criterion graph enforces structural invariants; and a criterion-conditioned RAG module resolves every external and internal reference and embeds summaries inline.

This design suggests that RegReAct is intended not merely as an extraction system but as a constrained transformation pipeline in which each stage is accountable to source evidence and to downstream schema consistency. A plausible implication is that the framework is optimized for regulatory settings where omission and mis-linkage are at least as problematic as ordinary extraction error.

2. Seven-stage pipeline

The pipeline consists of seven specialized stages. Each stage receives as input the original HTML and the cumulative extraction state from previous stages. After completion and self-correction, it writes its outputs to shared memory and passes control to the next agent.

Stage	Purpose	Output
1. Structural Parsing	Recover the true hierarchical nesting of criteria from noisy HTML lists, unnumbered paragraphs, and typographic cues	A tree of criterion nodes with stable identifiers; semantic anchoring and descriptive typing for unnumbered paragraphs
2. Threshold Extraction	Extract and normalize all quantitative limits and temporal deadlines, including distant or inherited ones	A structured threshold object per criterion with quantitative and temporal sub-fields
3. Classification & Logic Inference	Assign category, applicability, and evaluation logic	Fields category, applicability, evaluation_logic, n_required
4. Reference Extraction	Identify all external citations	A references object with logic and source list, including CELEX ID, link, and link status
5. Dependency Resolution	Infer and correct inter-criteria relationships unmarked in HTML	A dependencies object with condition summary, minimum conditions, and criterion clauses
6. Footnote Processing	Decompose footnotes into independent legal and definitional items	Footnote array with id, categories, items, definitions, and notes
7. Schema Assembly	Integrate all components into the final JSON schema and enforce consistency	A validated JSON document per activity conforming to the EU-TaxoStruct schema

Stage 1, Structural Parsing, produces a tree of criterion nodes with stable identifiers such as SC.1.a.ii. For unnumbered paragraphs, it performs semantic anchoring to parent criteria and classifies them into one of six descriptive types: Verification, Methodology, Commitment, Assessment, Replacement, and BackgroundInformation. This stage feeds the criterion tree and synthetic IDs into Stages 2 through 7.

Stage 2, Threshold Extraction, outputs a structured threshold object for each criterion. Quantitative items include metric, operator, value, unit, and optional measurement period. Temporal items include type, such as deadline or recurring, and date information. These extracted thresholds are registered in shared memory for cross-stage consistency.

Stage 3, Classification & Logic Inference, assigns category ∈ {Quantitative, Qualitative}, with “Quantitative” iff thresholds are present; applicability ∈ {Mandatory, Conditional}; and \phi(c) ∈ {AND, OR, N_OF_K, LEAF}. It outputs category, applicability, evaluation_logic, and n_required, and supplies evaluation logic and category labels to the graph and assembly stage.

Stage 4, Reference Extraction, identifies external citations, including EU acts, ISO standards, and internal sections. Its output includes a references object with logic (AND/OR/null) and a list of sources containing text, type ∈ {must_be_fetched, citation_only}, CELEX ID, link, and link status. CELEX normalization is performed through multi-step parsing and validation against EUR-Lex, with ReAct-style correction if unresolved.

Stage 5, Dependency Resolution, introduces explicit inter-criteria semantics absent from the HTML. It models three edge types: conditional dependencies (depends_on), threshold inheritance (inherits_threshold), and cross-reference corrections (corrects). Its output is a dependencies object with condition_summary, min_conditions_to_meet, and clauses [{criterion_id, status}].

Stage 6, Footnote Processing, decomposes footnotes into independent items such as legal acts, standards, and definitions, classifies each as must_be_fetched or citation_only, and links it to the appropriate criterion. Stage 7, Schema Assembly, integrates all components into the final JSON schema with 13 fixed fields per node, enforces cross-field consistency, and nullifies empty complex objects.

3. Observe–Diagnose–Repair mechanism

Each stage is wrapped in an Observe–Diagnose–Repair loop with up to $k_{\max}=3$ iterations. The ODR loop is central to RegReAct’s claim of self-correction, and it operates against the original HTML rather than relying only on internal model confidence (Ali et al., 13 Apr 2026).

In the Observe phase, the system examines the stage’s provisional JSON output alongside the original HTML. The detection taxonomy includes structural issues such as missing fields and malformed IDs, semantic inconsistencies such as operator-text mismatches, completeness gaps where source elements are not extracted, and cross-field contradictions such as category = Quantitative with no thresholds. Each issue is represented as {type, severity, field, description, source_evidence}.

In the Diagnose phase, the LLM analyzes the observed issues together with the history of prior attempts. The resulting DiagnosisResult contains a root_cause, contributing_factors, recommended_action ∈ {retry_modified, decompose, fallback, accept, escalate}, and specific_guidance identifying fields to focus on.

In the Repair phase, the system constructs a targeted correction prompt based on the recommended action and re-invokes the same stage with additional constraints. The example given is correcting the operator for thresholds in nodes missing ≤. Termination occurs when confidence is at least $\tau = 0.7$ with no critical issues, or when the attempt limit is reached. Unresolved outputs are flagged for human review.

Hallucination detection is embedded directly in this process. Phantom thresholds are detected in the Observe step by comparing extracted data against source HTML. Cross-reference errors are also handled through structured correction. If a citation such as “point 1(b)(v)” does not exist, a specialized agent maps the numeric position (v→5) to the correct sibling, for example 1(f)(e), and verifies semantic match. Corrections are recorded as edges of type Corrects and annotated in the rule_summary with [CORR FROM:… TO:… REASON:crossref].

This suggests that RegReAct treats source-grounded validation as a first-class inference operation rather than as post hoc quality control. A plausible implication is that the framework’s robustness depends not only on stage specialization but also on the explicit encoding of error taxonomies and repair actions.

4. Typed criterion graph and structural invariants

RegReAct constructs a typed criterion graph to enforce structural accuracy. For activity $i$, the graph is defined as

$$G_i = (V_i, E_i, \tau_V, \tau_E) \quad\text{with}\quad V_i=\{c_1,\ldots,c_m\},$$

$$E_i\subseteq V_i\times V_i\times\{\text{Hierarchy},\dots,\text{Corrects}\},\qquad \tau_V(v)=\text{CriterionNode},\qquad \tau_E(e)=\ell\in L.$$

The node set $V_i$ consists of criterion nodes, including anchored paragraphs. The edge set $E_i$ supports six labels: Hierarchy, Group_Member, Inherits_Threshold, References, Depends_On, and Corrects. This graph is therefore not limited to tree structure; it combines containment, logic grouping, threshold propagation, citation structure, conditional gating, and correction metadata within one typed representation (Ali et al., 13 Apr 2026).

Hierarchy edges enforce a cycle-free tree. Global validation checks acyclicity of parent–child edges, that each criterion with logic=AND/OR/N_OF_K has matching child counts, that no nodes are disconnected, and that regulatory rules are satisfied. One such rule is Evaluation Participation, which excludes BackgroundInformation nodes from child counts. Threshold inheritance edges store pointers used in Stage 5 to copy threshold values into dependent nodes.

The graph formalism is significant because it links extraction outputs to explicit invariants. Structural errors are therefore not only textual mismatches but graph violations. This suggests that RegReAct uses graph typing as a mechanism for reconciling local extraction decisions with global regulatory structure.

5. External dependency resolution and inline enrichment

To ensure completeness, RegReAct resolves external dependencies through a criterion-conditioned RAG module that retrieves, summarizes, and embeds referenced legal content inline. The stated goal is to resolve every external and internal reference and embed summaries inline so that outputs become self-contained (Ali et al., 13 Apr 2026).

The document retrieval algorithm proceeds as follows for each must_be_fetched reference containing a CELEX ID and article or section reference: fetch the PDF from EUR-Lex; convert it to structured Markdown via MinerU; chunk it while respecting article and paragraph boundaries; and index the chunks per document with ColBERT embeddings plus HNSW. Retrieval then runs in a ReAct-style loop of up to 3 iterations. The system rewrites the criterion into a retrieval-optimized question incorporating activity context, queries via RRF fusion of BM25 and ColBERT, has the LLM evaluate passages and flag gaps such as “threshold not found,” and refines the query from the gap description if confidence is below $\theta$.

The top-ranked chunks, together with the original criterion, are then passed to an LLM summarizer. Summaries must quote key thresholds verbatim in under 100 words, extract key_facts, extract thresholds, and assign confidence. The enriched summary is stored permanently under reference.enrichment in the JSON.

This component is notable because it moves beyond citation extraction into citation absorption. A plausible implication is that the framework aims to reduce the operational dependence of downstream compliance systems on the original legal corpus, except where enrichment is impossible.

The main stated limitation of this module is that paywalled references, specifically ISO and EN standards, cannot be enriched inline, which limits self-containedness.

6. Dataset construction, evaluation, and reported results

Applying RegReAct to the three EU Taxonomy Delegated Acts—2021/2139, 2022/1214, and 2023/2486—yields the EU-TaxoStruct dataset. The dataset covers 242 economic activities and over 4,800 hierarchical criterion nodes spanning six environmental objectives. Each node encodes category, applicability, evaluation logic, thresholds, inter-criteria dependencies, cross-reference corrections, footnotes, and in-line RAG summaries. Gold annotations are available on 100 activities, with Cohen’s $\kappa = 0.84–0.91$ across dimensions (Ali et al., 13 Apr 2026).

Evaluation is organized into three groups of metrics. Structural and classification evaluation on $n=100$ activities uses Structural F1, Category Accuracy, Applicability Accuracy, and Evaluation Logic Accuracy. Semantic equivalence is judged on a 1–5 Likert scale by a GPT-4o judge for threshold equivalence, reference equivalence, footnote equivalence, and dependency equivalence. RAG summary quality is evaluated on $\tau = 0.7$0 pairs using Faithfulness, Relevance, Completeness, and Coverage, also on a 1–5 Likert scale.

The baseline is a GPT-4o single-pass system using identical prompts and schema but without decomposition, ODR, graph, or RAG. The reported result is that RegReAct outperforms this baseline across all structural and semantic metrics. The paper states that all eight structural and semantic metrics in Table 7 show large $\tau = 0.7$1 in favor of RegReAct.

Two quantitative results are reported explicitly:

$\tau = 0.7$2

$\tau = 0.7$3

These results support the claim that decomposition, source-grounded correction, graph validation, and dependency enrichment are empirically consequential, not merely architectural embellishments. A plausible implication is that the largest gains occur in precisely those dimensions—structure and dependency semantics—where single-pass extraction is weakest.

7. Limitations, extensions, and name disambiguation

The paper identifies three primary limitations. First, paywalled references such as ISO and EN standards cannot be enriched inline, limiting self-containedness. Second, evaluation is limited to English-language EU texts, so multilingual support remains to be tested. Third, pipeline snapshots reflect regulations at processing time, and subsequent amendments require re-execution (Ali et al., 13 Apr 2026).

The stated future directions are adaptation to other regulatory domains and jurisdictions, the addition of multilingual and temporal versioning support, and integration of certified paywalled content extraction. These extensions suggest that the current system is domain-tested rather than domain-universal.

A common source of confusion is the similarity of names across unrelated works. RegReAct, the regulatory information extraction framework described here, is distinct from “ReGenNet: Towards Human Action-Reaction Synthesis” (Xu et al., 2024) and from “REAct: Rational Exponential Activation for Better Learning and Generalization in PINNs” (Mishra et al., 4 Mar 2025). The shared orthography reflects acronym overlap rather than methodological continuity.

Within regulatory AI, RegReAct is best understood as a multi-agent extraction-and-repair system centered on typed structural representations, iterative source-grounded validation, and inline dependency resolution. Its defining contribution is not a single model component but the integration of staged extraction, ODR self-correction, typed graph validation, and criterion-conditioned RAG into a schema-constrained pipeline for regulatory criteria.