🤖 AI

Deterministic Legal Agents: A Canonical Primitive API for Auditable Reasoning over Temporal Knowledge Graphs

This contribution introduces the SAT Graph API, a canonical primitive interface that enables verifiable, deterministic legal reasoning by confining LLM uncertainty to intent translation and narrative synthesis, while all structural, temporal, and causal graph traversals are executed through reliable symbolic operations.

Original authors: Hudson de Martim

Published 2026-04-30

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Hudson de Martim

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to solve a complex legal puzzle, such as determining exactly what a specific law stated on a particular day in the past.

In the world of standard AI (like the chatbots we use today), the system behaves a bit like a librarian who can only guess. If you ask, "What did the housing law state in 2001?", the librarian searches the library, finds pages that look similar to your question, and hands them to you. However, here lies the problem: the librarian might grab a page from 2024, or a page from another country, or a page that was deleted years ago. The librarian is good at guessing the words, but terrible at understanding the history or the rules of the library.

This article proposes a new way to build legal AI, called Deterministic Legal Agents. Instead of a guessing librarian, they want to build a robotic archivist that follows a strict, unbreakable set of rules.

Here is how the article explains this new system using simple concepts:

1. The Problem: The "Flat" Library

Current AI treats laws like a pile of loose sheets. It does not understand that a law is part of a larger book, that books have chapters, and that laws change over time.

The Analogy: Imagine trying to find a specific sentence in a novel, but the AI simply grabs random sentences from the book that contain the same words. It might grab a sentence from the beginning of the book when you need one from the end, or a sentence from a draft that was discarded. In law, this is dangerous because a law that was true yesterday could be false today.

2. The Solution: The "SAT-Graph" (The Master Blueprint)

The authors have previously developed a special database called the SAT-Graph. Do not think of this as a pile of paper, but as a living, breathing family tree for laws.

Each law is an "element."
Every time a law changes, a new "version" is born.
Every change is caused by a specific "action" (such as the signing of a new bill).
This graph knows the exact history: Which is the parent law? What did it change? When did it expire?

3. The New Interface: The "Primitive API" (The Strict Menu)

The big question the article answers is: How do we let the AI speak with this complex family tree without allowing it to make mistakes?

If we allow the AI to write its own database queries (like asking it to write SQL code), it could become confused and request the wrong thing. Therefore, the authors created a canonical primitive API.

The Analogy: Imagine the AI is a guest in a very upscale restaurant.
- Old Way: The guest enters the kitchen and starts shouting orders at the chef, trying to cook the food themselves. They might burn the soup or use the wrong ingredients.
- New Way (The API): The guest can only order from a strict, pre-approved menu. The menu has specific buttons like "Retrieve the version of Article 6 from 2001" or "Show me who changed this law." The AI is not allowed to wander into the kitchen; it can only press buttons.

4. The Golden Rule: "Probabilistic Isolation"

This is the most important concept in the article. The authors recognized that AI is inherently "fuzzy" (it guesses), whereas legal facts must be "sharp" (they are either true or false).

They created a rule called Probabilistic Isolation. Think of this as a security checkpoint:

Zone 1 (The Fuzzy Zone): The AI is allowed to guess here. It takes your question ("What about housing?") and guesses which law you are referring to. It might say, "I think you mean Article 6, but I am only 80% sure."
The Checkpoint: Once the AI selects a specific law ID (like "Article 6"), it passes through a checkpoint.
Zone 2 (The Strict Zone): From this point on, no guessing is allowed. The AI presses a button to retrieve the 2001 version. The robotic archivist must deliver the exact text from that date. It must not guess. It must not hallucinate. It simply retrieves the exact data.
Zone 3 (Back to the Fuzzy Zone): Once the robot delivers the exact text, the AI is allowed to guess again to write a nice summary for you.

5. How It Works in Real Life (The Use Cases)

The article demonstrates how this works with three examples:

