How I Actually Practice Accounting with AI in 2026

Last Tuesday at 7:14 AM, before I had finished my first coffee, an AI agent running on a small server had already reviewed every new customer contract my clients had signed in the previous 24 hours. It pulled each contract from Airtable, compared it line by line against QuickBooks, cross-checked the Stripe side for any subscription or invoice that should have been created, and ran 11 distinct verification rules against each one — wrong GL account, missing recurring transaction, billing-frequency mismatch, deferred revenue not booked, journal entries that didn’t tie. Across 24 new contracts, it caught three real problems and posted them to my team’s Slack channel before anyone was at a desk.

Three problems. Two of them would have eventually surfaced at month-end and required hours of unwinding. One was a Stripe subscription that hadn’t been created when a new deal was ingested — a single missed step in a 14-step ingestion pipeline — which meant the client wasn’t going to get billed on time. For two of them, the agent proposed the exact fix and our reviewer approved it with one click. For the third, the agent flagged it for a human to investigate. Either way, every customer gets looked at every morning — without anyone getting tired, distracted, or skipping a Tuesday because something else is on fire.

At a traditional bookkeeping firm, the work I just described — ingesting and then reviewing new deals every day, hundreds of deals per month, against three systems of record — would consume roughly two full-time employees. We do it with an agent. Close to zero human hours. By the time I read the Slack message, the analysis is done; the only thing left for a human to do is decide what to do about the three exceptions.

This is one workflow. It happens every morning. And it’s one of about thirty workflows like it that run across our firm — daily, weekly, and monthly. Some are simple, like processing a vendor invoice. Some are medium-complexity, like sending a customer a copy of an invoice when they ask. Some are very complex, like the deal-review agent I just described, or our inbound email pipeline, or month-end close. Every one of them runs the same way: an AI agent does the work, and a human is in the loop where judgment, sign-off, or a final read is the right move.

I run Clean Books, an AI-native bookkeeping and FinOps firm. This piece is the answer to the question people on my sales calls keep asking: what does “AI-native” actually mean? Not the theory. The workflow.

What does world-class actually mean for an accounting firm?

Every firm calls itself world-class, usually aspirationally. I’ve tried to define it in a way I can measure.

For us it means two things. First, every recurring task in a client engagement has been mapped, documented, and automated to the maximum extent possible. Second, the firm has the operations mindset required to keep that automation working as the business changes.

When we onboard a client, phase one is cleaning up the books — work any competent bookkeeper can do. The interesting question is what happens next. What’s left is a set of daily, weekly, and monthly recurring tasks — call it thirty distinct tasks for a moderately complex client. Each one is a candidate for automation. We didn’t build thirty at once. The first one we automated was sending invoice copies when a client asks — the smallest possible win, picked because if we got it wrong nothing exploded. The pattern from that workflow is the pattern across all thirty.

The agent does the data assembly, the cross-checks, and the first draft of the analysis every time. Some workflows post a finished report and a human just signs off. Some surface anomalies with a proposed fix and a human confirms with one click. Some need a person to make a real call — an unusual contract, a non-standard revenue treatment, a client question that needs a human voice. The human is in the loop where it adds the most value, not on every line of every reconciliation.

The second half of the definition is the part that’s easy to underestimate. Automation only compounds if the underlying data is structured to be fed into it. A single source of truth for contracts. A consistent chart of accounts across clients in the same vertical. A naming convention for vendors. None of that is glamorous, and none of it is what accountants are trained to do — it’s an operations function. The reason we can run thirty automated workflows per client is that we built the operations layer first.

The intersection of three things — being world-class at the books, being world-class at automation, and having the operations mindset to run both — is what makes it possible. Take any of the three away and it collapses.

Why build custom automations instead of buying accounting AI software?

There are plenty of off-the-shelf AI products for accounting. Categorizers, close-checklist generators, auto-coders, period-close workflow tools. Many of them are useful inside their lane. We don’t lean on them because the work that actually moves the needle for our clients isn’t something a product-shaped tool can hold. It’s specific business problems — this client’s deal-ingestion flow, that client’s deferred revenue treatment, this other client’s payment-processor reconciliation — that look different from one company to the next.

You can’t automate most of a small business’s finance function by buying things off the shelf, because no two of those businesses look alike below the surface. What works is the operations mindset: walking into a recurring task, understanding what’s actually happening, and building the smallest, most direct automation that eliminates the time it used to take. Sometimes that automation is a deterministic script. Sometimes it’s an AI agent following a written runbook. Sometimes it’s a one-page web tool a bookkeeper opens in the morning. The form follows the problem, not the other way around. The leverage is in the “specific automation for a specific problem” pattern, applied across thirty tasks per client, not in any one piece of technology.

The reason this is now realistic at our size is that two things became true at the same time. Every system we care about exposes an API — QuickBooks, Stripe, Airtable, Front, Google Sheet, Anrok and the rest — so we can reach into all of them, cross-check, and post results where the team works. And AI coding agents have collapsed the time it takes to build a working automation from months to hours. A specific automation for a specific problem used to be a six-figure software project. Now it’s an afternoon.

