🤖 AI

MoCA-Agent: A Market-of-Claims Code Agent for Financial and Numerical Reasoning

MoCA-Agent is a market-of-claims code agent that enhances financial and numerical reasoning by decomposing questions into atomic claims for specialist verification, synthesizing executable code from market-supported evidence, and applying rigorous verification to achieve state-of-the-art performance across diverse financial benchmarks.

Original authors: Abdelrahman Abdallah, AbdelRahim A. Elmadany, Sameh Al Natour, Hasan Cavusoglu, Adam Jatowt, Muhammad Abdul-Mageed

Published 2026-06-11

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Abdelrahman Abdallah, AbdelRahim A. Elmadany, Sameh Al Natour, Hasan Cavusoglu, Adam Jatowt, Muhammad Abdul-Mageed

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 very tricky math problem based on a messy spreadsheet. If you ask a standard AI to do it, it might write a long, confident-sounding story that leads to the wrong number. It's like a student who writes a perfect essay but accidentally divides by zero in the final step—the essay looks great, but the answer is wrong.

The paper introduces MoCA-Agent, a new kind of AI designed specifically to stop these "silent mistakes" in financial and numerical tasks. Instead of letting the AI just chat its way to an answer, MoCA-Agent treats the problem like a stock market for facts.

Here is how it works, using simple analogies:

1. The "Claim Catalog" (Breaking it Down)

Instead of asking the AI to "solve the problem," MoCA-Agent first breaks the question down into tiny, atomic pieces called claims.

Analogy: Imagine you are building a house. Instead of saying "Build a house," you list every single brick, beam, and nail needed.
In the paper: If the question is "What was the profit?", the system lists claims like: "Revenue is $100," "Expenses are $20," "Profit means Revenue minus Expenses," and "The sign should be positive."

2. The "Market of Traders" (The Debate)

This is the core innovation. The system doesn't just ask one AI to think. It hires four different "specialist traders" to bet on whether each tiny claim is true or false.

