How We Cut Monthly Invoicing From an Hour to Five Minutes — With an AI Agent Named Freddy

It's invoice day again.

If you run an agency or a services business, you know the feeling. Once a month, someone has to sit down and bill every client. For us, that meant opening Frappe, picking a customer, adding the line items, the hours, the cost, the description of the work — then doing it again for the next client, and the next. Across all our clients, it took about an hour. Not hard. Not urgent. Just tedious enough that it always got pushed to the end of the day.

We gave that hour to an AI agent named Freddy. Now it takes about five minutes. Here's the honest account of what we built, what it actually changed, and where we'd tell you to be careful.

The chore that never goes away

Monthly invoicing is the perfect small, annoying task. It's repetitive. It's predictable. It has to be exactly right, because it's money. And it never stops showing up — you finish this month's batch and next month's is already on its way.

It's also the kind of work that quietly taxes a team. Nobody's day is ruined by it, but everybody puts it off. The information rarely changes much month to month: same clients, similar line items, hours and amounts you already know by the time you sit down. You're not solving a problem — you're assembling something by hand that you've assembled forty times before.

That's what made it a good first candidate to automate. Small, well-defined, repeating, clearly bounded. If we were going to hand any task to an agent, we wanted one where the rules were obvious and the stakes were contained.

Why we built it for ourselves first

We have a rule we don't break: we don't recommend something to a client until we've lived with it ourselves.

That's the same instinct behind building Formester, our own SaaS product. Running our own product taught us things you only learn when the thing is yours — the boring edge cases, the parts that look clean in a demo and get messy in real use. We build client products like they're ours because we know what owning one actually feels like.

So when we got curious about AI agents doing real back-office work, we didn't write a deck about it. We tried it on our own invoicing — a chore we genuinely disliked, with real money attached, where a mistake would be our mistake. If it worked on us, we'd have an honest story to tell. If it didn't, we'd learn that quietly, on our own time.

We'll say the modest part up front: this is a small use case. It didn't change our business. It gave us back an hour a month and removed a chore we all avoided. That's the whole claim — and it's a true one.

Meet Freddy — a finance agent, not a feature

We wanted an AI agent for invoicing, so we built one — and gave him a name. Freddy isn't a button we added to a tool. He's an agent with a job.

Freddy is a Claude agent whose entire role is the financial side of things — the kind of teammate you'd hand the invoicing to. He has one main skill: generating invoices. That narrow scope is the point. We didn't build a do-everything assistant; we built a finance agent who does finance.

What makes a dedicated agent like this practical is how he's run. Freddy lives in his own isolated container — his own memory, his own instructions, and access only to the things we explicitly hand him. For a task that touches money, that isolation matters. Credentials don't sit loose inside the agent's sandbox. A money agent should be a money agent, walled off from everything else, and nothing crosses that boundary unless we wired it in on purpose.

That's not a nice-to-have for a finance task. It's the reason we were comfortable doing it at all.

The stack, named honestly

Here's the real setup, with credit where it's due.

Freddy runs on NanoClaw, an open-source harness for running Claude agents in isolated Docker containers. It's what gives each agent its own container, memory, and scoped access. It runs comfortably on modest hardware, so we put it on a Mac mini at home that the whole team can reach, quietly doing its job. Running an AI agent on a Mac mini turns out to be a very reasonable thing to do in 2026 — you don't need a server farm for this.

The pieces that make it useful for our invoicing are things we built on top of NanoClaw, not features it shipped with:

• Frappe is our invoicing system of record — it's where our invoices have always lived, long before Freddy existed. Freddy's skill drives Frappe; Frappe still does the actual invoice generation. NanoClaw didn't bring Frappe; we connected the two.
• The invoice-generation skill is ours. We wrote it to teach Freddy how to turn "this client, this work, this amount" into a correct invoice in our system.
• The Gmail send is ours too. NanoClaw ships with email out of the box through Resend; we wanted invoices to go out from our own Gmail, so we wired up that integration ourselves.

We're spelling this out because the difference matters. NanoClaw is the harness — the thing that safely runs the agent. The integrations that make Freddy useful to us are skills we built. If you go try this, that's the work: not installing the harness, but teaching the agent your tools.

How it works now — a voice note on WhatsApp

Day to day, talking to Freddy looks like texting a colleague.

We message him on WhatsApp: "Invoice this client, for this work, this amount." Freddy takes it from there — he generates the invoice in Frappe, drafts the email with the invoice attached, and sends it from Gmail.

There was one bit of friction left. Typing out the details on a phone was just enough of a hassle that we'd still put it off. So we added voice-to-text to our WhatsApp setup. Now we just say it out loud — "make an invoice for this client, for this work, this amount" — and Freddy does the rest. That voice step is our own setup choice, not something the harness handed us. But it's the small change that finally made the whole thing effortless.

That's it. A spoken sentence in a chat app, and the invoice is on its way.

One hour to five minutes — the honest result

The headline is simple: about an hour a month became about five minutes.

It's worth being precise about what changed and what didn't. The invoices are the same invoices — same Frappe, same format, same correctness. What disappeared was the manual assembly: the clicking, the line-item entry, the copy-pasting, the "wait, did I bill this one already." We still get accurate invoices to the right clients; we just don't build them by hand anymore.

We always glance at what Freddy produces before it goes out. It's money — a human look costs seconds, and we're not giving that up. But the work went from an hour of dull data entry to a quick spoken request and a quick review.

Small win. Real win. We'll take an hour back every month, gladly.

What we learned (and where we'd be careful)

A few things stood out — and they're the parts worth borrowing:

Scope the agent tightly. Freddy does one thing. One job, one skill. A narrow agent is easier to trust, easier to check, and far less likely to surprise you than a sprawling assistant trying to do everything.

A money task wants isolation — and a human glance. The container boundary is why we were comfortable pointing an agent at our finances. And we still review before anything sends. For anything financial, keep a person in the loop on the way out the door. The agent assembles; a human approves.

An agent is only as good as the system behind it. Freddy didn't replace Frappe — he drives it. Frappe is still the source of truth, still doing the real invoice generation. The agent is the friendly front door; your system of record still does the heavy lifting. Automate the interface, not the integrity.

The last bit of friction is the one that matters. We had this mostly working with typed messages and still weren't using it consistently. Voice-to-text — a tiny addition — was what made it stick. When you're automating a chore people avoid, the goal isn't "possible." It's "effortless."

Who this actually helps

If you run an agency or a services business that bills multiple clients every month, you feel this exact pain — and a pattern like this is worth borrowing. The same goes for mid-size ops teams sitting on small, repetitive, well-defined back-office chores: the recurring stuff that's never a crisis but always a drag.

We'd gently push back on treating it as a cure-all. This works because the task is small, bounded, and rule-governed, with a system of record already doing the real work. That's the sweet spot. The further you get from "small, repeating, clearly defined," the more carefully you'd want to think it through — especially with money involved.

But for that one nagging monthly chore? It's a genuinely good fit.

A small thing, done well

We didn't set out to reinvent how anyone works. We had a chore we disliked, and we were curious whether an agent could quietly take it off our plate. It could. An hour became five minutes, the invoices still go out correctly, and invoice day stopped being a thing we dread.

We're always tinkering with how we run our own shop — and that same curiosity is what we bring to the products we build with our clients. If you're weighing where automation actually earns its place in your business, we're happy to talk it through. No pitch, no pressure — just an honest conversation about what's worth doing and what can wait.