Foliome: Your Money, Your Machine, Your Agent

If AI existed from day one, how would personal finance be designed?

Here's how it works today. You pay a monthly fee to view your own money. You hand your credentials to a third-party aggregator so they can pull your transactions into one place. They promise all your accounts under one roof.

What you actually get:

• Half your integrations break.
• Not all platforms are supported.
• Your business bank shows a balance from three weeks ago.
• You're still logging into individual bank apps to re-authenticate MFA.
• You're still manually uploading CSVs for the accounts they can't connect to.
• You're still fixing things the aggregator was supposed to handle.
• The dashboard is fixed. You can't change what it shows you.

And while you're doing their job for them, they're selling your transaction data to advertisers who target you with credit card offers and personal loans timed for when you're most likely to take on debt.

You pay for the service. You do the work. You're stuck with their interface. And you're the product.

What I Built Instead

Foliome is open-source financial data infrastructure for AI agents. It's the plumbing that turns your agent into a financial operating system.

Here's what you get instead:

• Your agent logs into your banks, handles MFA, and downloads transactions automatically.
• Every platform is supported — because the agent builds the integration itself.
• Balances are current. Statement data is extracted. Nothing is stale.
• No CSVs. No manual uploads. No workarounds.
• The dashboard is whatever you need it to be. Ask for a view and the agent builds it.
• Credentials are encrypted. The LLM never sees your passwords. The system fails closed — if something looks wrong, it stops.
• Your data stays on your machine. No Plaid. No third-party access. No subscription.
• No one is selling your transaction data. No one is targeting you with debt.

What it gives you is something different: a financial intelligence layer that knows everything about your money and works exclusively for you.

The agent builds its own integrations. You point it at a bank URL. It explores the login page, figures out the MFA flow, discovers how to navigate to transaction downloads, and writes a deterministic automation config. First run is guided exploration with the LLM reasoning through each step. Every run after that is instant replay — zero tokens, zero cost. When a bank redesigns its site, the agent takes a screenshot, reasons about what changed, updates its own config, and the next run works again. It maintains its own integrations. You don't file a support ticket and wait.

The dashboard is whatever you need it to be. Want a subscription tracker? Ask for it. A quarterly breakdown by spending category? Ask for it. A tab that shows just your kids' expenses across all accounts? The agent has the data and builds the view. You're not on anyone's product roadmap.

And because the agent has your complete financial picture — every account, every balance, every transaction across every institution — it actually works for you. The same data that aggregators package and sell to advertisers becomes the thing that helps you make better decisions. You ask "how much did I spend on the kids' activities this quarter?" and get an answer in seconds that would have taken an hour across four bank apps. You ask "given my cash flow this month, should I pay down the credit card or fund the kids' education account?" and get analysis grounded in your actual numbers. Not a sponsored answer. Not an affiliate link.

No one is paying your agent to recommend a credit card.

What Using It Actually Feels Like

Foliome started as a sync engine. Point at banks, pull data, store locally. That was useful, but it turned out to be the foundation for something bigger. It's now a complete financial operating system.

Daily awareness. The morning brief tells me what happened overnight and what needs attention. Spending alerts flag unusual charges. Payment reminders track credit card due dates. I don't have to ask — the agent surfaces what matters before I think to check.

On-demand intelligence. I can query five years of transaction history in natural language. "How much did we spend on dining out in Q1?" "What's our monthly average for utilities?" "Compare grocery spending year over year." These are questions I never would have spent the time to answer before. I used to open three or four bank apps to piece together how much I'd spent on something. Now I ask one question and get one answer. The friction disappeared, and once the friction disappeared I started asking questions I never would have bothered with.

Investment visibility. Holdings across brokerage, retirement, and alternative investment accounts in one view. This was the thing I couldn't get any aggregator to do well — especially the accounts they don't natively support. Real estate estimates pulled from Zillow and Redfin. The net worth number includes everything.

A real dashboard on my phone. The Telegram Mini App gives me seven tabs: daily brief, account overview, transaction history, budget tracking, portfolio view, subscription monitoring, and an agent knowledge base wiki. It's the "aggregator dashboard" I always wanted, except I built it from my own data and I can change anything about it.

Agent memory. The agent remembers my financial goals, my family situation, which expenses are discretionary and which aren't. When it says "you mentioned wanting to max out your retirement contributions this year and you're behind pace," that's real context from weeks ago. It doesn't lose the thread between sessions.

The key insight: once you have clean, classified, locally-stored financial data and an agent that understands it, every feature is just a conversation. The infrastructure is the hard part. The intelligence layer builds itself.

Transaction Classification

Transactions get categorized through a four-tier pipeline that costs nothing to run:

1. Account-type implied — Transfers from a mortgage account are "Mortgage." Investment transactions are "Investment." Six categories are inferred from account type without any model.
2. Merchant rules — A local config of known merchants and their categories. Instant lookup.
3. Fine-tuned DistilBERT — For unknown merchants. Runs locally via ONNX, no API calls, no tokens burned. I fine-tuned this specifically on US bank transaction descriptions — the messy, truncated, reference-number-laden text that real bank exports produce. The model and training dataset are both open source.
4. Bank category fallback — If the export includes the bank's own categorization, use it as a last resort.

When the classifier gets something wrong, /category-override fixes it permanently for that merchant. I've overridden maybe 20 merchants total out of thousands of transactions. The pipeline handles the rest.

Credentials and Trust

This is the question everyone asks, and it deserves a straight answer.

Bank configs reference environment variable names, not values. At runtime, a Node script reads your local credential store — encrypted .env or Bitwarden vault — and Playwright types them directly into the bank's login form. The LLM never sees your credentials. A security gate verifies the domain and HTTPS before anything gets typed. Your financial data lives in local JSON files and a local SQLite database. Nothing leaves your machine.

Compare that to any aggregator where you type your bank password into their website and trust their infrastructure with everything.

Everything Is Open Source

Foliome is fully open source. You can read every skill, every primitive, every line of the classification pipeline. The transaction classification model and its training dataset are on Hugging Face. If you can run it locally, you should. If you can read the source, you should. If you can own the data, you should.

Your bank data is yours. Your transaction history is yours. Your net worth calculations shouldn't require someone else's server. The agent that manages your finances should run on your hardware, use models you control, and store everything locally where you can query it, export it, or delete it whenever you want.

What's Next

Foliome works today as a Claude Code project. That's step zero — ship it and use it daily. The roadmap from here:

1. Open harness. Claude Code is the runtime right now, but the skills and primitives aren't married to it. The next step is abstracting the agent layer so Foliome runs on other agent harnesses — OpenCode, Codex, whatever else emerges. If the architecture is right, the runtime shouldn't matter.

2. Fully local. The end state is no cloud LLM in the loop at all. The transaction classifier already runs locally. The sync engine already runs without tokens. The remaining dependency is the agent's reasoning during setup and edge-case recovery. As local models get good enough to handle visual exploration and config generation, that dependency goes away too. Everything on your hardware. Everything under your control.

Foliome is available now: github.com/wnstnb/foliome

For the technical details — how the agent builds integrations from scratch, how sync orchestrates ten banks in parallel, how the error recovery system works, how the dashboard authenticates — read the upcoming deep dive.