Foliome: A Personal Finance Skill Pack for AI Agents
I didn't want to pay money to view my money.
Every aggregator I've tried either charges a subscription to show you your own data, doesn't support half your institutions, categorizes transactions wrong, or requires you to hand your credentials to a third party and trust that their Plaid integration keeps working. Mint shut down. The replacements want $10/month and still can't pull my 529 data. I have accounts at 10 different banks and none of it made sense to me.
So I built something different.
What Foliome Is
Foliome is a skill pack that gives Claude Code (or any AI agent that reads SKILL.md files) full personal finance capabilities. 10 skills covering sync, queries, analysis, and management. No Plaid, no paid APIs, no third-party data access. Everything stays on your machine.
| Skill | What it does |
|---|---|
/sync | Sync all institutions with background execution, MFA handling, import, classify |
/learn-institution | Build a new bank integration by visually exploring the login flow |
/morning-brief | Daily summary with net worth, recent activity, due dates, alerts |
/spending-alerts | Detect large charges, low balances, unusual spending |
/payment-reminders | Credit card payment due dates with tiered alerts |
/spending-query | Natural language questions like "how much on restaurants?" |
/investment-brief | Portfolio allocation, holdings breakdown, dividend activity |
/net-worth | Net worth snapshot and historical trends |
/transaction-analysis | Structured spending reports by category/period with optional CSV export |
/category-override | Reclassify transactions via natural language |
The whole thing is open source. You can read every line before you run it.
Your Agent Builds Its Own Integrations
Foliome doesn't ship "support for 10 banks." It ships primitives and a skill called /learn-institution that uses those primitives to build integrations with any institution.
You point the agent at a bank URL. It visually explores the login page, figures out the MFA flow, discovers how to navigate to transaction downloads, identifies the download pattern, and writes a deterministic Playwright config. The agent handles iframes, shadow DOM components, custom web elements, backdrop overlays, landing pages that hide the login form behind a button, multi-step login flows with method selection. Every bank has its own version of these problems.
First run is LLM-guided exploration. The agent is actively reasoning about what it sees on the page. After that, daily syncs use the config it wrote. Deterministic execution, zero LLM cost. The agent only comes back when something breaks (a bank redesign, a new MFA flow, a changed download path).
I didn't set out to build a taxonomy of bank download patterns, but six distinct ones emerged as I added institutions. Some banks let you export all accounts from a central download dialog. Others make you navigate to each account individually. A few don't offer CSV at all, so LiteParse extracts text from PDF statements and the agent parses out the transactions. There are banks that require selecting a date range from a calendar modal, banks with a single export button (bless them), and banks that generate reports asynchronously where you request, wait, then download. Each bank I added forced the primitive to grow to handle the next weird thing.
What Using It Actually Feels Like
I open Telegram in the morning, say "good morning," and the agent tells me my net worth, what transactions posted overnight, and what credit card payments are due soon. Most mornings that's all I need. Sometimes a charge looks off and I dig in from there.
The spending queries have replaced a habit I didn't realize I had. I used to open three or four bank apps to piece together how much I'd spent on something. Now I just ask. The database has thousands of transactions spanning five years across all 10 institutions. "How much on food this month" gets me a number in seconds. I've started asking questions I never would have bothered answering before, because the friction is gone. "What did I spend on the kids' activities this quarter?" Would have taken me an hour across four accounts before. Now it's one sentence.
The investment brief pulls holdings across brokerage, retirement, and 529 accounts into one view. This was actually the thing I couldn't get any aggregator to do well, especially the 529 data.
If the classifier gets a merchant wrong, /category-override fixes it and the correction persists for future transactions from that merchant. I've probably overridden maybe 20 merchants total. The local DistilBERT model gets it right often enough that I rarely think about classification anymore.
Works from the terminal at my desk and Telegram on my phone. Same skills, same data.
How It Works
Three layers. Primitives acquire data: Playwright for bank websites (handles MFA, popups, every login variant), REST/OAuth for brokerages and business banking, public sources for real estate valuations. A normalized SQLite database stores everything locally with dedup and automatic classification via a local DistilBERT model. No API calls for classification. Skills query that database and present information through Claude Code or Telegram.
Parallel Sync and MFA
Running /sync kicks off all institutions in parallel. API connectors finish instantly. Browser-based banks run simultaneously, each in its own Playwright context with a persistent Chrome profile.
When MFA triggers, the system sends a notification to Telegram. You can respond with all your MFA codes in a single message and the orchestrator routes each code to the correct bank session. You're not entering codes one at a time across 10 browser windows.
Persistent Chrome profiles mean MFA triggers less often over time. After the first authenticated session, most banks remember the device. Some banks haven't asked for MFA in weeks.
Credentials and Trust
This is the question everyone asks, and it deserves a straight answer.
The architecture doesn't require the agent to touch your passwords. Bank configs reference environment variable names, not values. At runtime, a Node script reads your local .env file and Playwright types credentials directly into the bank's login form. The LLM isn't in the loop during login.
That said, any coding agent with filesystem access can technically read any file on your machine, .env included. This isn't a Foliome-specific problem. It's an agent permissions problem that the entire ecosystem is working through. Claude Code, Codex, OpenCode, any of them can cat .env if they choose to. The .gitignore keeps credentials out of version control, but local file access is inherent to how coding agents work.
What I can control: credentials never leave your machine (no Plaid, no third-party credential relay). A security gate verifies the domain and HTTPS before any credentials are entered, so the automation won't type into a page it doesn't recognize. The credential injection code is straightforward and readable, and it's one of the first things I'd point anyone to for an audit. Transaction data lives in local JSON files and a local SQLite database. Your financial data never hits someone else's server.
Compare that to any aggregator service where you type your bank password into their website and trust their infrastructure with everything.
Transaction Classification
Transactions get categorized through a three-phase pipeline that costs nothing to run:
- Merchant rules check against a local config file of known merchants and categories. Instant.
- Cache of previously classified merchants. If the pipeline has seen "TRADER JOE'S" before, it reuses the classification. Instant.
- Fine-tuned DistilBERT model for unknown merchants. Runs entirely on your machine, no API calls, no tokens burned.
I fine-tuned this model specifically for Foliome. Off-the-shelf classifiers couldn't handle real bank transaction descriptions. They're messy: truncated merchant names, reference numbers mixed in, every bank formats them differently. So I built a training dataset of US bank transaction categories and fine-tuned DistilBERT to handle what actual bank exports look like. The model and the dataset are both open source.
The categorization isn't perfect. Some merchants get misclassified, especially small local businesses. But you fix them once with /category-override and the correction sticks.
Everything Is Open Source
Foliome is fully open source. You can read every skill, every primitive, every line of the classification pipeline. If you can run it locally, you should. If you can read the source, you should. If you can own the data, you should.
I don't believe in building tools that hold your information hostage behind a subscription. 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.
Foliome is available now: github.com/wnstnb/foliome
Ten banks. Zero subscriptions. Everything on your machine. Pull it down, point it at your banks, and let the agent figure out the rest.