Ledger

Inspiration

As AI agents gain the ability to spend money, a successful API call is no longer enough to prove they did the right thing. A payment can execute perfectly and still happen twice, reach the wrong vendor, or skip approval.

We built Ledger Sentinel around a question: How can we check an agent’s financial behavior as it happens—and give people evidence they can inspect?

What it does

Ledger Sentinel is a live verification platform for AI agents that handle money. In a simulated company environment, buying agents pay bills and trade on an exchange with local Solana settlement. Sentinel checks their actions against policies such as “approval must come before payment.”

Each monitor produces one of three outcomes: satisfied, violated, or inconclusive. Findings that need attention appear in a review inbox with a counterexample timeline, supporting events, and settlement details.

The demo includes duplicate payments, missing approvals, budget breaches, vendor aliases, and instructions hidden inside bill memos. All financial activity is simulated.

How we built it

We built the backend in Rust, with Rig and Gemini powering the buying agents. OpenTelemetry captures agent and exchange activity, which our ingest pipeline turns into events with causal links. TimescaleDB stores those events, while Sentry provides tracing and logs.

We connected this event stream to Sentinel’s incremental verification engine. Gemini drafts specifications from plain-English policies, and Jev, from TypeSafe System One, supplies typed judgments for ambiguous questions—for example, whether two differently named vendors refer to the same obligation.

Deterministic checks handle amounts, identifiers, and currencies first. Semantic judgments enter only where those checks cannot decide.

The React and TypeScript interface streams verdicts into an evidence-backed review workflow.

Challenges we faced

The hardest problem was connecting precise financial rules to messy business language. Two payments might represent a duplicate, or they might be legitimate recurring rent. Different vendor names might refer to the same business.

We also had to handle uncertainty explicitly. Missing events, model timeouts, and ambiguous judgments cannot silently become successful checks. Those cases produce an inconclusive result so reviewers can see where the evidence stops.

Another challenge was making findings understandable. Detecting a violation matters, but showing the sequence of events that caused it makes the result useful.

What we learned

We learned that reliable agent oversight needs both deterministic verification and narrowly scoped semantic reasoning. Code provides clear boundaries; models help interpret language within those boundaries.

We also learned to treat observability as part of the product. Causal links and event timelines let a reviewer move from “something needs attention” to understanding exactly what happened.

What we’re proud of

Ledger Sentinel connects agent actions, policy checks, settlement records, and human review in one workflow. Its central principle is simple: every finding should come with evidence, and uncertainty should remain visible.

Built With

• ai
• gemini
• react
• runtime-verification
• rust
• solana
• timescale
• typescript