How does AI actually run day to day inside the firm?

People imagine AI in accounting means a chatbot that helps you write a vendor email. That’s the smallest possible version.

We run AI in three distinct shapes, each solving a different problem.

The first is conversational. We have an agent that lives in two places: a Slack bot for our team, and a chat panel embedded directly inside the web dashboards we’ve built for ourselves and our clients. It has access to all of our tools — QuickBooks, Stripe, Airtable, our internal databases — and it can both read and write. Ask it to find invoice #1234, check whether a customer’s recurring transaction is still active, or pull the GL for a vendor over the last six months, and it answers in seconds. Ask it to create a dozen journal entries or batch-create a set of invoices, and it does that too — staging each mutation for human confirmation first. That last part matters more than it sounds. QuickBooks is famously slow to navigate, and bulk operations through its UI take ages. Through the agent, work that would take twenty minutes of clicking takes thirty seconds of typing.

The second is autonomous workflows. These are agents that run on a schedule — every morning at 7 AM, every Sunday night, every first of the month — and perform the recurring work I described earlier. They don’t wait for a human to trigger them. They read from the systems of record, run their checks or transformations, and post results into Slack for human review. The deal-review agent I opened with is one of these. So is the email-triage pipeline. So is the month-end close engine. So is our sales tax workflow that pulls every taxable transaction from Anrok against QuickBooks each month and reconciles them. This is the layer that does the actual work of the firm.

The third is web applications. When the workflow needs a real interface — a dashboard, a portal, a form, something a client or a teammate can interact with — we build it. This part of what we do has grown into something we didn’t expect, so I’ve given it its own section below.

Why does a bookkeeping firm build its own dashboards and web apps?

One of the surprises of the last twelve months is how much value sits in building small, purpose-built web apps for ourselves and our clients. We’re not a software firm. But because everything we care about lives behind an API, and because AI coding agents have collapsed the time it takes to build a working app from months to hours, it’s now reasonable for us to ship a real internal tool or a real client dashboard in an afternoon. Two examples a year ago would have been a six-figure software project apiece. Now they’re a Tuesday.

A handful of what we’ve actually built:

The Hub. An internal portal that consolidates the live state of every workflow we run for a client — deal reconciliation status, open exceptions, recent activity, customer-level views — with an AI chat panel built in. From that panel a team member can ask a question, kick off a multi-step workflow that pulls from QuickBooks, Stripe, and Airtable, and make changes back to those systems, all without leaving the page.

A restaurant margin dashboard. Built for a restaurant client that had never had real per-menu-item profitability. Ingests point-of-sale data, joins it to ingredient costs, and produces a margin heat map that updates as costs change. The owner now sees per-item margin in two seconds. Before, getting that answer meant hiring a CFO for a week. Built in an afternoon.

A construction-project profitability dashboard. For a construction client who’d had “profitability by project” on their roadmap for seven years — the entire life of the business — and never been able to get it built. We built it for them in roughly an hour.

A multi-entity finance dashboard. For a client with three QuickBooks entities, consolidated P&L and balance sheet plus open AR and open AP in one view. Looking up “how much did we spend on this GL across all three entities over the last three months” used to take ten minutes of clicking through three QuickBooks files. Now it’s a two-second lookup.

None of these were on a product roadmap. They came out of one of three places: a bookkeeper saying “I wish I could see X in one place,” or a client saying “I’ve always wanted Y and no one’s been able to build it,” or us looking at how a client runs and saying “the owner should have this in front of them every day.” We can build them now because we have API access to every system that holds the data, and because the time-to-working-app has collapsed. We don’t do this because we’re a web-app shop. We do it because it’s the operations side of being a bookkeeper, and the tools finally exist.

When should a workflow use an AI model instead of a script?

Every workflow we run is governed by a plain-text instruction document. Call it a brief, call it a runbook — it’s the operating manual for the agent, written in plain English. It tells the AI what to check, in what order, what edge cases to watch for, when to escalate, what tone to use when posting to Slack. It’s years of accumulated bookkeeping judgment, written down once, and applied every time the workflow runs. Anyone on the team — or anyone we hire next year — can pick it up and run the same work to the same standard.

The less obvious decision behind every workflow is how much of it should be scripted code and how much should be left to the AI’s judgment. Our default is to script the deterministic parts — pulling data, doing the math, posting the message, writing the journal entry — and reserve the AI for the parts that actually require thinking. Scripts are cheaper, faster, and don’t drift. The AI is for the questions that genuinely need an answer that doesn’t fit on a checklist. The reason we can do this at all is that AI coding agents now make it reasonable for someone with our background to ship the scripted half. Two years ago, “just write a script for it” meant hiring an engineer. Today it means a focused afternoon.

Alongside every runbook we keep two companion documents — one logs the non-trivial design decisions and why, the other logs every bug we’ve found, its root cause, and a pointer to the test that prevents it from coming back. Boring discipline. It’s what keeps the system from drifting six months in.

