Meet Cameron: a personal finance agent you own and run

This is a short devlog marking the v1 release of Cameron, the companion agent we build in public across this blog. A full walkthrough article is on the way; for now, here's what shipped and where to find it.

Cameron is a local-first personal finance agent you own and run yourself: no data leaves infrastructure you control. But the reason it's worth writing about isn't the finance domain; it's the agent-building pattern underneath. v1 is where Cameron stops being a generic chat starter and becomes an agent you can hand real money to: an LLM reasoning loop, a set of tools it can call, and an approval gate that stands between the model and anything it would change. This devlog is about how those pieces compose; the technologies are just what we reached for to realize the pattern.

The three hard rules

Every version of Cameron holds these invariants:

1. Cameron never moves money or mutates financial records without explicit human approval.
2. Every capability — built-in, connector, or future skill — passes through the same approval gate.
3. All financial data stays on infrastructure you control.

What shipped in v1

Think of v1 as the smallest complete version of the pattern: a model that can decide, tools it can act through, and a gate that keeps it honest.

• Tools are the agent's hands. Cameron does nothing on its own; it acts by calling tools you define — log an expense, query transactions, analyze spending. Designing that tool surface (what the agent can reach, and how each call is described to the model) is the real work of building an agent, more than any prompt.
• An approval gate on every mutation. The load-bearing idea: reads flow freely, but anything that changes state pauses for you to approve or deny. This is what makes an autonomous agent safe to point at real money — the model proposes, you decide. Every future capability inherits the same gate, so safety doesn't erode as Cameron grows.
• Letting the LLM write SQL, safely. For open-ended questions ("what did I spend on groceries in Q2?"), Cameron writes its own guarded, SELECT-only SQL — the model gets query power without the ability to wreck your data. It's a small case study in the general problem of giving an agent a sharp tool with a safe handle.
• Human-in-the-loop as middleware. In modern agent frameworks, middleware is a pluggable step you insert into the agent's loop — intercepting a tool call before it runs, without rewriting the agent. Cameron's approval gate is exactly that: LangChain's humanInTheLoopMiddleware, configured to pause only on mutations. The pattern is the lesson; the specific middleware is just the implementation.

Everything is grounded in a store Cameron owns rather than reading your accounts live, so any reader can run the exact same agent on seed data and reproduce it.

The stack, in one line: LangChain / LangGraph v1 createAgent running in-process inside Next.js (no separate agent server), Postgres via Drizzle, and the LangGraph Postgres checkpointer for memory; Anthropic by default, with OpenAI and Google supported.

Try it

Cameron is open source and runs on seed data with zero real accounts:

• Repo: github.com/agentailor/cameron
• v1 release notes: the "Meet Cameron" release

Next up is v2 — Memory: budgets and preferences as long-term memory, plus summarization of aging history. Follow the whole arc on the Cameron hub.