The Traders:
- The Extractor: Checks if the numbers match the original document.
- The Formula Expert: Checks if the math logic makes sense.
- The Accountant: Checks if the units (dollars, percentages) and signs (positive/negative) are correct.
- The Skeptic: Actively tries to find errors and "sell" (reject) claims that look shaky.
The Market: Each trader places a "buy" or "sell" order on every claim. If the Accountant and the Skeptic both "sell" a claim (saying it's wrong), the market price for that claim drops, and it gets rejected. If everyone agrees, the price goes up, and the claim is accepted.
Why this matters: In normal AI debates, if three AIs agree on a wrong answer, they all sound confident. Here, even if the "Formula Expert" is confident, the "Skeptic" can short-circuit the whole thing if the numbers don't add up.

3. The "Synthesizer" (Building the Program)

Once the market clears (decides which claims are accepted), a "Synthesizer" agent writes a Python computer program.

The Rule: The Synthesizer is strictly forbidden from using any claim that the market rejected. It can only build with the "approved bricks."
Analogy: It's like a construction foreman who is only allowed to use the blueprints that passed the safety inspection. If a blueprint was rejected, they can't use it, even if they really want to.

4. The "Verifier" (The Safety Inspector)

Before the final answer is given, a "Code-Aware Verifier" runs the program.

The Check: It doesn't just check if the code runs without crashing; it checks if the code matches the logic of the market. Did the program accidentally flip a sign? Did it multiply by 100 when it should have divided?
The Repair: If the Verifier finds a silent error (like a wrong sign), it sends the program back for one round of repair, specifically pointing out the mistake so the Synthesizer can fix it.

5. The "Conflict Arbiter" (The Tie-Breaker)

Sometimes, the market is confused, or the program is weak. In these cases, a "Committee" compares the market's answer against a standard, non-market AI answer. If they disagree, a special "Arbiter" creates a third, hybrid answer that combines the best parts of both.

The Results: Why It Works

The authors tested this system on 10 different difficult benchmarks involving financial reports, complex tables, and charts.

The Outcome: MoCA-Agent consistently beat other top-tier AI models (including very large ones like GPT-4o and specialized financial models).
The Secret Sauce: It didn't just get better because it used a bigger brain; it got better because it stopped the AI from "hallucinating" confident but wrong numbers. By forcing the AI to agree on every single tiny fact before doing the math, it reduced errors significantly.

Limitations (The Fine Print)

The paper is honest about what this system can't do yet:

It's Expensive: It takes many more computer "thoughts" (API calls) to run this market system than a simple AI chat, making it about 5 times more expensive to run.
It Needs English: The system is currently tuned for English financial language. It might struggle with other languages or non-financial fields like biology.
One-Step Vision: If the input is a chart image, the system uses one tool to read the image. If that tool misreads a label, the "traders" don't get a chance to bet on it again; the error slips through.

In summary: MoCA-Agent is like a financial audit firm that doesn't trust anyone's word until they have signed off on every single number. It replaces "free-form chatting" with a structured, evidence-based marketplace to ensure the final math is actually correct.

Technical Summary: MoCA-Agent

Problem Statement

Financial and tabular question answering (QA) systems face a critical challenge: the requirement for answers to be grounded in exact facts, formulas, units, signs, and scales. Unlike open-ended chat tasks, financial reasoning has virtually no tolerance for "fluent-but-wrong" derivations. A single misread cell, swapped formula, or off-by-100-percent error can silently corrupt a final numerical result while the surrounding prose remains plausible.

The authors identify three recurring failure modes in existing financial code agents:

Silent Miscomputation: In Program-of-Thought (PoT) approaches, agents commit to a program once emitted. Even syntactically valid programs may divide the wrong cells or apply incorrect units, and downstream checks often only observe the final output rather than the underlying assumptions.
Opaque Aggregation: In multi-agent debate systems, agents aggregate whole answers or critiques. If multiple agents fluently derive the same incorrect number, the consensus becomes wrong with high confidence. These systems treat agent outputs as opaque votes rather than collections of typed claims that can be independently challenged.
Insufficient Structural Verification: Existing self-refine and code-repair frameworks rely on execution failures or free-form critique. They struggle to detect programs that execute successfully but utilize wrong facts, signs, or scales (e.g., flipping a net-of-tax sign or scaling a ratio by 100).

Methodology: MoCA-Agent

The paper introduces MoCA-Agent (Market-of-Claims Code Agent), a framework that replaces free-form multi-agent debate with a structured, claim-level verification protocol. The system decomposes questions into typed atomic claims, aggregates evidence via a simulated market, and synthesizes executable code only from market-supported evidence.

Core Pipeline

Claim Catalog Builder: The system decomposes the input tuple (Question $q$ , Table $T$ , Context $C$ ) into a catalog of $M$ atomic, tradable claims ( $K$ ). Each claim is typed as a fact, formula, unit, sign, direction (e.g., increase/decrease), or other. The catalog is capped at 10 claims to ensure tractability.
Specialist Trader Market: Four distinct trader agents ( $R$ $R$ ) independently evaluate each claim:
- EXTRACTOR: Grounds factual cells against the table.
- FORMULA: Validates that proposed formulas obey the requested operation.
- ACCOUNTANT: Cross-checks units and accounting conventions (e.g., revenue vs. expense).
- SKEPTIC: Actively sells (doubts) under-evidenced claims.
  Traders place weighted "buy" (support) or "sell" (doubt) orders with specific prices and notional sizes.
Market Clearing: The system aggregates orders to calculate a clearing price ( $\pi_m$ $π_{m}$ ) and confidence score ( $\gamma_m$ $γ_{m}$ ) for each claim. Claims are assigned a status: accepted, rejected, or uncertain.
- Accepted: $\pi_m \geq 0.62$
- Rejected: $\pi_m \leq 0.38$
- Uncertain: Otherwise
Synthesis: A synthesizer writes an executable Python program ( $P$ ) strictly using non-rejected claims. Rejected claims are filtered out before code generation.
Code-Aware Verification & Repair:
- A Code-Aware Verifier executes the program in a sandbox and applies operation-aware structural checks (e.g., verifying sign flips, percent scaling, and formula consistency).
- If the program fails structural checks, a Market-Aware Repair round is triggered, providing the synthesizer with specific structural error lists (e.g., "missing_formula_or_unit_claim") rather than generic feedback.
Conflict Resolution: If the market-grounded candidate is structurally weak, a Hybrid Selector Committee compares it against a baseline candidate (a single-agent writer without the claim market). If disagreements persist, a Conflict Arbiter generates a third program drawing on approved parts of both candidates.

Multimodal Extension

For chart reasoning, the system fills the table slot with a vision-language model (VLM) transcription of the chart. The rest of the pipeline (traders, synthesizer, verifier) remains identical to the text-only configuration.

Key Contributions

Failure-Mode Analysis and System Design: The authors formally identify silent miscomputation, opaque aggregation, and insufficient structural verification as primary failure modes in financial agents. They propose MoCA-Agent to make assumptions explicit as typed atomic claims.
Market-of-Claims Protocol: A novel protocol where specialist roles place weighted orders on typed claims. This creates an explicit audit trail of assumptions and allows the system to "short" over-confident formulas without rejecting the entire program.
Code-Aware Verification and Conflict Recovery: The verifier is elevated to a core routing component that targets specific silent-error patterns (signs, scales, units). The system includes a hybrid selector and conflict arbiter to handle unresolved disagreements between market-grounded and baseline candidates.
Benchmark Results: Extensive evaluation across 10 public benchmarks demonstrates the efficacy of aggregating evidence at the atomic claim level.

Experimental Results

MoCA-Agent was evaluated using a fixed Qwen3.6-27B backbone across four categories:

Financial Numerical Reasoning:
- FinQA: 78.3% (vs. 74.2% for Fino1-14B).
- FinanceMath: 76.0% (vs. 67.0% for GPT-4o PoT).
- DocMath-Complong: 50.7% (vs. 42.3% for DeepSeek-V3).
General Tabular Reasoning:
- MultiHiertt: 71.2% (vs. 56.8% for Fortune RL).
- TabMWP: 96.0%.
- WTQ: 81.4%.
Domain Knowledge QA:
- ESGenius: 86.9% (outperforming the strongest RAG baseline of 83.8% and zero-shot baselines).
Multimodal Chart Reasoning:
- FinChart-Bench: 85.6% average across True/False, Multiple Choice, and Open QA. It achieved 74.65% on Open QA, significantly outperforming Claude Sonnet 4 (63.59%).

Ablation Studies: Removing the Trader Market, Code Repair, Baseline Proposer, or Conflict Arbiter resulted in performance drops of 2.8% to 5.1% on average, confirming the complementary nature of these components. The gains were shown to be attributable to the agent architecture rather than the backbone model, as results held across different model sizes (9B to 31B).

Significance and Claims

The paper claims that aggregating evidence at the level of atomic claims, rather than whole answers, improves robustness in high-stakes numerical reasoning. By making assumptions explicit and allowing specialist roles to independently support or challenge specific facts, formulas, and units, MoCA-Agent mitigates the risk of silent errors propagating through the pipeline.

The authors emphasize that this approach is particularly effective in settings requiring multi-cell extraction and formula composition. They note that while the system improves traceability and reduces error rates, it does not eliminate the risk of incorrect answers. Consequently, they position MoCA-Agent as a decision-support artifact that should be reviewed by qualified humans before use in high-stakes financial, legal, or regulatory contexts.

Limitations Acknowledged

The paper explicitly notes four limitations:

Cost: The pipeline requires 6–10 LLM calls per query, roughly 5x the cost of a single-pass PoT agent.
Out-of-Distribution Layouts: The system assumes questions can be decomposed into $\leq 10$ claims; it underperforms on benchmarks dominated by column-header normalization (e.g., HiTab) where fine-tuned specialists excel.
Single Multimodal Step: Errors in the initial VLM transcription of charts are not re-evaluated by the trader panel.
Domain Specificity: The role biases and verifier checks are calibrated for English financial/accounting conventions and have not been validated for scientific, biomedical, or non-English contexts.