Time Travel: You ask, "What did the law state on May 20, 2001?"
- Old AI: Might show you the law as it is today.
- New AI: Guesses the law name, then presses the button "Retrieve Version 2001." The robot delivers the exact text from that day.
Detective Work: You ask, "How did the law change when 'housing' was added?"
- Old AI: Might find the word "housing" and show you a paragraph.
- New AI: Finds the law, examines its history, locates the exact moment "housing" was added, and shows you the text before and after the change, along with the specific bill that caused it.
The Ripple Effect: You ask, "Which laws did this new amendment change?"
- Old AI: Might search for the name of the amendment in other laws (which often fails).
- New AI: Follows the "action" trail. It sees that the amendment was a "parent" element that created new versions of other laws. It lists exactly what changed.

Summary

The article does not claim that this AI is perfect at being a lawyer. It claims to solve the reliability problem.

It builds a system where the AI is allowed to be creative to understand your question and formulate the final answer, but is forced to be a robot when searching for facts. It separates "guessing" from "fact-checking," so every piece of evidence the AI uses can be traced back to a specific, immutable dataset in the database.

It is like giving a detective a magnifying glass that shows only the truth, rather than a crystal ball that shows what might be true.

1. Problem Statement

The paper addresses critical limitations in applying Retrieval-Augmented Generation (RAG) to high-risk legal domains. Conventional RAG systems rely on semantic similarity over flat text fragments, which fails to capture the complex nature of legal knowledge. The authors identify three specific failure modes in current legal RAG systems:

Mereological Blindness: The failure to recognize part-whole relationships (e.g., Clause $\subset$ Article $\subset$ Statute).
Diachronic Naivety: The inability to distinguish between superseded and currently valid norms, leading to the conflation of historical and current law.
Causal Opacity: Lack of traceability regarding legislative provenance (the specific acts that enacted, amended, or repealed a norm).

While prior work (SAT-Graph) solved the representation problem by modeling legal norms as structure-aware temporal knowledge graphs, a new interaction problem emerged: How can a probabilistic LLM agent query this deterministic graph without reintroducing the unreliability the graph was designed to avoid? Allowing agents to generate arbitrary database queries (SQL/SPARQL) or relying solely on semantic search risks silent errors, hallucinations, and the circumvention of temporal or structural constraints.

2. Methodology: The SAT-Graph API

The paper proposes the SAT-Graph API, a canonical primitive interface acting as a mediator between a probabilistic LLM agent and a deterministic symbolic substrate (the temporal knowledge graph).

Core Design Principle: Probability Isolation

The architecture strictly confines stochastic uncertainty to three limited phases, ensuring that once a reference is resolved, all subsequent operations are deterministic:

Intent Translation: The LLM converts a natural language query into an execution plan.
Initial Semantic Anchoring: The system uses probabilistic search (semantic/lexical) to map ambiguous references to ranked candidate graph anchors (Items, Topics, TextUnits).
Narrative Synthesis: The LLM generates the final prose response based on verified evidence.

Deterministic Core: Once a canonical identity and temporal parameters are established, all graph traversals (structural, temporal, causal) are executed via typed, atomic primitives. This ensures the retrieval process itself is reproducible and auditable.

Architectural Components

The Substrate (SAT-Graph): A temporal knowledge graph modeling legal instruments as versionable entities with explicit hierarchical embedding and legislative causality.
The Interaction Protocol (API): A library of typed, composable primitives serving as a procedural facade. The agent does not see the physical database schema but interacts via a fixed vocabulary.
The Agent: A probabilistic planner that decomposes questions into a sequence of primitive calls, observes intermediate results, and synthesizes answers.

Key Data Models

The API operates on five canonical, domain-portable data models:

Item: A canonical graph entity with a stable identity (e.g., a specific article).
Version: A time-bound snapshot of an Item, capturing validity and applicability intervals.
TextUnit: The textual realization attached to a graph entity, linking semantic search with deterministic retrieval.
Action: A reified state-transition event (e.g., promulgation, amendment) that creates or terminates versions.
Relation: Typed semantic edges (citations, dependencies) between entities.

Primitive Categories

The API exposes functional groups of primitives:

