MCP Is Where AI Finance Gets Useful

There is a big difference between an AI that can look at your money and an AI that can update the place where your budget actually lives.

That difference matters more than the launch headlines make it sound.

MCP (Model Context Protocol) gives assistants a way to call tools in real apps. In personal finance, the first wave mostly solves data access: connect accounts, read transactions, answer questions. That is already a big step. But budgeting is not just “what happened?” It is “what do I need to change before the month gets away from me?”

That is where read-only finance AI reaches its current edge.

ChatGPT Finances is a big step

On May 15, 2026, OpenAI announced Finances in ChatGPT. It lets U.S. Pro users connect financial accounts in ChatGPT on web and iOS.

The connection runs through Plaid. Once accounts are synced, ChatGPT can categorize data and show a dashboard with spending, subscriptions, upcoming payments, portfolio performance, and related finance context.

I think that is genuinely useful.

People already ask ChatGPT money questions. If someone is asking, “Where did my money go this month?” it is better for ChatGPT to see real transactions than to work from a vague paragraph the user typed from memory. A model with actual account data can spot patterns faster, ask better follow-up questions, and avoid making the user copy numbers across apps.

That is a real improvement.

The only thing missing, for now, is the ability to update the budget itself. I would be surprised if OpenAI does not keep expanding this. They are clearly starting from the safest version first, which is exactly what I would expect for a broad consumer finance feature.

Memory is not a budget

At time of writing, June 7, 2026, OpenAI says ChatGPT can access balances, transactions, investments, and liabilities, but it cannot see full account numbers or make changes to accounts. That is a reasonable safety line, and honestly a smart starting point.

The more interesting missing piece is what happens when the data is wrong.

The OpenAI Finances help center says a spending breakdown can be inaccurate if transfers, reimbursements, duplicate pending transactions, or category choices are off. It also says users can ask ChatGPT to explain what it included, reclassify anything that looks wrong, and remember relevant corrections for future finance conversations.

That can make the next answer better. It is not the same thing as updating a budget.

If a restaurant transaction is categorized wrong, there is a practical difference between:

• “Remember that I count this as dining out.”
• “Change this transaction’s category in my budget.”

The first changes context. The second changes the system of record.

That distinction matters a lot in envelope budgeting. If the assistant cannot create a category, move money between envelopes, update assigned amounts, or mark transactions as reviewed, then it can explain the budget but it cannot help maintain it.

For where ChatGPT Finances is today, that is fine. It is still early. It just means the product is strongest at understanding and planning, not at maintaining a budget.

Driggsby is a strong MCP version of this

Driggsby is more direct about what it is: an MCP server for your money.

You connect accounts through Plaid, then use an MCP client like Claude, ChatGPT, Codex, or another compatible assistant to ask questions against structured tools. Its public tool list includes things like:

• get_overview
• search_cash_transactions
• list_investment_holdings
• search_investment_activity
• list_recurring_transactions
• query_cash_sql
• export_cash_transactions

That is a great shape. The assistant gets real financial data through typed tools instead of scraping screens or asking the user to paste CSVs. For a lot of people, that alone is enough to make an AI assistant meaningfully more useful.

Driggsby is also explicit about the safety boundary. Its agent-facing docs say financial institution access is read-only. It can view balances, transactions, liabilities, holdings, and investment activity. It cannot move money, make payments, place trades, or modify linked financial accounts.

It can manage Driggsby-owned custom net-worth items if the user asks. But its current public docs do not position it as a full budgeting system where the assistant edits envelope assignments, creates spending categories, or maintains transaction categories as part of a monthly budget.

That is not a knock. I like what Driggsby is doing. If the job is “let my AI answer questions about my finances,” Driggsby is a strong version of that idea.

I also expect this gap to close quickly. From what I understand, Driggsby is actively working on write capabilities too, which makes sense. The read-only version proves the data layer. Write tools are the natural next step.

Era is closer to the write-capable future

Era is closer to the direction I find interesting.

Era Context is a personal finance MCP server that connects financial data to assistants like Claude, ChatGPT, and Cursor. Its MCP docs list read tools, but they also list write-capable tools for transaction updates, spending category management, transaction tags, automation rules, manual transactions, transfer links, account visibility, and memory.

That changes the shape of the product.

Instead of only asking, “How much did I spend on coffee?” a user can ask the assistant to clean up messy coffee transactions, tag them, categorize them, and create a rule so future transactions stay cleaner. Era’s docs describe that exact kind of loop: read the data, make a small approved change, then rerun the analysis to prove the answer changed.

That is much closer to useful financial automation.

The assistant is not just summarizing the past. It is maintaining the data that future summaries depend on.

Where Kualia fits

This is also the line I care about with Kualia.

The Kualia MCP server can read the normal things a budgeting assistant needs: transactions, envelopes, recurring bills, reports, income summaries, category targets, monthly summaries, category rollups, and account balances.

But it can also write with approval. It can:

• Assign money to categories.
• Create, update, delete, and restore transactions.
• Create, update, archive, reorder, and sort categories.
• Create, update, archive, reorder, and sort category groups.
• Create, update, and delete category targets.
• Reconcile accounts.

That is the difference between “tell me I overspent dining out” and “move $40 from Fun Money to Dining Out so the budget is accurate again.”

I wrote more about the plumbing in How I Built the Kualia AI Assistant, but the short version is this: the in-app assistant and the public MCP server share the same tool registry. Reads and writes go through the same dispatch path, with scopes and workspace checks in front of the actual data changes.

That architecture matters because write access is not something to bolt on casually.

A finance assistant should not have a giant “do anything” button. It should have small, named tools with clear inputs:

• Read this month of envelope status.
• Set this category’s assigned amount.
• Update these selected transactions.
• Create this category target.

The assistant can reason about what needs to happen, but the app still enforces what is allowed.

Read-only is not wrong

I do not think every finance assistant needs write access on day one.

Read-only tools are easier to trust. They are also enough for a lot of questions:

• “What did I spend last month?”
• “Which subscriptions increased?”
• “What is my net worth?”
• “Did grocery spending change after I switched stores?”

For that, ChatGPT Finances and Driggsby make sense. They are good products for those questions, and I expect both of them to get more capable quickly.

But budgeting is a maintenance habit. The useful moment is often not the answer itself. It is the tiny fix that follows the answer.

You see a transaction in the wrong category. You move it.

You notice a bill went up. You update the target.

You overspend an envelope. You cover it from somewhere else.

You add a new recurring expense. You create the category before it surprises you again next month.

If the assistant cannot make those changes, the user still has an extra handoff. They get the advice in one place, then do the budget maintenance somewhere else.

That is still useful. It is just not the end state.

The safety model

The right safety model is not “never write.”

It is scoped tools, clear permissions, OAuth, and user-approved changes.

For personal finance, that means a few practical rules:

• The assistant should only see data the user already has permission to see.
• Read tools and write tools should be separate.
• Write tools should be narrow and auditable.
• Destructive actions should require extra care.
• The app should validate every ID, amount, category, account, and workspace server-side.
• The user should be able to disconnect the assistant.

That is how MCP gets interesting. Not because it lets an AI “manage money” in some vague sense, but because it gives the app a typed surface area where a model can do useful, bounded work.

Read-only finance AI is good for questions.

Write-capable MCP is good for maintenance.

Envelope budgeting needs both. It needs the assistant to understand what happened, and it needs the budget to reflect what the user decided to do next.

That is what I am building toward in Kualia.