I've been building a deterministic verification engine for AI-generated financial claims.

The basic idea is simple:

An LLM can generate a financial answer, but the LLM itself should not be allowed to decide that its answer is "verified."

Instead:

LLM generates a claim ↓ Structured claim ↓ Evidence binding ↓ Compatibility checks ↓ Conflict detection ↓ Deterministic calculations ↓ Versioned rules ↓ VERIFIED / CONTRADICTION / BLOCKED / etc. 

I recently ran a 66-case benchmark in two modes.

1. Fixture-based claim input

When the deterministic engine received the expected structured claims:

66/66 cases passed.

2. LIVE_CLAIM mode

I then used Azure OpenAI with GPT-5.1 to generate the claims that entered the same verification pipeline.

Result:

19/66 cases passed.

Failure breakdown:

• 31 PIPELINE_EXECUTION_FAILURE
• 18 CLAIM_BINDING_FAILURE
• 2 CONTRADICTION_DETECTION_FAILURE

At the same time, several verification dimensions scored perfectly:

• Evidence graph integrity: 25/25
• Deterministic calculation: 25/25
• Rule application: 25/25
• Missing evidence detection: 25/25
• Reproducibility: 25/25
• Auditability: 25/25

So the interesting result isn't simply "the benchmark failed."

It seems to show a separation between two problems:

Problem 1: Can the deterministic verification engine correctly evaluate a properly structured claim?

In this benchmark: 66/66.

Problem 2: Can an LLM reliably translate its output into the exact structured claim required by a deterministic verification system?

In this benchmark: clearly not yet.

The majority of failures happened before or around claim binding and pipeline execution rather than deterministic calculations or rule application.

My next step is to add much more granular diagnostics and compare:

Expected fixture claim vs Raw LLM output vs Normalized claim vs Verifier input 

I'm particularly interested in feedback from people working on:

• LLM structured outputs
• agent reliability
• deterministic verification
• formal methods
• financial systems
• evaluation benchmarks

Would you treat this as evidence that the verification architecture is working but the LLM-to-formal-system translation layer needs work, or do you see a more fundamental issue with the benchmark design?

I’m happy to share more details about the benchmark methodology and failure taxonomy if people are interested.

https://preview.redd.it/eqio3da2fpkh1.png?width=1536&format=png&auto=webp&s=07a92563c52a489f088bd4b2837d55ce1e417c0a