Dashboard

TrustBooks

Tracks: Best Overall Product, EigenLayer, Merit Systems, Supermemory

Inspiration

We were inspired by a simple but painful truth: accounting automation has outpaced accounting security.
Every year, there are more and more accounting AI models that claim to solve financial automation, but they introduce new risks.

In 2025, Sheheen, Hancock & Godwin exposed 34,000 clients’ financial records after a ransomware attack, and Deloitte’s global email breach revealed how even the largest accounting firms can’t fully secure client data.

The problem isn’t just weak passwords or bad policy. It’s architecture.
Traditional accounting SaaS models store everything in one place. Centralized ledgers make sensitive data a single point of failure.

Our goal with TrustBooks was to reimagine accounting from the ground up: privacy-first, verifiable, unstoppable.
We wanted to build an AI accountant that even hackers can’t compromise, because our data is encrypted, verified, and never centralized.

What it does

TrustBooks is the first accounting system that combines AI automation with cryptographic verifiability.

Each transaction, invoice, or financial action generates a deterministic proof artifact, hashed and stored on-chain via EigenCompute.
Documents are processed through an encrypted RAG (Retrieval-Augmented Generation) pipeline, ensuring AI reasoning is auditable yet private.
Supermemory maintains contextual, user-owned financial memory — invoices, payroll summaries, and vendor histories — without ever exposing raw data.
Every proof is linked to an IPFS-hosted verification record, creating an immutable audit trail for regulators, auditors, and clients.

In short, TrustBooks replaces “trust us” with “verify it yourself.”

How we built it

We divided the build into three verifiable layers:

Agent Layer (Frontend & LLM)

Built using Next.js, TypeScript, and Echo SDK for OAuth and payment metering.
Integrated with OpenAI APIs for the RAG pipeline and a vector store for structured retrieval.

Proof Layer (Verifiability & Blockchain)

Implemented EigenCompute proofs for validation of ledger consistency and transaction integrity.
Uploaded proof artifacts to IPFS and emitted on-chain attestations to Ethereum Sepolia testnet using Ethers.js.

Memory Layer (Data Privacy & Intelligence)

Deployed Supermemory for encrypted long-term storage of financial facts.
Used local JSON stores and Merkle hashing to guarantee data integrity between sessions.

Backend stack: Node.js (Express), PostgreSQL (audit logs), Redis (proof queue), and Pinata/IPFS (proof storage).
Frontend: React + Tailwind with a glass-morphism UI, inspired by modern fintech dashboards.

Challenges we ran into

Proof generation latency: Initial EigenCompute validations took 25–30 seconds. We optimized by batching transaction checks and caching recurring ledger hashes.
Privacy vs. usability: Encrypting context limited AI recall. We solved this with an encrypted embedding layer — storing only vector hashes, not plaintext data.
On-chain event reliability: IPFS gateway failures occasionally broke proof lookups. We built a fallback queue to re-emit attestations with redundancy.
Team coordination: Merging the blockchain, AI, and memory components required strict schema versioning across microservices.

Accomplishments that we're proud of

Achieved fully verifiable financial proofs for invoices and expenses: each one queryable and hash-verified on-chain.
Integrated Echo-based metered AI usage, letting users pay per verified query with automatic accounting credits.
Built a secure RAG pipeline that can answer queries like “How much did Vendor X invoice in Q3?” without exposing underlying files.
Delivered a production-ready MVP with glass-morphism UI, real EigenCompute proof calls, and a live IPFS proof explorer.

What we learned

Privacy and verifiability are complementary, not opposites. With the right architecture, you can have both.
Proof artifacts are the missing piece in AI reliability: they transform black-box reasoning into auditable computation.
On-chain verifiability can be lightweight: hashes and URIs are enough to guarantee transparency without inflating costs.
Building cross-stack systems (AI + blockchain + encryption) demands continuous validation of assumptions — every layer must agree on what “truth” means.

What's next for TrustBooks

Expand to enterprise deployments with 1,000+ verified business accounts.
Integrate real-time EigenCompute proofs for continuous auditability.
Build auditor-facing dashboards that allow regulators to instantly verify transaction chains.
Long term: become the default privacy + proof layer for all AI-driven accounting software, replacing traditional audits with autonomous, verifiable assurance.