🤖 AI

An LLM Agentic Approach for Legal-Critical Software: A Case Study for Tax Prep Software

This paper proposes an agentic LLM framework that automates the translation of U.S. tax code into executable software and utilizes higher-order metamorphic relations for test generation, demonstrating that a smaller model (GPT-4o-mini) outperforms frontier models in achieving robust, trustworthy legal-critical software.

Original authors: Sina Gogani-Khiabani, Ashutosh Trivedi, Diptikalyan Saha, Saeid Tizpaz-Niari

Published 2026-03-05

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Sina Gogani-Khiabani, Ashutosh Trivedi, Diptikalyan Saha, Saeid Tizpaz-Niari

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 build a robot that can do your taxes. This isn't just any robot; it's a robot that has to follow the law exactly. If it makes a tiny mistake, you could get audited, fined, or miss out on money you deserve.

The problem is that tax laws are written in "Legalese"—a confusing, ambiguous language full of exceptions, edge cases, and constant updates. If you ask a standard AI (a Large Language Model or LLM) to just "write the code for the tax law," it often hallucinates (makes things up) or gets the logic wrong, like applying a tax rate to the wrong part of your income.

This paper introduces a new way to build this "Tax Robot" called Synedrion. Instead of asking one super-smart AI to do everything, they built a team of specialized AI agents that work together like a human software company.

Here is the breakdown using simple analogies:

1. The Problem: The "Oracle" Mystery

In normal software testing, you know the answer before you start. If you ask a calculator 2 + 2, you know the answer is 4. This is called an "Oracle."

But in tax software, nobody knows the exact answer beforehand without a human expert looking at the law. If a single person earns $50,000, is the tax $7,200 or $7,250? It depends on a dozen tiny rules. This is the "Oracle Problem." You can't just check if the robot is right because you don't know the right answer yourself.

2. The Solution: The "Synedrion" Team

The authors created a team of AI agents, each with a specific job, mimicking a real-world law firm and engineering team:

The Tax Expert (The Translator):
- Analogy: Imagine a strict lawyer who reads the messy tax code and turns it into a clean, structured recipe card (JSON format).
- Job: They don't write code; they just translate the confusing laws into clear, step-by-step instructions that a computer can understand.
The Coders (The Builders):
- Analogy: These are the construction workers. They take the "recipe card" from the Tax Expert and build the actual software.
- Job: They write the Python code. There are two of them: one builds the first draft, and a "Senior Coder" (a manager) reviews it. If the draft is messy, the manager sends it back for fixes.
The Metamorphic Agent (The Quality Inspector):
- Analogy: This is the most creative part. Imagine a detective who doesn't know the exact answer to a math problem, but knows the rules of the game.
- Job: Instead of asking "Is the tax $7,200?", this agent asks: "If I give the robot a person with more income, should the tax go up?" or "If I make someone blind, should their tax go down?"
- The "Higher-Order" Twist: The paper's big innovation is that this agent doesn't just check simple "up or down" rules. It checks rates of change.
  - Simple check: "If income goes up, tax goes up." (A bad robot that charges a flat 20% on everything passes this).
  - Higher-Order check: "If income goes from $40k to $41k, the tax should jump slightly because you crossed a bracket. But if it goes from $41k to $42k, the jump should be bigger."
  - This catches "flat-rate" bugs that simple checks miss.

3. The Surprise: Small Dogs vs. Big Lions

Usually, in AI, bigger models (like GPT-4o or Claude-3.5) are smarter than smaller ones. You'd expect the "Big Lion" to win.

The paper found the opposite:
When using this team approach, a smaller, cheaper AI model (GPT-4o-mini) actually performed better than the massive, expensive models when working alone.

Why? The massive models tried to do everything at once and got confused by the complexity. The smaller model, when guided by the "Tax Expert" and checked by the "Inspector," stayed focused and made fewer mistakes. It's like a small, focused apprentice with a great mentor doing better than a distracted genius.

4. The Results: Catching the "Flat Rate" Trap

The team tested their system on six different tax scenarios, from simple deductions to complex retirement distributions.

Without the team: Even the best AI models failed on the hardest tasks (getting less than 15% of the answers right).
With the team: The smaller model, guided by the agents, got 45% to 88% of the answers right (depending on the complexity).
The "Inspector" effect: Adding the "Metamorphic Agent" (the detective) was crucial. It found systematic errors that the builders missed, pushing the success rate even higher.

Summary

This paper argues that to build software for critical legal tasks (like taxes), we shouldn't just ask a super-intelligent AI to "do it." Instead, we should build a collaborative team:

One to translate the law.
One to build the code.
One to act as a detective, checking if the logic holds up under pressure.

By using this "Agentic" approach, even smaller, cheaper AI models can build software that is safer, more accurate, and more trustworthy than the most powerful models working alone. It turns the chaotic process of coding from legal text into a structured, reliable assembly line.

1. Problem Statement

The paper addresses the challenge of developing legal-critical software, specifically U.S. federal tax preparation systems, by translating complex, ambiguous natural language statutes into executable code.

The Oracle Problem: In legal domains, determining the "correct" output for a specific input is often impossible without expert legal interpretation. Traditional testing relies on an "oracle" (a known correct answer), which is unavailable for many tax scenarios.
Limitations of Standard LLMs: While Large Language Models (LLMs) can generate code, they struggle with:
- Hallucinations and Ambiguity: Misinterpreting nuanced legal statutes.
- Systematic Errors: Generating code that satisfies simple pairwise logic (e.g., "higher income = higher tax") but fails complex structural requirements (e.g., progressive tax brackets or specific deduction caps).
- Scalability: Frontier models (e.g., GPT-4o) often fail in complex scenarios when used in isolation, and smaller models perform poorly without guidance.