Discovery & Search: resolveItemReference, searchTextUnits (returns ranked candidates with confidence scores).
Temporal Resolution: getValidVersions, getItemVersions (deterministic retrieval of versions valid at a specific point in time).
Structural Navigation: getItemHierarchy, getItemAncestors (reconstructs context without reliance on text adjacency).
Causality & Impact: getItemHistory, getActionsBySource (traces provenance and forward-looking impact).
Introspection: getRootItemTypes, getSupportedActionTypes (enables agents to discover schema boundaries).
Hydration: getVersionTextUnits (converts lightweight IDs into full textual evidence).

3. Main Contributions

Specification of a Canonical Primitive API: A formal interface for querying structure-aware temporal knowledge graphs, instantiated for legal norms but designed for domain portability.
Principle of Probability Isolation: A neuro-symbolic design pattern that separates probabilistic planning/anchoring from deterministic graph execution, making system errors localizable and auditable.
Reason-Act-Observe Paradigm: Shifts legal RAG from a passive "retrieve-then-generate" pipeline to an active process where the agent decomposes questions into explicit, verifiable execution plans.
Formal Separation of Concerns: Decouples the representation of legal knowledge (the graph) from agent reasoning (the LLM) via a typed interaction protocol, preventing schema coupling and query confabulation.
Application Examples: Illustrates how complex legal queries (point-in-time retrieval, version comparison, forward-looking causality, thematic impact analysis) are decomposed into verifiable primitive sequences.

4. Results and Evaluation

The paper presents no empirical benchmark results (e.g., accuracy metrics against baselines) but offers a formal architecture specification and qualitative validation through use cases:

Deterministic Point-in-Time Retrieval: Demonstrates how an agent can retrieve the exact text of a law valid at a specific past date, thereby avoiding the "temporal naivety" of standard RAG.
Causal Point Accuracy: Shows how an agent can trace the exact legislative action that introduced a specific right (e.g., "housing") and compare the text before and after the amendment.
Forward-Looking Causality: Illustrates how all provisions affected by a specific amendment can be identified, a task difficult for semantic search due to lack of lexical overlap.
Thematic Impact Analysis: Demonstrates the ability to aggregate historical changes across a thematic hierarchy (e.g., "digital security") by combining thematic resolution with temporal event queries.

The "results" are the verifiable execution logs generated by these processes, enabling human auditors to trace exactly which entity was resolved, which version was selected, and which action produced the evidence.

5. Significance and Implications

Trustworthy Legal AI: The architecture provides a foundation for legal systems where the evidence-based basis of an answer is fully auditable, reproducible, and traceable to canonical graph objects.
Auditability as a Retrieval Property: Unlike traditional RAG, where auditability is a downstream feature, this system makes auditability an inherent part of the retrieval process itself. Every step is a typed operation over a canonical object.
Domain Portability: Although illustrated in law, the abstractions (Items, Versions, Actions) apply to any authority-governed domain requiring historical accuracy and provenance (e.g., technical standards, regulatory compliance, technical specifications).
Shift in Engineering Burden: The complexity of temporal logic and structural validation is shifted from the LLM prompt (where it is error-prone) to the API layer (where it can be rigorously tested and enforced).

6. Limitations and Future Work

Dependency on Graph Quality: The determinism of the system depends on the correctness and completeness of the underlying knowledge graph ingestion.
Errors in Semantic Anchoring: Although uncertainty is exposed, the initial mapping of natural language to graph anchors remains probabilistic and may fail with ambiguous queries.
Planning Errors: The architecture does not prevent agents from generating logically insufficient plans (e.g., querying the wrong instrument) but makes these errors auditable.
Future Directions: The authors call for empirical benchmarking against standard RAG, the development of "Text-to-Plan" learning models, and the construction of gold-standard datasets for temporal legal reasoning.

In summary, the paper argues that for high-risk domains, retrieval must be a verifiable execution process, not a black-box search. The SAT-Graph API provides the necessary interface to achieve this by strictly isolating probabilistic uncertainty from deterministic reasoning.