What does an AI accounting workflow look like in practice?

Three examples, because I want this to be concrete.

The deal-review agent. Every customer my clients sign goes through an automated ingestion pipeline. A signed contract triggers a workflow that creates the customer in QuickBooks, books the invoice to the right GL account, applies the credit card fee if applicable, sets up a recurring transaction if it’s a subscription, defers the revenue if the contract crosses a fiscal boundary, posts the corresponding subscription or invoice in Stripe if that’s the payment rail, sends the client a welcome email with banking instructions, and updates an Airtable database we use as the system of record for active contracts. A new deal touches roughly fourteen distinct steps across four systems before it’s fully booked. At a traditional firm, with the volume of new deals my clients sign — call it 300 a month across the book — this would be two full-time people doing nothing else. We have zero people on it.

What we have instead is a daily agent that wakes up every morning and reviews every customer in the contract database against QuickBooks and Stripe. Eleven verification rules. Twenty-four active customers in the rotation right now. It checks that the QuickBooks invoice exists and matches the contract amount. That the recurring transaction is active and on the right cadence. That the Stripe side, if applicable, mirrors QBO. That the GL coding is right. That the deferred revenue schedule, if there is one, hasn’t drifted. It posts a structured report to Slack with anything that looks off. Last Tuesday it caught a Stripe subscription that hadn’t been created because the front-end automation had silently failed on a single field. The client would have stopped getting billed. We caught it in under 24 hours instead of at the end of the month, and the fix took fifteen minutes.

Stripe-to-QBO monthly reconciliation. Every month, for each of our Stripe-billing clients, we have to make sure the activity that flowed through Stripe agrees with what landed in the QuickBooks clearing account. Historically this is hours of cross-referencing two systems that don’t format anything the same way — one charge in Stripe can become two or three lines in QuickBooks (the charge itself, the Stripe fee, the payout), and a discrepancy can come from anywhere along the path. We have an agent that pulls the month of Stripe activity and the unreconciled lines from the QBO clearing account, matches them transaction by transaction, and produces an Excel workbook — matched pairs on one tab, unresolved items on another. The matched side is the bulk and almost always closes itself. For the unresolved items, the agent does the work of figuring out what’s most likely going on — a date mismatch where Stripe records a charge on one day and QuickBooks on the next, a Stripe fee that wasn’t booked, a posting that hit the wrong GL. For each one, it proposes the specific fix and presents the whole batch to a reviewer who can apply all of them with one click. The genuinely unusual cases — where the agent can’t produce a confident fix — get escalated for a full human investigation. The same work that used to be a half-day exercise is now a one-click approval of the routine items and a focused review of the handful that actually need a person.

Email triage that understands the difference between a question and a request. Every inbound client email hits our agent first. It identifies the customer, pulls the relevant context (open invoices in QBO or Stripe, recent thread history, the customer’s billing method, any prior conversations on the same topic), and classifies the email into one of more than twenty categories — invoice request, payment confirmation, billing-method change, dunning response, vendor onboarding, refund request, and so on. Once classified, it follows a category-specific template to draft a response and posts the draft into our inbox tool for human review.

The pipeline never sends automatically. Every draft is reviewed by a person before it goes out. The reviewer is reading a draft that’s already been built from the right context, with the right tone, citing the right invoice numbers — and judging whether to send it as-is or tweak it. We also score every draft on two dimensions before posting: how much of the substantive response came from the template versus the agent’s own judgment, and how confident the agent is in the result. The reviewer sees those scores and decides where to spend attention. Drafts that score 5/5 across both dimensions get glanced at and sent. Drafts that score 2/5 get a careful read.

For anything destructive — voiding an invoice, switching a client off Stripe — a second AI re-reads the original email and has to agree with the first before the action ever shows up for a human to approve. Two agents have to agree before something destructive even gets staged. We built that gate after a near-miss in the first month, and it’s the pattern we now apply anywhere the cost of being wrong is asymmetric.

Where is AI-native accounting going next?

I came into this from finance and operations, not software. Eighteen months ago I hadn’t written a line of production code in my life. Today every recurring task in our firm runs on a system I designed, deployed, and maintain — and every client engagement gets the benefit of that system without anyone having to think about it.

We’re building a firm where world-class bookkeeping is table stakes and the operations layer around it is the product. Automated workflows that catch things before they become problems. Dashboards that turn ten minutes of clicking into two seconds. An AI in chat that reaches into every system and does the thing rather than telling you how. This is what an accounting firm looks like in 2030, and we’re building it now because the tools finally make it possible.

Every workflow we automate makes the next one cheaper to build. Every piece of judgment we write down makes it reusable. Eighteen months in, the firm runs on a system that didn’t exist when I started. Eighteen months from now, it’ll run on one I can’t picture yet. That’s the part I’m betting on.

If you run a firm and you’re reading this thinking “where would I even start” — start with the one task your team complains about most this month. Not the hardest one. The most annoying one. That’s the first workflow.