2. Methodology: The Synedrion Framework

The authors propose Synedrion, a multi-agent framework designed to automate the translation of legal documents into robust software. The system simulates a real-world software team with specialized roles.

A. Agent Architecture

The framework consists of five specialized agents:

TaxExpertAgent: Parses raw legal text (e.g., IRS publications) and converts it into structured JSON specifications. It defines function inputs, outputs, constraints, and edge cases, ensuring data integrity before code generation.
Coder Agents (Two instances): Generate Python code based on the JSON specifications. They use different temperature settings to encourage diverse implementation strategies.
SeniorCoderAgent: Orchestrates the coding process. It reviews the initial code from the Coder Agents, provides feedback, and selects or refines the best implementation.
MetamorphicAgent: The core innovation. It does not check for absolute correctness but validates relative correctness using metamorphic testing.

B. Key Innovation: Higher-Order Metamorphic Testing (HMT)

To solve the oracle problem, the paper introduces Higher-Order Metamorphic Relations.

Standard Metamorphic Testing: Compares two inputs (e.g., a blind taxpayer vs. a non-blind taxpayer) to ensure the output follows a logical rule (e.g., blind taxpayer pays less).
Higher-Order Generalization: Instead of pairwise comparisons, HMT evaluates rates of change across multiple inputs ( $n$ $n$ -ary relations).
- Example: In a progressive tax system, simply checking that tax increases with income is insufficient. HMT checks if the marginal rate of tax increase matches the statutory brackets. It can detect if a model incorrectly applies a flat rate across all income levels, which would pass a simple pairwise test but fail a higher-order rate-of-change test.
Automated Generation: The MetamorphicAgent uses LLMs to automatically generate these complex test tuples (e.g., identifying income thresholds where tax brackets jump) and detect violations.

3. Experimental Setup

Benchmarks: Six progressively complex scenarios derived from U.S. tax law (IRS publications), ranging from basic tax brackets to complex 1099-R retirement distributions and the American Opportunity Tax Credit.
Models Evaluated:
- Baselines: GPT-4o, GPT-4o-mini, Claude-3.5-Sonnet, Llama 3.1-70B, Llama 3.1-8B.
- Prompting Strategies: Zero-shot vs. Step-wise Chain-of-Thought (CoT).
Evaluation Metrics:
- Partial Pass@k: Since passing all tests is rare, the metric measures the average percentage of test cases passed across $k$ generations.
- Worst@10: The lowest pass rate observed across 10 generations, measuring reliability/consistency.
Ground Truth: A hand-authored reference implementation (fixed to Tax Year 2021) used for validation via symbolic execution (Z3 solver).

4. Key Results

The study yields counter-intuitive findings regarding model size and the efficacy of the agentic approach.

RQ1 (Baseline Performance): Large models (GPT-4o, Claude-3.5) perform well on simple tasks (Scenarios 1-5) but degrade significantly on complex tasks (Scenario 6). Smaller models (Llama-8B, GPT-4o-mini) struggle significantly in zero-shot and CoT modes, often achieving near-zero pass rates on complex benchmarks.
RQ2 (Agentic vs. Baseline): The Synedrion framework allows smaller models to outperform frontier models.
- GPT-4o-mini (a smaller model) within the agentic framework achieved a Worst@10 of 45% on the hardest scenario, compared to 9% for the same model using CoT prompting alone.
- The agentic framework with Claude-3.5 achieved a Worst@10 of 78% on the hardest scenario, significantly outperforming its baseline CoT performance (31%).
RQ3 (Metamorphic Testing Contribution):
- Adding 4-ary Metamorphic Testing (MT) improved robustness.
- Adding Higher-Order Metamorphic Testing (HMT) provided the most significant gains. For GPT-4o in Scenario 6, HMT pushed the Worst@10 score from 72% (with MT) to 88%.
- HMT successfully detected systematic errors (like flat-rate implementations) that pairwise tests missed.
RQ4 (Agent Contributions):
- The TaxExpertAgent was critical for structuring rules, boosting PP@1 scores from 12% to 97% in medium-complexity scenarios.
- The MetamorphicAgent was essential for reliability, drastically reducing the variance between best-case and worst-case performance.
- Cost Analysis: While HMT increases token usage (and cost) significantly (e.g., from ~111k to ~450k tokens for Scenario 6), the trade-off is justified by the massive gain in functional correctness and robustness.

5. Significance and Conclusion

Paradigm Shift: The paper demonstrates that for legal-critical software, structured collaboration among specialized agents is more effective than relying on the raw capability of a single, massive LLM.
Small Model Viability: It proves that smaller, more cost-effective models (like GPT-4o-mini) can achieve state-of-the-art results in complex domains if supported by a robust agentic workflow and advanced testing strategies.
Solving the Oracle Problem: By leveraging Higher-Order Metamorphic Relations, the framework provides a mechanism to validate software against legal principles (consistency, progressivity) without needing a definitive "correct" answer for every input.
Broader Impact: The approach is applicable beyond tax software to any legal-critical domain (e.g., welfare eligibility, compliance systems) where natural language regulations must be translated into error-free executable logic.

In summary, Synedrion establishes that combining domain-specific agents with higher-order metamorphic testing creates a pathway to generating trustworthy, legally compliant software, overcoming the limitations of both traditional testing and standalone LLM generation.