LedgerGuard

The Autonomous CFO circuit-breaker: intercepts AP invoice fraud deterministically, freezes liquidity rails via Dodo Payments, and negotiates vendor disputes.

Comment

Inspiration

Enterprise AP (Accounts Payable) teams lose over $300B annually to invoice fraud, ghost line-items, and rate drift. While the market is flooded with generic "AI invoice parsers," CFOs fundamentally cannot trust them: an LLM with a 95% accuracy rate is a catastrophic failure in corporate treasury, where a 5% hallucination rate can leak hundreds of thousands of dollars.

We built LedgerGuard on a contrarian architectural premise: Never let an LLM do financial arithmetic. Instead, decouple strict mathematical auditing from contextual diplomacy. Deterministic rules freeze the money; autonomous agents negotiate the dispute.

What It Does

Rather than just passively detecting spend, LedgerGuard reconstructs the entire Agent Economic Trace—validating contractual authority, enforcing sub-2ms deterministic reconciliation, locking liquidity on Dodo Payments rails, and piping immutable audit evidence into Neatlogs.

  • Deterministic 3-Way Audit: Ingests vendor invoices against Purchase Orders (POs) and executes strict mathematical verification in sub-2ms (1.46 ms) with zero hallucinations.
  • Instant Liquidity Circuit-Breaker: If any discrepancy is caught, LedgerGuard immediately triggers a programmatic circuit-breaker on Dodo Payments rails, freezing payouts before capital leaves the treasury.
  • Autonomous Contract Negotiation: An agentic CFO arbiter cross-references legal agreements (MSA terms) and negotiates pushbacks against vendor excuses with strict contractual grounding.
  • Self-Healing Settlement: When a vendor provides a corrected invoice, the system autonomously re-verifies the delta, clears the dispute, and unfreezes Dodo rails for instant settlement.
  • Immutable Observability: Every audit trace, agent debate span, token metric, and circuit-breaker trigger is recorded live on Neatlogs for real-time compliance.

How We Built It

  • Agent Orchestrator (AO): We used Agent Orchestrator with Claude Code and Aider harnesses throughout the entire development cycle to architect our sub-2ms deterministic engine, generate multi-vendor edge cases, and safely refactor our dispute pipeline without breaking production contracts.
  • Core Audit Runtime: High-performance Node.js / ES6 backend engineered for line-item differential parsing and zero-hallucination math.
  • Liquidity Rail Controls: Integrated with Dodo Payments API to programmatically hold, release, and auto-settle payouts.
  • Observability Layer: End-to-end telemetry and execution spans piped via Neatlogs SDK.
  • Frontend CFO War Room: Built with React and Tailwind CSS for real-time audit visualization and simulated vendor portals.

Challenges We Ran Into

Managing strict latency and execution order: ensuring the Dodo Payments circuit-breaker triggers synchronously in under 2ms before any automated disbursement occurs, while maintaining asynchronous dual-agent debate loops so audit pipelines never block.

Accomplishments That We're Proud Of

  • Achieved 1.46 ms deterministic verification across complex multi-line invoice schemas.
  • Successfully integrated Agent Orchestrator to automate testing and iterative code refactoring.
  • Verified over $2,300 in protected capital across 5 vendor audits with live immutable traces in Neatlogs.
  • Built a complete fail-safe model: deterministic code controls the money, autonomous agents handle vendor diplomacy.

What We Learned

Why enterprise CFOs reject black-box financial LLMs—and how wrapping deterministic circuit-breakers and deep observability around agentic workflows creates enterprise-grade autonomous finance.

What's Next For LedgerGuard

  • Two-way ERP sync adapters for SAP S/4HANA and NetSuite.
  • Dynamic multi-currency FX hedging and automated credit-note escrow reconciliation.

Built With

Share this project:

Updates

Submission history