De Jure: Unlocking Regulatory Intelligence with Iterative LLM Self-Refinement

The Regulatory Labyrinth: A Developer’s Dilemma

In an increasingly regulated world, software engineers are constantly challenged to build systems that not only perform their intended functions but also strictly adhere to complex legal and compliance frameworks. From financial services to healthcare and emerging AI governance, regulatory documents are the bedrock of operational legality. Yet, these documents—often dense, hierarchically structured, and laden with nuanced legal jargon—are notoriously difficult to translate into actionable, machine-readable rules.

Traditionally, extracting these rules has been a manual, expert-intensive, and costly endeavor. This bottleneck severely hampers the scalability and agility of AI deployments in high-stakes environments, demanding solutions that can bridge the gap between human-readable legalese and machine-executable logic. Existing AI approaches often fall short, either requiring extensive human annotation, being too domain-specific, or producing rules too coarse to capture critical legal nuances.

Enter De Jure, a groundbreaking pipeline that promises to revolutionize how we extract and operationalize regulatory intelligence. Developed by researchers at The Vanguard Group, De Jure is a fully automated, domain-agnostic system that uses iterative Large Language Model (LLM) self-refinement to transform raw regulatory documents into structured, machine-readable rule sets. For software engineers, De Jure offers a powerful blueprint for building more compliant, efficient, and robust AI applications.

De Jure: An Engineering Blueprint for Regulatory Extraction

The De Jure pipeline operates through four meticulously designed stages, each leveraging LLM capabilities and structured data formats to ensure high-fidelity rule extraction:

Stage 1: Pre-processing – Standardizing the Chaos

The journey begins with normalizing diverse regulatory document formats (PDFs, HTML) into structured Markdown using tools like Docling. This step is critical for engineers as it:

• Standardizes Input: Converts disparate formats into a consistent, parseable structure, preserving essential elements like section boundaries, lists, and tables.
• Ensures Auditability: Each section is indexed with a unique identifier and a SHA-256 fingerprint, guaranteeing that every extracted rule can be traced back to its exact source span—a non-negotiable requirement for regulatory compliance.

Stage 2: Rule Generation – From Text to Typed JSON

Here, the pre-processed Markdown sections are fed into an LLM, which is prompted to generate structured JSON output. This isn’t just any JSON; it adheres to a carefully defined schema that decomposes each section into rich, typed components:

• Section Metadata: Captures fundamental information like citation, title, and effective_dates.
• Definitions: Extracts legal terms and their precise definitions, including term, text, scope, and cross-references.
• Rule Units: The core of the extraction, each unit contains a rule_id, label (a concise summary), rule_type (e.g., obligation, prohibition, permission), targets (who must comply), and a nine-field statement decomposition. This decomposition breaks down the rule into granular elements like action, action_object, method, conditions, constraints, exceptions, penalties, purpose, and the verbatim source span.

This structured output is a game-changer for engineers. It’s machine-readable, queryable, and directly consumable by downstream systems, moving beyond monolithic text blobs to discrete, semantically rich data points.

Stage 3: Multi-Criteria Judgment – The LLM as a Quality Gate

In an unsupervised setting without human-annotated gold standards, ensuring extraction quality is paramount. De Jure tackles this with an innovative LLM-as-a-judge framework, evaluating extractions across 19 detailed criteria, organized hierarchically:

• Metadata Validation (6 criteria): Checks for completeness, fidelity, non-hallucination, and precision of citations/dates.
• Definition Validation (5 criteria): Assesses completeness, source fidelity, non-hallucination, precision, and term quality. This stage is particularly vital for preventing hallucinated or paraphrased definitions that could subtly corrupt the interpretation of rules.
• Rule-Unit Validation (8 criteria): The most demanding stage, evaluating per-rule aspects like completeness, conciseness, accuracy of rule type, consistency, fidelity to source, neutrality, actionability, and non-hallucination.

Each criterion receives a 0-5 score and a natural-language critique, providing granular feedback for the next stage.

Stage 4: Selective Repair by Regeneration – Iterative Self-Correction

If any stage’s average score falls below a predefined quality threshold (defaulting to 0.90), De Jure initiates a targeted repair process. The LLM is re-prompted with the original text, the failing extraction, and the judge’s critiques, instructing it to correct only the deficient fields. This iterative process is:

• Hierarchical: Repairs are applied in dependency order (metadata first, then definitions, then rule units), ensuring that corrections are made on a stable, verified context. This prevents error propagation.
• Bounded: Limited to a maximum of three attempts per stage, retaining the highest-scoring output to ensure monotonically improving quality while managing computational costs.
• Surgical: Critiques are specific, leading to targeted field-level corrections rather than costly wholesale rewrites.

Why This Matters to Software Engineers: The Impact

De Jure’s innovative approach offers significant advantages for software engineers:

• Accelerated Development & Reduced Costs: By eliminating the need for human annotation and domain-specific training data, De Jure drastically cuts down the time and cost associated with building compliance-aware AI systems. Engineers can rapidly deploy solutions in new regulatory domains.
• Enhanced Data Utility & Integrability: The structured JSON output provides machine-readable rules that are easy to parse, query, and integrate into existing software architectures. This enables the creation of sophisticated compliance engines, automated auditing tools, and intelligent legal assistants.
• Robust & Trustworthy AI Systems: The iterative self-refinement and hierarchical repair mechanisms lead to more accurate, reliable, and auditable extractions. For high-stakes applications, where correctness is paramount, this means building AI systems with greater confidence in their outputs.
• Cross-Domain Scalability: De Jure’s domain-agnostic nature means it performs consistently well across finance, healthcare, and AI governance regulations without any re-engineering. This generalizability is a massive boon for engineers working on multi-industry platforms or those needing to adapt quickly to new regulatory landscapes.
• Superior Downstream Performance: The paper demonstrates that rules extracted by De Jure significantly improve the performance of RAG-based compliance question-answering systems. This translates to more accurate and contextually relevant answers, directly enhancing the utility of AI-powered legal and compliance tools.

Under the Hood: Key Technical Insights

Beyond the pipeline’s stages, several technical nuances contribute to De Jure’s effectiveness:

• Multi-Criteria LLM Judgment: The 19 distinct criteria used by the LLM judge provide a fine-grained evaluation, allowing for precise identification of errors and targeted feedback. This goes beyond simple pass/fail judgments, offering actionable insights for repair.
• Hierarchical Decoupling: The principle of repairing upstream components (metadata, definitions) before downstream ones (rule units) is fundamental. It ensures that the context provided for rule unit evaluation and repair is as accurate as possible, maximizing the likelihood of high-fidelity rule decompositions.
• Bounded Regeneration: The controlled retry budget (max 3 attempts) and the strategy of retaining the best-scoring output prevent quality degradation during regeneration, providing a “soft safety net” that ensures monotonic improvement.
• Chunking Strategy Impact: The quality of input chunks significantly impacts early pipeline stages. Cleanly encapsulated regulatory provisions lead to more precise extractions, highlighting the importance of robust pre-processing.

Conclusion: The Future of Regulatory AI is Here

De Jure represents a significant leap forward in the field of regulatory intelligence. By combining sophisticated LLM capabilities with a robust, iterative self-refinement pipeline, it offers a scalable and auditable path toward regulation-grounded LLM alignment. For software engineers, this means moving beyond the tedious and error-prone manual extraction of regulatory rules to building intelligent systems that can automatically understand, interpret, and operationalize complex legal frameworks. The era of truly compliant and agile AI is not just a dream; with De Jure, it’s becoming an engineering reality.