---
title: 'RegReAct: Self-Correcting Regulatory Extraction'
url: https://www.emergentmind.com/topics/regreact
type: topic
---

# RegReAct: Self-Correcting Regulatory Extraction

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 [2604.12054].

## 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 language models, which the underlying work states can hallucinate structural elements, lose hierarchical relationships, and fail to resolve inter-document dependencies [2604.12054].

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 [2604.12054].

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 [2604.12054].

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 [2604.12054].

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 [2604.12054].

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 $n=709$ 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 $\Delta$ in favor of RegReAct.

Two quantitative results are reported explicitly:
$$
\text{Structural F1}_{\text{ReAct}} = 94.12\%,\quad
\text{Structural F1}_{\text{GPT4o}} = 78.6\%,\quad
\Delta = +15.52\%.
$$

$$
\text{Dependency}_{\text{ReAct}} = 4.63,\quad
\text{Dependency}_{\text{GPT4o}} = 2.96,\quad
\Delta = +1.67.
$$

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 [2604.12054].

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” [2403.11882] and from “REAct: Rational Exponential Activation for Better Learning and Generalization in PINNs” [2503.02267]. 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.

Source: https://www.emergentmind.com/topics/regreact