Slowth Money：協助規劃財務目標的本地 AI 智能體

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

Personal finances can often be a source of stress.

Money management can have a big psychological impact. It consumes a lot of our attention.

This is why I built Slowth Money, a calm, local-first savings and financial goal-planning desktop app that leverages open-source AI to define strong boundaries between public resource sharing and private data kept on your local machine.

Slowth Money tries to minimize the stress of financial planning by embracing laziness through various forms:

• lazy planning - periodically checks whether any bank or financial provider offer is worth looking into
• lazy attention - only get notified when it's worth your time
• lazy data - pull relevant resources publicly while keeping your sensitive information private

Demo

Code

Check out the code on Github!

Feel free to fork it, experiment with it, and share feedback.

You could try adding your own country pack to run it from your own home for example.

Disclaimer: This is a proof of concept. It may contain bugs and incomplete features. Do not rely on it as financial advice.

No web deployment or cloud backend is required. The projects runs locally as an Electron desktop app.

JulienAvezou / Slowth-Money

Slowth Money helps users spend less time thinking about repetitive financial optimization while keeping sensitive financial information private.

Slowth Money

Slowth Money is a calm, local-first savings and goal-planning desktop app. Canada is the proof-of-concept market for the current MVP: its registered-account wrappers, public institutions, and deposit products provide a concrete way to validate the privacy and planning architecture. The longer-term design can support other markets through country-specific packs, provider adapters, schemas, and UI, but only Canada is implemented today.

Slowth Money helps answer four questions without turning personal finance into another feed to monitor:

• Am I on track?
• Do I need to do anything?
• Is the benefit worth my attention?
• What evidence supports that conclusion?

The hackathon MVP runs as an Electron app on macOS, keeps the private financial profile encrypted locally, performs financial math in deterministic TypeScript, and uses an open-weight model through local Ollama only when language reasoning adds value.

The internet knows what financial products exist.
The local model knows your financial situation.
Neither…

How I Built It

Slowth Money runds as a local desktop application.

- Electron for the desktop application
- React + TypeScript for the interface
- SQLite for local persistence
- Ollama for local model inference
- Gemma 3 12B as the open-weight model
- SerpApi for public web discovery
- deterministic TypeScript code for financial calculations
- native desktop notifications

I am running the application on an Apple M4 with 24 GB of RAM.

I built this project around an intentional privacy boundary:

The internet knows what the latest financial products are whereas the local model knows my financial situation. External services don't need to know about the latter by default.

To give you some examples of what is fed to my private context:

• salary
• savings
• debts
• financial goals
• family plans
• account balances

In the public context we can find:

• promotional rates
• fees
• financial programs
• contribution rules
• educational financial information

The core technical design decisions I took when building this project include:

• Attach a trust score to data

Recommendations use this trust score for the RAG context.

SOURCE TRUST

Government             1.00
Regulator              1.00
Financial institution  0.95
Established aggregator 0.75
Financial publication  0.70
General website        0.40
Forum / social media   0.20

• Periodic data fetching with configurable rules

How often should the agent check things?

App launches

        ↓

Market data older than 7 days?
        │
     YES│
        ▼
     Refresh

Country rules older than 30 days?
        │
     YES│
        ▼
     Refresh

Anything changed?
        │
     YES│
        ▼
     Load Gemma

• Rely on deterministic code vs AI when applicable

Most of the financial calculations don't require an LLM so I use normal code for them.

Things such as calculations over interest, fees, projected savings rely on application code.

The local model is only pulled in when language understanding or reasoning is needed.

• Make provider adapters for financial providers

The adapters support multiple providers and normalize their results.

Without this scraping would be unreliable as bank sites can change HTML, restructure pages, therefore making it hard to build a universal financial website scraper.

• Fine-grained notifications

The application can be configured to only notify about an opportunity that exceeds the user's financial opportunity laziness threshold. ie. how much financial benefit should this promotional rate offer to bother me with a notification.

Why Does Open Innovation Matter?

Privacy controls

This project got me thinking more about leveraging open-weight models to set boundaries on what sensitive information I want to keep private, my personal finances in this case.

I also have more abilities to inspect the processes surrounding the model reasoning.

Lower resource consumption

It also got me thinking about being less wasteful about AI consumption and only run inference periodically to stay on track with goals. Even your AI model should be allowed to be lazy at times!

I can run the model offline and ore transparent planning and insepction of the process.

Using open-weight model forces a better and more mindful usage of resources to make the setup work properly, which I consider a healthy source of friction.

Lower costs

This project is essentially free to run in my case with my current setup.

There is no per-request AI API fee to pay.

AI model interoperability

There is no lock-in to a company or model. If I want to switch model, I can do so very easily.

The Lazy Payoff

I used Slowth Money the past week to set some financial goals and keep track of financial provider's latest offers in my area.

When using this application I found myself not having to think so often about where my money should sit as I knew that Slowth Money was checking for me and helping me reach my financial goals in the background.

I also wanted more control on when I am bothered with notifications. In the context of my app, I can set the financial benefit control to only bother me if it exceeds a certain amount. I value my time and the notification should be worth opening.

Other than the benefits of the product itself, working on this project made me think about AI consumption itself.

That is also a different kind of lazy payoff:

• I don't need inference constantly
• I don't need all my data sent to a frontier model
• I don't need all my agents to live in the cloud

Prize Categories

Best Use of Gemma

Gemma is a good fit for Slowth Money because it provides me with a robust open-weight reasoning layer without requiring my personal financial information to leave the device.

The model efficiently handles tasks such as understanding financial goals, reasoning over relevant context and providing useful recommendations.

The model is also resource efficient, allowing me to run the model locally on my local machine while also processing other tasks in parallel such as browsing the internet and coding on other projects.

Best Use of SerpApi

SerpApi helped me bridge the private reasoning provided by Gemma and with the latest public data from financial products.

I used it as a discovery layer for public information such as new financial offers, current promotions, changes in regulated financial products.

SerpApi helped me keep fresh public knowledge whilst maintaining private local reasoning in parallel.

Closing notes

After sharing this project, I would love to know your thoughts.

What do you think of the privacy model? Of the architectural setup?

Do you have any feature requests? Optimizations? Design recommendations?

Do you have any useful tool you already use for your personal finances?

To help me gauge community interest for future development, consider starring the repository on Github if you find the idea interesting.