A deterministic memory layer for financial data, built so probabilistic AI agents can query and reason over it reliably. Not another chat history. A structured, reconciled record of what actually happened in the statements.
Memory, in the sense ChatGPT and Claude mean it, is what a conversational AI agent remembers about you across sessions: your preferences, past requests, the context it should carry forward. Financial memory extends that same idea to financial records — a place where an agent's memory of your finances is as durable and queryable as its memory of your conversation.
The difference is where the memory comes from. A conversation-derived memory layer remembers what was said. Financial memory is deterministic because it's document-derived and reconciliation-checked: every fact traces back to a specific page of a specific bank statement, and every balance is verified to carry forward correctly before it's trusted. An AI agent reasoning over it isn't reasoning over a summary someone typed once. It's reasoning over the source documents, structured and checked.
From the founder's LinkedIn post
The plan was never to just convert bank statements
Initially, I thought Bankstatemently would become a Financial Vision company. Over the past few months, I've concluded that's too narrow. Vision is only one part of the problem. Seeing is important, yes. But what comes next is understanding: Interpreting through a coherent model of reality. That - in my opinion - is still by far the hardest part of making financial document data usable.
AI models are becoming better eyes. The days of struggling with 90% OCR accuracy are largely behind us, and extracting data from financial statements keeps getting better. But what AI still struggles with is building a consistent representation of financial data, especially when the real world is full of inconsistencies, ambiguities, and different document formats.
That's why I'm starting to think of the future of Bankstatemently as Financial Memory instead. A place where financial data lives in one consistent, structured model. A deterministic memory layer that's easy for probabilistic AI agents to query and reason over.
If that memory layer exists, it shouldn't matter whether the reasoning comes from ChatGPT, Claude, or an open-source model
An AI agent asked to reason about a bank statement PDF today has to re-read and re-interpret it every single time, from scratch, with no guarantee it reads the same statement the same way twice. Financial memory inverts that: the statement is parsed once into a structured, verified model — transactions, balances, accounts, dates — and every agent that queries it afterward gets the same deterministic answer.
That structure is what makes financial data usable by an agent instead of merely visible to one. A language model can describe a PDF. It can't, on its own, guarantee that every transaction on every page was captured, or that a running balance carried forward correctly from one statement to the next. The memory layer does that verification once, up front, so an agent querying it later is reasoning over checked facts, not a fresh guess.
The REST API returns structured JSON: transactions, account metadata, and balances, resolved through the same deterministic pipeline used everywhere else on the site. Any agent framework that can call an HTTP endpoint can call this one — no PDF parsing logic of its own required. See the full reference at /developers/api.
The Model Context Protocol server exposes the same memory layer as a set of tools an agent can call directly: convert a statement, list statements, fetch a specific one, get account credits. It's the fastest way to give Claude, ChatGPT, Codex, Cursor, or a custom agent framework access to bank statement data without hand-rolling an integration. See /developers/mcp for setup.
Connect the MCP server, upload a statement (or point the agent at one), and ask a question in plain language: "What was my average monthly spend on software subscriptions?" or "List every transfer over $2,000 in the last quarter." The agent reasons over structured, reconciled data instead of trying to read the PDF itself, which is the difference between an answer you can trust and one you have to double-check by hand.
Accounting and bookkeeping agents built on top of an LLM inherit the same weakness every LLM has with source documents: they summarize instead of exhaustively capturing. A financial memory layer gives those agents a deterministic ledger to reconcile against instead — every transaction on every page, cross-checked for balance continuity, so an automated bookkeeping workflow isn't quietly dropping lines it never read correctly in the first place.
Connect via MCP in minutes, or try the API directly.