Digits

Digits Adds 11 New Quality Checks

Wed, 16 Sep 2026 00:00:00 GMT

When we launched Quality Control as part of the Agentic Close in June, we knew accountants would love having Digits automatically flag things like missing categories, low-confidence categorizations, and missing vendors, customers, receipts, and bills.

We also knew this was just the start. Sure enough, we were quickly overwhelmed with requests for more checks!

Today, we’re adding eleven new Quality Control checks, available for everyone on our public plans with no price changes or upgrades required!

What's new

Balances on the wrong side (3) — an asset with a credit balance, a liability with a debit balance, or negative revenue usually means something was posted backwards or a transaction is missing.
Negative Asset
Negative Liability
Negative Revenue
Clearing and suspense accounts that didn't net out (1) — money parked in transit that never made it to its destination.
Non-Zero Clearing
Equity movements net income doesn't explain (1) — changes to equity that didn't come from earnings and need a reason.
Equity Fluctuation
Significant balance sheet changes (3) — large swings in assets, liabilities, or equity relative to prior periods.
Material Asset
Material Liability
Material Equity
Coding inconsistencies (2) — transactions for vendors or customers that span more than one category.
Multiple Categories for Vendors
Multiple Categories for Customers
Sensitive data in descriptions and memos (1) — names, account numbers, and other personal information that shouldn't live in the ledger.
Personally Identifiable Information (PII)

How it works

Once you enable checks for a client, Digits runs them continuously and deterministically as that client's transactions post. You don't have to schedule them or remember to run them. Set them once, and they run every period after that. When something trips a check, it appears in your Checklist with the context you need to review it: the account, the amount, and what the check looked for.

Digits won't silently change the books. It surfaces the exception for you to decide whether it needs a correction.

Completely customizable

You can also use plain-English agent instructions for each client’s books to tune what surfaces next time.

Suppose the Transaction in Parent Category check flags a handful of transactions a client booked to "Cost of Goods Sold" at the top level. You reclass them, but you know this client will keep doing it. They pick from a dropdown between your reviews and simply grab the broadest option that looks right.

So, you instruct the check that "anything booked to a parent category, hold in review until we re-class it". Going forward, those entries queue up for you automatically.

Quality reviews you can trust

Thanks to state-of-the-art technical breakthroughs, we have combined the endless power of plain-English agent instructions with the confidence and reliability of legacy rule-based systems. In Digits, every Quality Control check runs the same way every time. A Negative Asset check looks for credit balances in asset accounts. A Non-Zero Clearing check verifies that the balance cleared.

The practical effect is that on any client where a check is enabled, you never have to wonder whether it was applied. If a clearing account has a balance, it was flagged. If it wasn't flagged, it netted out. The reviewer stays in control of the judgment calls, but stops spending time confirming that the basics were covered.

Fewer surprises on close day

Most review work happens at the end, after the books are mostly done. That's also the worst time to discover a problem: the context is weeks old and you're reconstructing what happened instead of fixing it.

Take a customer payment recorded to Invoice Clearing ahead of a batch deposit that never hits the bank. Left to a month-end review, that discrepancy can sit for two months before anyone notices, and by then nobody remembers the payment. Because Quality Control runs continuously on the clients you’ve set it up for, the Non Zero Clearing check flags the week it stops netting out, while the deposit is still easy to chase down.

Enable the checks that fit each client’s books, and Digits shows where your attention is needed so your close starts from a shorter checklist.

Available today

Good reviewers know what to look for. Quality Control turns that expertise into a system that runs alongside the books — every client, every close, without relying on someone to remember every check.

These eleven came directly from conversations with the firms using Quality Control today, and I know there are more. If there's a check you run by hand every month, or one you wish you could run, I'd like to hear about it.

Zero Entry: The Opportunity of a Lifetime for Accountants

Tue, 08 Sep 2026 10:00:00 GMT

Jeff Seibert and I have spent the last eight years building Digits. In that time, we've spent thousands of hours talking with accounting firms about what they need from their software. Plenty of those conversations opened with a complaint about a specific tool or workflow, but as we dug deeper, the problem was always bigger than the tool. The software firms rely on has been failing them for years, long enough that the workarounds have stopped feeling like workarounds. They've become part of the job.

If that were the only problem, it would be manageable. Firms have absorbed bad software before. But it isn't the only problem. At the same time, firms are facing a shrinking talent pipeline, private equity consolidation, pricing compression, and consequential decisions about their technology architecture. Any one of these could be handled on its own. Together, they put the profession on the brink of real distress.

On a flight across the country with no Wi-Fi, I started writing down all of these themes that eventually became Zero Entry. We wrote this book to bring firms along the path we have been walking ourselves. We have watched AI tools go from interesting to genuinely useful in our own work over a short stretch of time, and that same shift is arriving quickly for accountants and the business owners they serve. Putting our thinking somewhere everyone can access felt important, so that firm owners have the full context when they decide what is right for their own firm.

Why this era is not like the last three

Firm owners have been told before that a technology change was the one that would change everything, and every time, they have handled each of those changes as they arrived just fine. From handwritten ledgers to desktop software, then desktop to the cloud. Not many industries retool that often while keeping the work accurate and the deadlines met.

The piece that makes this time different, and true, is that AI changes how the work gets done vs. where the work gets done. It categorizes, reconciles, researches unfamiliar vendors, runs quality control, and closes the books. Changes of that kind do not stop at the software. It runs downstream into how a firm is staffed, how engagements are priced, and what the economics need to look like to support the business over the long term. Those are big questions that firms will be forced to grapple with sooner than in any prior cycle. The good news is that what we believe comes out the other side is a more human profession than the one most firms are running today; it is just going to take facing some hard challenges head-on to get there.

1. The ledger sets the ceiling

The general ledger is the gravitational center of a practice. Every categorization, every reconciliation, every report flows out of it, which means its architecture is the core determining factor of the AI capability your firm will ever have access to. Most platforms in use today store a transaction as a row of text in a relational database designed more than twenty years ago. There is no semantic understanding in that, and no amount of AI layered on top of it creates any.

2. The opportunity is in the part that was always human

Verification, compliance, interpretation, and accountability. An AI can categorize a transaction, project a tax liability, and flag a risk. It cannot sign the return, carry E&O insurance, or sit across from a business owner and say it stands behind the numbers and will answer for them. That signature, your signature, is the product. As production work compresses, the scarce thing becomes the professional willing to attach their name to the outcome.

3. More businesses will need you, not fewer

Business owners now have real access to baseline accounting through general-purpose AI tools, and starting a company keeps getting easier. Business applications in the US reached 5.62 million in 2025, well above the 3.47 million annual average since 2005, and 2026 is running roughly 18% ahead of last year's pace (US Census Bureau, Business Formation Statistics).

A much larger pool of small businesses will have serviceable books for the first time, including the ones firms have historically turned away because cleanup made them uneconomical to serve. But having books and trusting them are separate things. A business owner's attention belongs on their business, which is exactly why they hire you. The demand of this influx will ultimately flow to whoever is positioned to serve it at scale.

So what does this mean for your firm?

At the end of the day, every firm sits at a different point on the adoption curve with a different client base and different constraints, and anyone selling you a universal roadmap has not talked to enough firms. What we wanted was to get leadership teams asking the right questions before the market answers them on their behalf.

If you are a firm owner and looking at where to start, there is a firm AI maturity assessment linked at the back of the book. It takes a firm leadership team about an hour, and it tends to produce a useful and slightly uncomfortable conversation about where the firm actually stands rather than how it describes itself.

Take the Firm AI Maturity Assessment →

Then move. Speed matters more in this cycle than in the last three, because the advantages compound. A firm running on architecture that learns gets better at serving clients every month it operates. A firm waiting for clarity is holding still against a reference point that keeps moving.

What we hope for the profession

The tedium disappearing is the best thing to happen to accounting in a generation, as long as firms use the room it opens instead of filling it back up with more of the same. Accountants got into this to help business owners run better companies. There is about to be considerably more room to do that, and considerably more business owners who need it.

Build the infrastructure now so your firm is in a position to take it.

The opportunity is here. Zero Entry explores what AI changes for accounting, and how firms can make the most of what comes next. Buy Zero Entry →

Want to see where your firm stands? Take the Firm AI Maturity Assessment →

Digits vs. Accrual for Accounting Firms: What's the Difference?

Wed, 02 Sep 2026 12:00:00 GMT

Accrual adds AI to a tax workflow. Digits is the AI-native ledger where the accounting happens.

Both platforms are built for accounting firms, but they start at different points in the accounting lifecycle.

Digits is an AI-native general ledger. Digits’ Agentic General Ledger™ (AGL®) embeds accounting intelligence directly into the system of record, where transactions are recorded, reconciled, reviewed, and reported. That lets Digits automate work across the accounting lifecycle, including transaction processing, reconciliation, schedules, automated quality control, close, reporting, and tax readiness.

Accrual starts with individual tax preparation. Its AI handles work around the return, from document intake and preparation to review and delivery, while the firm’s existing tax engine remains responsible for calculations, forms, and filing.

That difference in architecture shapes nearly everything else.

Can Digits or Accrual replace QuickBooks?

Digits can replace QuickBooks as the client’s general ledger. Accrual does not.

Digits is the system of record for the books. Transactions are recorded, reconciled, reviewed, and reported directly in Digits, so firms can use it instead of QuickBooks or another general ledger.

Accrual is building a broader, open platform for accounting firms, but its publicly documented workflows do not maintain the client’s general ledger. Firms still need a system for the books, while Accrual connects with existing firm systems and currently applies its AI most deeply to individual tax preparation.

Accrual sits elsewhere in the firm’s stack. It does not maintain the client’s books, so firms still need a general ledger for client accounting. Its current focus is automating individual tax preparation around the firm’s existing tax stack.

Digits vs. Accrual at a glance

Category	Digits	Accrual
What it is	AI-native general ledger and accounting platform	AI tax-preparation and firm workflow platform
Where AI operates	Inside the general ledger, the system of record for the books	Around the firm’s existing tax engine and workflow
Year-round accounting	Yes. Transactions, reconciliation, schedules, Quality Control, close, and reporting	Not a general ledger
Tax readiness	Yes. Keeps books current, tracks W-9s, evaluates 1099 eligibility, calculates eligible spend, supports year-end review, and produces financial packages for tax preparation	Yes. Organizes source documents and information needed to prepare individual returns
1099 & W-9 workflow	AI-assisted 1099 eligibility, entity-type detection, W-9 tracking and document recognition, vendor-level review, and export of eligible vendors	Tax-document intake and preparation workflows
Role in the tax return	Produces and reviews the books the return is built from. Does not prepare or file returns	Prepares cited tax worksheets from source documents for the firm’s tax engine.
Individual tax return prep	No. Digits prepares the books and tax-ready financial data but does not prepare or file income tax returns	Automates preparation work for individual returns, including document processing, worksheet population, and preparer/reviewer workflows. The tax engine handles calculations, forms, and filing.
Tax calculations & filing	Uses the firm’s preferred tax/filing solution	Existing tax engine remains responsible for calculations, forms, and filing
Year-end handoff	Ledger, Trial Balance, P&L, Balance Sheet, and Cash Flow exported together; tax accountant can also be given access	Prepared tax work flows into the firm’s existing tax engine
Best fit	Firms that want the ledger itself to automate accounting and tax readiness throughout the year	Firms that want to automate individual tax-return preparation around their existing stack

What do Digits and Accrual automate?

The practical difference is where each platform starts taking work off the accountant’s plate.

Accrual starts with the return. Its AI organizes tax documents, identifies missing information, prepares tax-engine worksheets with source citations, and helps preparers and reviewers track changes.

Digits starts with the books. Digits’ AGL® automates transaction processing, reconciliation, schedules, automated quality control, close, and reporting. As year-end approaches, that same ledger supports W-9 tracking, 1099 workflows, year-end review, and the financial packages needed for tax preparation.

Accrual makes preparing the individual return more efficient. Digits works upstream, keeping the underlying books current and reviewed continuously, not just for tax season.

Do Digits or Accrual replace your tax software?

No. Neither replaces the tax engine your firm uses to calculate and file income tax returns.

Accrual works alongside that software. Its AI turns source documents and tax information into prepared, cited work for the firm’s tax engine, which remains responsible for calculations, forms, and filing.

Digits reaches the tax workflow from the other direction. It maintains the underlying accounting and gets the books ready for tax, including year-end review, W-9 and 1099 workflows, and financial packages. The firm then uses its preferred tax software for return preparation and filing.

So while neither replaces the tax engine, they arrive there with different jobs already done. Accrual prepares work for the return. Digits prepares the books behind it.

Should your accounting firm choose Digits or Accrual?

The answer depends on where your firm needs more capacity.

Choose Accrual if individual tax-return preparation is the bottleneck. Its current product is designed to reduce the work involved in organizing documents, preparing tax worksheets, finding missing information, and reviewing returns.

Choose Digits if the bottleneck starts with the books. Digits automates recurring accounting work inside the general ledger, from transactions and reconciliation through schedules, quality control, close, reporting, and tax readiness. That makes it particularly relevant for firms growing CAS, bookkeeping, outsourced accounting, and year-round advisory relationships.

With AI inside the ledger, Digits creates capacity across the accounting lifecycle, giving firms more room for review, reporting, advisory, and client service.

For most firms it isn't either-or, it's a question of order. Every tax return inherits the accounting that came before it. Current, reconciled books make every return built on them faster to prepare and easier to review. It does not work the other way around.

Frequently Asked Questions

Can Digits replace QuickBooks?

Yes. Digits is a general ledger and can serve as the client's system of record instead of QuickBooks. Transactions are recorded, reconciled, reviewed, and reported inside Digits, and financial statements are produced from the same live books.

Can Digits help with 1099s and W-9s?

Yes. Digits evaluates 1099 eligibility, tracks W-9 status, recognizes W-9 documents, calculates eligible vendor spend, and lets firms review and export 1099-eligible vendors and totals. Digits does not file 1099s.

How does Digits help accounting firms get clients tax-ready?

Digits keeps the accounting and year-end workflow in the same ledger. Firms can reconcile and review the books, track W-9s and 1099 eligibility, and produce a financial package with the Trial Balance, P&L, Balance Sheet, Cash Flow, and supporting ledger data.

How do Digits and Accrual keep accountants in control of AI?

Both keep accounting professionals in the review process, but at different points. Digits surfaces accounting work and exceptions for review inside the ledger and uses Automated Quality Control to apply consistent checks to the books. Accrual provides source citations, preparer notes, and review checkpoints so tax professionals can inspect prepared work.

How do Digits and Accrual use AI differently?

Digits embeds AI directly into the general ledger, where transactions are recorded, reconciled, reviewed, and reported. Accrual applies AI to individual tax-return preparation, including document processing, worksheet preparation, source citations, and review.

What types of accounting firms is Digits built for?

Digits is built for firms that manage ongoing client accounting, including bookkeeping, CAS, outsourced accounting, reporting, and advisory services. Firms can manage work across their client portfolio while maintaining visibility and consistent review standards.

See what changes when AI starts in the ledger

Digits gives accounting firms an AI-native general ledger for the work that happens all year, from transactions and reconciliation to close, reporting, and tax readiness.

Where Does the Foundation Come From?

Wed, 29 Jul 2026 20:22:00 GMT

I've been a software engineer for more than 20 years, and I can say without hesitation that I'm more productive with agentic AI in the loop. In areas where I'm already an expert, I move at least two to three times faster. Additionally, AI has let me contribute in areas I'd normally never touch.

But there's a catch, and it took a summer of interns at Digits to make me see it clearly. I wrote about it at length in a recently published ACM Queue article, "Where Does the Foundation Come From? — here's the short version, and what it taught us about how engineers actually learn.

The reason I get that multiplier is that I can lean on two decades of experience. I know what questions to ask. I can spot when generated code is subtly wrong. I can look at an architecture document and know which paragraph is doing too much.

New graduates are now expected to be more productive too — because of the same tools. The question no one has answered: where do they get the foundation those tools assume they already have?

The deep end

This summer, I led the internship program at Digits. When the interns arrived, our first instinct was to bring them straight to where our full-time engineers already are. We had recently reshaped our development environment around agentic AI — virtualized sandboxes where models operate, skill-based workflows for well-defined tasks, the whole stack of patterns that lets a Digits engineer hold ten threads at once.

So on day one, we handed them everything. Container environments, code-exploration agents, a skill that walks you through producing an architecture document — the one- to three-page doc every Digits engineer writes before making a nontrivial change to a service. For experienced engineers, that skill removes about half the boilerplate and frees them to focus on the load-bearing design decisions.

The interns used it, and they produced architecture documents that were technically complete. Every section filled. Every code reference correct. And they were unreadable.

Summary sections that should have been three sentences ran three paragraphs. Dependency sections cataloged every import statement of every adjacent file. Test plans rehearsed the entire conceptual testing landscape instead of naming the two or three things that actually needed testing.

The interns hadn't failed the skill. The skill had assumed judgment they hadn't had a chance to build yet — what level of detail fits the audience, what's load-bearing versus scaffolding, what can be left out because the reader can be trusted to know it. Without that direction, the tools produced everything they could, and more powerful tools only made it worse.

The symptom looked like a tool problem. It was a grounding problem.

The fix: a phased on-ramp

So we adjusted. We rebuilt the program around three phases, each deliberately brief — measured in days, not weeks, because these were bright graduates and learning speed was never the issue. The issue was sequence.

Phase one: manual coding. Closed environment, no agentic assistance, write the code by hand against the real codebase. Not to prove they could — most already could — but to build vocabulary. When an agent later referenced those components and conventions, they'd recognize them instead of parsing them from scratch.

Phase two: AI as assistant. We do a lot of paired programming at Digits, and this phase treated AI the same way — a pairing partner, not a co-author. Explain this function. Walk through this control flow. Suggest a single-method implementation. By the end, the interns could navigate the system and form their own positions before the agent suggested one.

Phase three: agentic. Only then did we hand back the full stack. And this time, when an agent produced an architecture document, they could read it and say: this paragraph is doing too much, this section is the actual contested decision, this dependency is wrong. They had what the tools assumed they had to begin with — direction.

We reinvented something old

Walking the program back, we realized we'd accidentally compressed a career arc. An engineer in the 2000s started by writing code by hand because there was no other way, picked up assistance gradually as they were ready to direct it, and eventually orchestrated sophisticated tooling because the foundation underneath was already built. That arc used to take years, mostly by accident. We compressed it into weeks — but we didn't skip a single phase.

AI is the accelerant within each phase, not a substitute for the phases themselves. For an engineer with grounding, AI is a multiplier. For an engineer without it, AI creates a productivity illusion: output gets larger, faster, and more polished, while the understanding underneath doesn't grow with it.

Why this matters for how we build

This philosophy isn't confined to our internship program. It's the same principle at the core of how we build Digits for accountants.

Digits does the repetitive work — booking, reconciling, verifying — and brings professionals in exactly where judgment is required. The accountant isn't bypassed; they're elevated to the work only they can do: reviewing exceptions, applying expertise, standing behind the outcome. The system amplifies judgment. It doesn't pretend to replace it.

AI can compress the path to expertise. It cannot replace the path.

The full paper goes deeper — including what this means for how universities should teach and assess software engineering in an AI-forward world. Read it here.

How non-engineers at Digits ship AI-built tools

Mon, 29 Jun 2026 18:00:00 GMT

Digits is an AI-native accounting platform, so it won't surprise you that our own people lean on AI constantly. What did surprise us is where the bottleneck moved. Sometime last year, AI got good enough that anyone here, not just engineers, could ask Claude for a working dashboard and get one. Building stopped being the hard part.

Everything after the build was a cliff. You'd have a beautiful HTML dashboard sitting in a folder on your Mac with no good way to do anything with it. Sharing meant zipping files into Slack. The moment Claude refactored something, your old version was gone. Hosting meant the word "deploy," which meant filing a ticket, which meant the dashboard quietly died in the folder. The numbers inside were baked in at generation time, a screenshot pretending to be software, because reaching our BigQuery warehouse required SQL that most of the company never learned. Every tool looked different from the last, styled however the model felt that day. And the part that kept us up at night was security. Vibe-coded projects full of revenue data or PII were one careless hosting decision away from leaking, with no authentication anywhere in sight.

The Sidekick home feed. Every AI report, analysis, tools at Digits is just a click away.

So we built Sidekick, a Mac app for everyone at Digits who builds with AI. Sidekick doesn't write code. Claude does that. Sidekick handles everything around the code. It hosts the project behind our Google Workspace authentication, attaches a data store, keeps version history, applies the Digits design system, and publishes to a shared feed where teammates discover it. Drop in a single HTML file and it's live in seconds. Drop in an entire folder and Sidekick retrofits it with everything it needs to become publishable, which is how the more complex tools and reports arrive.

If that sounds like something Claude or Codex already do, it’s worth considering the differences between our custom harness and artifact sharing within those tools. Their sharing shows colleagues the html snippets that you made. Everything above turns it into a tool the company can rely on, governed, styled like Digits, version controlled, with a datastore, cloud functions, and with user-level data access permissions. And none of it is welded to one model. Sidekick sits above the AI, not inside it: point it at Claude today, Codex or open source tomorrow, and it's still the one place every project lives, on rails we own instead of a vendor's. Producing the artifact is the part anyone can do now, which is exactly why we put our effort into everything that comes after it, the part that decides whether a one-off becomes something the company can trust and reuse.

Two weeks into our open beta, sign-ins grew 5x in the first week and a new project has gone live roughly every 16 hours since! The builders come from every department, and so far the heaviest ones are people who typically don't write code for a living.

This is how it works, starting with the architecture, which may surprise you.

The backend that isn't there

Our first design for Sidekick's cloud side looked like everyone's first design. Cloud Run services, Firestore, GCS buckets, a Cloudflare worker for URLs. We had it scaffolded before we asked the uncomfortable question: who is this for?

The people we're serving, our internal business teams, live in Google Sheets all day. They already know how to open one, inspect it, and hand-edit a cell when something looks wrong. So instead of inventing storage they'd never see, we rebuilt every project out of pieces they already understand, on infrastructure we could prototype in days and update in seconds. Every Sidekick project is exactly three things in Google Workspace:

A Google Sheet. The project's data store. Every "table" is a tab, first row is headers.
An Apps Script project. The code, a Code.gs server file plus an index.html UI, pushed via the Apps Script REST API. With access to our datastores, product metrics, drive, and so much more.
A Web App deployment. The URL teammates load, served by Google and restricted to our Workspace domain.

Every Sidekick project is three pieces inside Google Workspace. Your Mac publishes, teammates open it behind a digits.com sign-in, and BigQuery data flows in read-only.

That's the entire stack. There’s little for us to operate, and authentication is fully managed by Google Workspace. When a teammate opens your project, Google verifies their digits.com sign-in before a single byte is served. Nobody at Digits can accidentally publish customer data to the open internet.

The Sidekick Mac app is the orchestrator, and even there the AI era shaped the choices. We built it in Tauri rather than native Swift because AI is exceptionally good at React, which let us ship polished, beautifully styled screens about ten times faster than we could have in SwiftUI. The core is Rust because we wanted the app lean and fast. Speed is part of the Digits experience, and we hold our internal tools to the same bar as our product. The app watches your project folder, and on every save it pushes the code to Apps Script, mints a version, and repoints the deployment. The deployment ID never changes, so the link you shared on day one still works on version forty. Rollback is the same trick in reverse.

Even discovery follows the pattern. The home feed, the grid of every project that greets you when Sidekick opens, is itself a Sheet that every install reads directly, with writes funneled through one locked writer script so two people publishing at once never collide.

And it's hard to overstate how small each project is. This is the entire server side of a typical Sidekick dashboard:

// Code.gs: the whole backend
function doGet() {
  return HtmlService.createHtmlOutputFromFile('index');
}

function getNewFirmsByWeek() {
  return SidekickQueries.run('new_firms_by_week');
}

The page renders, calls one server function, and that function runs a saved warehouse query. Everything else, auth, hosting, versioning, data access, is the platform's job.

Live data without learning SQL

A dashboard with baked-in numbers is stale the day it ships. Sidekick projects query our BigQuery warehouse live, every time someone opens them, and the person who built the project never writes a line of SQL. They describe what they want, Claude writes the query, and the library underneath enforces the rules:

// Claude saves the query first, with a required description...
SidekickQueries.save('arr_by_month', sql, 'ARR by month across all firms');

// ...and the app runs it by name. Automating saved queries.
const rows = SidekickQueries.run('arr_by_month');

That library has opinions. It rejects any statement containing DML or DDL before storing or running anything, dry-runs every query and refuses one that would scan more than a gigabyte, and parameterizes inputs rather than concatenating strings. Saved queries live in a tab of the project's own Sheet, so they travel with the project and every collaborator sees the same list.

The best part is what we didn't have to build. Apps Script Web Apps run as their author, so every query executes under the author's own BigQuery permissions. If you can't see a dataset, neither can your dashboard. When IT revokes access, every tool that person built loses it at the same instant. Governance stays exactly where it already lives.

No jargon, ever

Sidekick's primary user has used Claude a few times, knows what an HTML file is, but could not tell you what "deploy" means. They should never have to. We keep an actual list of words banned from the UI, including git, commit, deploy, repo, branch, build, and endpoint. What they see instead is plain language like "save a version," "share," and "make a copy."

Collaboration follows the same philosophy. Multiple people can edit one project, and to users it feels like Google Docs, while underneath it's libgit2 doing real three-way merges between Apps Script versions. When two people change the same line, Sidekick shows a friendly side-by-side view with buttons instead of merge markers. We deliberately keep the AI out of conflict resolution, because "what did you both mean?" is a human question.

Agents need a contract, not vibes

Claude writes every line of application code in the Sidekick world, so the most important interface we maintain is a set of instructions, not an API.

Sidekick ships a companion plugin for Claude whose skill is, in effect, a contract. It spells out what files make a project, the Apps Script runtime's hard limits, the saved-query rules, and the Digits design system, brand tokens and all, so every tool comes out looking like we shipped it and good design thinking lands with the first prompt. Alongside the skill, Sidekick exposes an MCP server for saving queries, publishing, and validating.

Two decisions did more for reliability than anything else. First, validation is the gate. Claude isn't done when it says it's done; it's done when sidekick_validate_project returns ok, and a unit test pins that a passing validation means Sidekick flips the project to ready. The agent and the app agree on one machine-checkable definition of done. Second, handoff is a file. When someone drags in a folder Sidekick can't host directly (a React app, say), Sidekick writes a conversion brief to .sidekick/inbox.md and opens Claude, whose skill says to read the inbox first and work it. The user just sees "your project is being set up."

The handoff loop. Sidekick writes the brief, Claude does the work, and validation is the gate.

The contract even self-heals. When we fixed a bug in the shared query library, we taught the validator to flag stale projects and taught Claude to quietly re-publish on sight of the finding. The fleet patched itself the next time anyone touched a project.

Two weeks in

We opened the beta in late May. By the end of week one, sign-ins had grown 5x, and a new project has gone live about every 16 hours since.

Cumulative projects since internal launch.

Three favorites so far:

Finance stopped waiting in line for the data team. One analyst shipped six live dashboards in his first nine days, covering ARR, unit economics, firm churn, and cash flow forecasting. Questions that used to sit in a request queue are now URLs he checks each morning.

Account managers walk into every call prepared. A Firm Insights dashboard pulls a firms entire picture into one screen, with real-time usage metrics, a deep-dive into ways Digits can further automate their business, and where their time is being spent. What used to mean asking a data scientist to generate is now an impressive tool designed by our AM’s.

A firm insights dashboard in Sidekick gives firms a 360 view of how to make their practice more efficient.

Enablement shipped a tool, not a chart. A converter that transforms QuickBooks exports into the Digits import format now smooths customer migrations. It's exactly the kind of utility that’s incredibly helpful and so challenging to bake into a traditional roadmap.

None of these existed three weeks ago. Each one is a question someone had, an afternoon with Claude, plus a drag onto Sidekick. Because every project lands in the shared feed with a live thumbnail, each one teaches the next person what's possible.

Constraints are the point

Apps Script is not a general-purpose platform, and we lean into that. There are no websockets, requests die at six minutes, and nothing in the stack can write to BigQuery. When an idea needs more than the platform allows, Sidekick says so plainly and offers a path to engineering. We've gotten comfortable saying no to feature requests, because the constraints keep the system understandable and safe for a team whose day job is building Digits, not Sidekick.

The fair critique is that this is a lot of constraint, and it is, on purpose, but it isn't permanent. Because every project lives behind the app instead of directly on Apps Script, the runtime underneath is just an implementation detail; what stays fixed is the contract Claude builds against, validate, publish, saved queries, the design system. The day a project genuinely needs websockets or a long-running job, we can put a different engine behind the same rails without anyone ever noticing.

Similarly Sidekick offers a path into the product roadmap. When a new tool or report becomes a hit and proves its worth, it now prompts a discussion on how to prioritize it into the Digits roadmap.

The operating story is hard to argue with too. Hosting, managed auth, storage, and the database all ride on Workspace, so the marginal infrastructure cost of the platform is zero and there’s no pager.

Who gets to build

We started this project to fix a sharing problem and accidentally changed who builds software at Digits. The distance from "I wonder" to "here's the link" collapsed to under an hour, and it turns out a lot of people were standing at that cliff with something in their hands. Engineers haven't lost anything; they've gained colleagues who answer their own data questions, against live numbers, with guardrails nobody has to think about.

The feed fills up a little more every day, mostly with serious tools, occasionally with something delightful and unnecessary, which we take as a sign of health. The stack still makes us smile. The next time someone says there's no time to build a platform that lets non-engineers ship, remember that ours runs on a spreadsheet, and it's doing fine.

Build What Makes You Different. Buy Everything Else.

Fri, 26 Jun 2026 21:00:00 GMT

Everyone's been running the same AI loop over the past six months.

First, amazement:
"Wait, AI built that?"
Then ambition:
"Let's automate everything! Let's build our own tools!"

Then the hangover: the code works until it doesn't. The workflow breaks. The model updates. The thing you hacked together on Saturday is load-bearing infrastructure by Monday.

The lesson underneath all of it: AI scales your output way faster than it scales your certainty.

Accounting firms are next.

Call it “vibe accounting”

At first it really is magic. A partner prompts a tool and gets a client memo. A manager builds a workflow over a weekend. A staffer wires a few apps together and kills a repetitive task. A firm prototypes software without the six-month procurement saga. That's real, and it's exciting.

Then the questions start. Who owns this thing? Who tests it every month? Who keeps it current when the tax rules change, the client facts change, the API changes, the model changes? Who makes sure it doesn't blend two clients' data together? Who explains the output to the client, and who takes on the risk when it's wrong?

That's where build-vs-buy stops being a slide and becomes a real decision.

AI made building dramatically easier. It did not make maintaining easier. And in accounting, maintenance isn't a technical problem. It's a trust problem. A tool that nails the demo is not a system that survives hundreds of clients, close cycles, tax deadlines, audit trails, staff turnover, permissions, edge cases, and regulators. The demo is cheap. The operating burden is the whole bill.

This is exactly why experts matter more, not less. AI can generate work that looks right. Experts know whether it is right. They know where the judgment lives, where the controls belong, and when "close enough" is the dangerous answer.

So the best firms will build. They'll build the parts that are truly theirs: their operating model, their client experience, their judgment layer, their particular way of delivering advice. And they'll buy the things every firm needs and nobody escapes maintaining: ledgers, tax, practice management, payments, security, compliance. Then they'll build around those platforms instead of rebuilding them from scratch.

Which might be where the great SaaS-pocalypse quietly ends. Everyone's about to remember why we handed software to software companies in the first place. Not because firms can't build. Because software isn't finished when it works. It still has to be maintained, secured, governed, supported, upgraded, documented, integrated, monitored, and trusted.

AI doesn't change that. It just lets more people find out a lot faster.

Digits + Karbon: Practice Management Meets the Ledger That Closes the Books

Tue, 16 Jun 2026 12:00:00 GMT

Accounting firms run on trust.

Clients trust their accountants to keep them compliant, represent their financials accurately, and help them make better decisions. But behind that trust is an enormous amount of coordination: deadlines, emails, client requests, internal reviews, team capacity, deliverables, and follow-up.

That is what practice management is built for.

But for too long, practice management tools have been pulled into tracking work the ledger should have finished on its own. Checklists become close checklists. Managers chase the status of reconciliations. Partners ask whether the books are ready. Teams move between systems to understand what is done, what is blocked, and what needs attention.

The problem is not practice management. The problem is that the ledger has not done enough of its job.

Today, we are announcing our partnership with Karbon to change that.

Why Karbon

Karbon is the leading AI-powered practice management platform for accounting firms. It helps teams manage workflows, centralize client communication, coordinate work across the practice, and maintain visibility into what needs to happen next.

That matters because firms are not just collections of tasks. They are relationship-driven businesses where timing, communication, quality, and accountability all matter.

Karbon helps firms manage the practice.

Digits closes the books.

Digits is designed to create and maintain the financial record, not merely store it. It collects source data, books transactions, reconciles accounts, manages schedules, applies quality checks, surfaces exceptions, and produces reporting-ready information continuously.

When the ledger does more of the close, practice management can focus more fully on what it was built for: helping firms run the practice.

What this makes possible

Most practice management and ledger integrations focus on basic operational sync: contacts, invoices, payments, and billing workflows.

Those are useful. But they do not answer the questions firms ask every day:

Are this client’s books ready?
What is blocking the close?
Which clients need review?
Where is the team spending time?
What work is waiting on accounting data, and what work is ready for the client?

Those answers live in the ledger. But historically, they have not flowed naturally into the systems firms use to manage the practice.

Digits and Karbon are partnering around a different idea: practice management should sit closer to the accounting foundation underneath it.

Firms should be able to coordinate client work in Karbon while relying on Digits as the financial system of record that keeps the books complete, accurate, and current. That creates a clearer operating rhythm without asking teams to abandon the workflows they already use.

Let each system do what it does best

The goal is not to turn Karbon into a ledger or Digits into a practice management system.

The goal is to let each system do what it does best.

Karbon helps teams coordinate work, communicate with clients, manage deadlines, and run the practice. Digits keeps the financial record current underneath it.

That distinction matters.

When practice workflows are disconnected from the state of the books, teams lose context. They have to check multiple systems to understand whether work is ready, whether a client needs attention, or whether an issue is still sitting in the ledger.

When the ledger handles more of the close, those workflows become cleaner. Teams can spend less time managing around unfinished accounting work and more time delivering the advice, accuracy, and confidence clients hired them for.

Part of a connected firm stack

Karbon is one part of a broader connected accounting stack we are building around Digits.

Practice management matters. Revenue workflows matter. Reporting matters. Each system should do what it does best, while the ledger keeps the financial record complete, accurate, and current underneath it.

That is why we are also partnering with Ignition to connect revenue workflows with the ledger. Read more about Digits + Ignition.

And it is why we are partnering with Reach Reporting to connect Digits data to client-ready reporting, dashboards, budgeting, and analysis. Read more about Digits + Reach.

Together, these partnerships reflect a simple idea: the ledger should close the books, so firms can run the business.

What’s next

We are partnering with Karbon to bring practice management closer to the accounting foundation underneath.

The direction is clear. Modern firms need their systems to work together without blurring what each system is meant to do.

Karbon helps firms manage the practice.

Digits does the job the ledger was always supposed to do.

Together, they create a more connected foundation for the modern accounting firm.

Digits + Reach Reporting: Better Data In, Better Insights Out

Tue, 16 Jun 2026 12:00:00 GMT

Accounting firms do not just need accurate books. They need to turn those books into clear, useful conversations with their clients.

That is where reporting, dashboards, and budgeting come in. For many firms, the client relationship lives in those tools: the monthly package, the KPI dashboard, the budget-to-actuals view, the board-ready report.

It is how accountants explain what happened, what changed, and what to do next.

But reporting tools are only as powerful as the data underneath them.

If the books are still being finalized, the story is already out of date. If reconciliation is incomplete, the report may look polished, but the confidence is not there yet.

Today, we are announcing our integration with Reach Reporting to change that.

Why Reach Reporting

Reach Reporting gives firms a polished, flexible reporting layer for dashboards, analysis, budgeting, and budget-to-actual workflows.

For firms, that matters. Reporting is where accountants move from bookkeeping into advisory. It is where they help clients understand margin, cash, performance against plan, and what decisions need to happen next.

Reach helps firms turn financial data into a format clients can understand.

Digits gives Reach better data to work with.

When that data flows into Reach, firms can build reports, dashboards, and budgets on top of cleaner, more current financial information.

Better data in. Better insights out.

Keep the client interface. Upgrade the engine underneath.

Many firms already have a reporting rhythm their clients recognize. They have built dashboards, monthly report templates, advisory packages, board reports, and budgeting workflows around the way they work.

This integration is designed to preserve that.

Reach is building into Digits so firms can keep the client-facing reporting experience they already use while relying on Digits as the intelligent ledger powering the data underneath.

That means firms do not have to choose between the accounting platform they want and the reporting interface their clients already know.

They get both.

Reach also extends Digits into budgeting and budget-to-actual workflows. Firms can use underlying Digits financial data to create budgets, compare actual performance to plan, and support more forward-looking client conversations without Digits needing to build budgeting directly into the ledger.

That is the power of a connected stack: each system does what it does best.

Digits closes the books. Reach turns the data into reports, dashboards, budgets, and insight.

Built to feel familiar

Reach has a standard integration pattern across accounting platforms. For this integration, Digits built a translator between our API and Reach’s prescribed integration structure so the connection should feel familiar to firms already using Reach.

Same reporting workflow. Better accounting engine.

Reach will also be the first third-party app listed in the Digits Connect UI.

That matters because this is not about building a marketplace full of logos. It is about thoughtfully connecting the tools firms actually use around a stronger ledger foundation.

When Reach reads from a traditional ledger, it is limited by the state of the books underneath: sync schedules, manual cleanup, incomplete reconciliation, and inconsistent structure. When Reach reads from Digits, it can work from financial data that is continuously processed, reconciled, categorized, and organized inside an AI-native ledger.

The result is simple: firms can spend less time worrying about whether the data is ready and more time helping clients understand what the data means.

Part of a connected firm stack

Reach is one part of a broader connected accounting stack we are building around Digits.

Reporting matters. Revenue workflows matter. Practice management matters. Each system should do what it does best, while the ledger keeps the financial record complete, accurate, and current underneath it.

That is why we are also partnering with Ignition to connect revenue workflows with the ledger. Read more about Digits + Ignition.

And it is why we are partnering with Karbon to connect practice management with the accounting foundation underneath. Read more about Digits + Karbon.

Together, these partnerships reflect a simple idea: the ledger should close the books, so firms can run the business.

Getting started

The Reach integration syncs Digits data into Reach for reporting, dashboarding, analysis, budgeting, and budget-to-actual workflows.

If your firm uses Reach and is exploring Digits, this integration makes it easier to keep the client-facing reporting workflows your clients already know while upgrading the ledger underneath. New to Reach? Digits customers get 30% off their first six months with code DIGITS.

We are excited to bring Reach into Digits Connect and to keep building a smarter, more connected accounting stack for modern firms.

Ignition + Digits: AI-Powered Revenue Workflows Meet the AI-Native Ledger

Tue, 16 Jun 2026 12:00:00 GMT

Most accounting and tax firms run their business across two systems that should work together, but rarely do.

One system handles how work gets sold and paid for: proposals, engagement letters, pricing, invoicing, payments, and collections. The other handles how that revenue is recorded and understood: the ledger, categorization, reconciliation, reporting, and analysis.

For years, those systems have been connected by manual work.

A proposal gets accepted. An invoice gets generated. A payment comes in. Someone reconciles it later. If scope changes mid-engagement, tracing that back to what was originally proposed often means opening multiple tabs, checking spreadsheets, and piecing together context after the fact.

That is not just inefficient. It creates a structural blind spot.

Firms cannot make confident pricing, billing, profitability, or growth decisions when the commercial side of the practice and the financial record underneath it are out of sync. Advisory services are harder to scope and expand when the team is still fighting to finish last month’s books. Scope creep is harder to catch when the ledger is behind. Pricing decisions are harder to evaluate when the outcomes are scattered across disconnected systems.

Today, we are announcing a partnership and integration with Ignition to change that.

Why Ignition

Ignition is the leading revenue and billing automation platform for accounting and tax professionals, helping firms simplify proposals, automate billing and collections, manage engagement letters, and get paid for their work in a single AI-powered platform.

That matters because the way firms sell and bill work is no longer just an administrative workflow. It is one of the most important operating systems of the firm.

Ignition provides the front-end context: what was proposed, what was approved, how work was priced, what was billed, and what was collected.

Digits provides the accounting foundation underneath it.

When the ledger closes the books, every tool built around it can finally do what it was designed to do.

For Ignition, that means revenue workflows can connect directly to how revenue is captured and understood in the ledger.

What this means

At launch, the Ignition and Digits integration supports billing-related data flow, client and invoice synchronization, improved visibility into future-dated transactions, and reduced manual accounting setup.

That is the starting point.

Most billing-to-ledger integrations push invoices into a general ledger. That can reduce data entry, but it does not create intelligence. It does not help firms understand whether a client is underbilled relative to scope, whether pricing is producing the expected margin, or whether revenue activity is telling a different story than the engagement letter.

Ignition and Digits create a different foundation.

When proposals, billing, payments, and pricing connect to a continuously maintained ledger, firms can start to answer harder questions:

Which clients are expanding beyond their original scope?

Where are services being underpriced?

Which engagements are profitable, and which only appear profitable because the books are behind?

How should firms package, price, and grow advisory services based on actual financial outcomes?

This partnership lays the foundation for future AI-driven capabilities such as scope creep detection, profitability insights, and pricing optimization driven by live financial data.

Part of a connected firm stack

Ignition is one part of a broader connected accounting stack we are building around Digits.

Revenue workflows matter. Reporting matters. Practice management matters. Each system should do what it does best, while the ledger keeps the financial record complete, accurate, and current underneath it.

That is why we are also partnering with Reach Reporting to connect Digits data to client-ready reporting, dashboards, budgeting, and analysis. Read more about Digits + Reach.

And it is why we are partnering with Karbon to connect practice management with the accounting foundation underneath. Read more about Digits + Karbon.

Together, these partnerships reflect a simple idea: the ledger should close the books, so firms can run the business.

Getting started

If you already use both Ignition and Digits, the integration is available now. If you use one and are exploring the other, this is a good time to see what a connected, AI-powered firm stack can look like.

We will be demoing the integration live at Scaling New Heights.

The days of manually reconciling revenue workflows against the ledger are numbered. This is only the beginning.

Business Accounting Software Was Never Built for Accounting Firms

Fri, 12 Jun 2026 23:00:00 GMT

Every firm knows the handoff.

A new client comes in. They are on QuickBooks or Xero. The books technically exist, but they were not built the way the firm would have built them. The chart of accounts is a little off. The bank rules are inconsistent. Categories reflect how the business owner thinks about the company, not how the firm reports across a portfolio.

Someone has to clean it up, normalize it, and make it usable before the real work can begin.

Then the next client comes in, and the same thing happens again.

That cleanup work does not show up on the invoice. It shows up in the close.

This is not a staffing problem. Not a training problem. Not a tooling problem.

Accounting firms have been running on software built for someone else. And the ledger they inherit from a client is the ceiling for everything they can automate on top of it.

Why does business accounting software create friction for accounting firms?

Business accounting software creates friction for accounting firms because it was designed around the wrong operator.

QuickBooks and Xero were built for one company, one chart of accounts, one owner or internal bookkeeper, and one set of books.

Firms live in a different reality.

A single firm manages dozens, hundreds, or thousands of clients across industries, entities, reporting needs, and firm-specific standards. To business software, each client is a fresh setup problem. To a firm, each client should benefit from what the firm has already learned.

Multi-entity logins do not fix this. They put a different door on the same product. The orientation is not in the dashboard. It is in the data model.

If the system of record treats every client as a separate file and every transaction as an isolated row, every AI feature built on top inherits that ceiling.

Firm-built software has to start with the data model, not just a better workflow around it.

What is the difference between business accounting software and firm accounting software?

Business accounting software is built around one business managing its own books. Firm accounting software is built around one accounting firm managing many clients.

The difference starts with the default user.

Business accounting software assumes the business is the operator: one company, one owner or internal bookkeeper, one chart of accounts, and one set of books.

Firm accounting software assumes the firm is the operator: one team managing a portfolio of clients, applying firm standards, reviewing exceptions, and using the firm’s history to improve how future work gets handled.

Category	Business accounting software	Firm accounting software
Optimized for	One business managing its own books	One firm managing many clients
Default user	Business owner or internal bookkeeper	Firm partner, CAS lead, controller, or accounting team
Chart of accounts	Client-defined and often cleaned up by the firm	Firm-informed defaults with client-level flexibility
AI learns from	One client file at a time	The firm’s history across the portfolio
Default workflow	Self-service bookkeeping and periodic cleanup	Portfolio review, exception handling, and professional sign-off
Knowledge retention	Knowledge can leave when senior reviewers leave	Firm standards and past firm decisions stay encoded in the system

Adding an accountant dashboard does not turn business accounting software into firm accounting software. If the underlying system was built around a single client file, a single business owner, and a manually configured workflow, the firm still inherits those limits.

Different users. Different defaults. Different workflows. Different product categories.

Is business accounting software becoming a risk for accounting firms?

As business accounting platforms add more AI directly for business owners, firms need to be clear about the layer they own.

That layer is not manual categorization. It is not cleanup. It is not making a client’s chart of accounts usable after the fact. Those things are becoming automated, and firms that define themselves by doing them are building on a foundation that keeps shrinking.

The layer worth owning is judgment, accountability, and the professional relationship.

A business owner who can automate more of their own books still needs someone who can interpret what the numbers mean, stand behind the work, and advise on what to do next. No software platform can take professional responsibility for the numbers, carry E&O insurance, or respond to a regulator.

That layer is not going anywhere. But it has to be claimed actively, not assumed.

Firms that turn their standards, judgment, and client knowledge into how the work gets done will hold that layer. Firms that have not made that shift yet are still relying on the mechanics to justify the relationship.

That is why the software category matters. A platform built for the business owner reinforces the old model. A platform built for the firm is how the new one takes hold.

Should a firm migrate a new client off QuickBooks, or stay where they are?

The question is not whether to stay in QuickBooks, move to Xero, or migrate the client somewhere else.

The question is whether the next system was built for the firm.

A firm can move a client from one business accounting platform to another and still end up with the same problem: a client-defined chart of accounts, client-specific rules, manual cleanup, and a workflow that depends on the firm stitching everything together after the fact.

That is the old model of accounting software. The system stores the work. The accountant fixes, interprets, and finishes it.

The next model is different. Routine work moves into the ledger itself, and the firm’s standards, history, and judgment become the starting point for every client.

Which means there are three options, not two.

Stay where the client is. The firm inherits a chart of accounts, bank rules, categories, and workflows built around the business owner’s preferences. The firm’s standards are not the default. Each monthly close starts from the business’s setup and ends with the firm cleaning it up.

Migrate the client to another business accounting platform. The firm absorbs the cost of moving books that were not structured the way the firm structures books: new chart of accounts, new conventions, new rules. But if the destination was still built for one business to run its own books, the firm may end up rebuilding the same operating model in a different system.

Move the client into firm-built software. The starting point changes. The system is built around the firm’s standards, past firm decisions, review workflows, and portfolio-wide knowledge. The client still gets flexibility where the work requires it. But the firm is no longer adapting its operating model around software designed for someone else.

The first two options both ask the firm to keep working around software built for the business owner.

The third changes what the firm is building on.

If not QuickBooks or Xero, what should accounting firms use?

Accounting firms should use software built around the firm as the operator, not another platform built for one business to run its own books.

That is what Digits built the Agentic General Ledger™ to do.

Most AI accounting tools sit beside the ledger. They read transactions, suggest treatments, organize review queues, and wait for someone else to carry the result into the books.

Digits is different because its intelligence is ledger-native. It operates directly inside the general ledger rather than in a separate AI tool sitting on top of it.

The Agentic General Ledger™ does not just suggest accounting work. It performs the work inside the system of record: categorizing, verifying, posting, reconciling, and routing exceptions according to the firm’s standards and history.

The ledger is no longer just where accounting work is recorded. It is where the books stay current, firm standards get applied, and exceptions surface for review.

The Agentic General Ledger™ is not a plugin, not a review queue, and not another business accounting platform with AI added on. It is a ledger where intelligence lives inside the system of record.

Why do traditional ledgers force accountants to stitch work together?

In traditional accounting software, much of the real work happens outside the ledger: spreadsheets, workpapers, reconciliation tools, review queues, categorization tools, and close workflows.

Each system holds a piece of the work. The ledger records the result after everything gets stitched back together.

The accountant is the one doing the stitching.

A platform can make the stitching easier. It can make the queue cleaner. It can make the handoff faster. But if the work still happens outside the ledger, the firm is still operating in the old model.

How does Digits treat accounting data differently?

Most ledgers store a transaction as a line item: date, amount, merchant description, account, and memo. The system can record what happened, but it does not deeply understand the relationships around the transaction.

Digits treats accounting data differently.

Transactions, vendors, customers, categories, entities, and firm decisions exist as connected objects. That means the ledger can understand how a transaction relates to the vendor, how the firm has handled that vendor before, how similar clients handle the same pattern, and whether the classification fits the firm’s standards.

That is a different foundation for AI.

For core accounting work, Digits also uses purpose-built deterministic models designed to produce consistent, verifiable results from the financial data and accounting context available in the ledger.

A bolt-on AI tool can look at a transaction description and make a suggestion. Digits can reason from the accounting context already inside the ledger.

That is what allows the Agentic General Ledger™ to act within the books instead of sending another suggestion to a review queue.

Why does intelligence inside the ledger prevent truth drift?

When intelligence sits outside the ledger, the firm has to make sure the AI’s output and the ledger agree.

A categorization may look right in one tool but post differently in the books. A reconciliation may look complete in one system but not carry through to the system of record. An exception may be resolved in a workflow tool but still need to be reflected in the ledger.

That gap is truth drift: the difference between what an outside AI tool thinks happened and what the general ledger actually shows.

The Agentic General Ledger™ reduces that risk because the intelligence and the financial data operate inside the same ledger. There is no separate AI system that has to be reconciled back to the system of record.

The ledger handles the mechanics. The accountant handles the judgment.

How does tiered intelligence work in Digits?

Digits uses a Model Layer Cake that combines multiple layers of intelligence, escalating when the prior layer lacks confidence. Its proprietary accounting models were trained on 180 million transactions representing nearly $1 trillion in real financial activity.

Layer	Trained on	Handles
Company model	This client’s transaction history, vendors, and conventions	Recurring transactions, known vendors, established patterns
Firm model	The firm’s portfolio: standards, conventions, and past firm decisions	Firm-specific rules, codified judgment, and industry conventions
Global models	Broad accounting patterns learned from proprietary models trained on 180 million transactions representing nearly $1 trillion in real financial activity	Broad accounting context, common vendor recognition, and GAAP-standard treatments
Fallback agents	Specialized agents for unclear or novel transactions	New vendor lookups, ambiguous transactions, and edge cases requiring contextual reasoning

Each layer produces a categorization with a confidence score. Low-confidence transactions escalate through the stack.

Verification runs in parallel: a separate AI layer checks each proposed entry against how the firm has handled similar transactions before anything posts.

Routine transactions post to the ledger. Exceptions route to the accountant.

When a partner classifies a vendor or sets a rule for one client, the firm model carries that decision across the portfolio. The firm’s standards stop living only in handbooks, Slack threads, and senior reviewers’ heads. They become part of the system that does the work.

That is the answer to “if not QuickBooks or Xero, then what?”

Not another business accounting platform. Not AI layered on top.

A ledger built for AI and built for the firm: the Agentic General Ledger™.

Why isn’t bolt-on AI enough for firm accounting workflows?

Bolt-on AI can make old workflows move faster, but it does not change the workflow’s center of gravity.

If the intelligence still sits outside the ledger, the firm still has to review the output, approve the treatment, and make sure the books reflect what the AI suggested. The queue may move faster, but the firm is still operating around the ledger instead of inside it.

That is the limitation.

Bolt-on AI helps with the work. The Agentic General Ledger™ changes where the work happens.

Category	Bolt-on or approval-first AI	Agentic General Ledger™
Where AI lives	Outside the ledger, in a separate tool or workflow	Inside the ledger, on the system of record
What AI produces	Suggestions or drafts waiting for approval	Verified entries that post to the ledger
Review model	Every AI output needs approval before posting	Exceptions route to accountants; routine transactions post when verification passes
Truth drift	Created at handoffs between systems	Eliminated by architecture
Firm review burden	Reviewing AI outputs and whether systems agree	Reviewing exceptions and exercising professional judgment

Business accounting software can speed up reviews.

Firm accounting software reduces how much routine work reaches the review queue in the first place.

How do Digits, QuickBooks, Xero, and Puzzle compare for accounting firms?

Category	Digits	QuickBooks	Xero	Puzzle
Primary orientation	Firm-built general ledger	Business accounting software	Business accounting software	AI accounting software for small businesses
Built around	Accounting firms managing many clients	One business managing its own books	One business managing its own books	One small business managing its own books with AI assistance
AI role	Acts inside the ledger	Suggests or assists	Suggests or assists	Prepares accounting work for review
Review model	Exception-focused review	Human review and cleanup	Human review and cleanup	Approval-first review
Firm-level learning	Learns from the firm’s history across clients	Limited to client-specific workflows	Limited to client-specific workflows	Limited; primarily business-level context
Where work happens	Inside the system of record	Around the ledger	Around the ledger	Around an approval workflow before posting
Best fit	Firms that want routine work moved into the ledger	Small businesses and firms managing simple client books	Small businesses and firms managing simple client books	Small businesses that want AI-assisted bookkeeping

The point is not that QuickBooks, Xero, or Puzzle are bad products. They are built around different assumptions. QuickBooks and Xero were built for businesses to manage their own books. Puzzle is built around an approval-first AI workflow. Digits is built around the firm as the operator, with the Agentic General Ledger™ acting inside the system of record.

What should accounting firms look for in accounting software?

Accounting firms should look for software built around the firm as the operator, not software built for one business to manage its own books.

The key question is:

Does this system make the firm rebuild its workflow client by client, or does it help the firm carry its standards, knowledge, and judgment across the portfolio?

Question to ask	Why it matters
Does the intelligence live inside the ledger?	The firm should not have to reconcile AI outputs back to the system of record.
Does the system complete work or create a review queue?	Firm-built software should reduce routine work before it reaches the team.
Does the system learn from the firm’s history?	New clients should benefit from how the firm has handled similar work before.
Does the system preserve firm expertise?	Standards and judgment calls should not live only in senior reviewers’ heads.
Does the vendor publish proof?	Firms should look for zero-touch performance, accuracy benchmarks, and clear methodology.

Business accounting software can still work for small, stable firms with simple client needs. But as a firm manages more clients, adds advisory services, or tries to preserve senior knowledge across the team, the limits become harder to ignore.

The question is not whether business accounting software can be made to work. Firms have made it work for decades.

The better question is:

How much of the firm’s operating model is being rebuilt around software that was never designed for it?

Business accounting software makes the firm adapt to the client’s setup.

Firm accounting software makes the system adapt to the firm.

That is the category shift.

Frequently asked questions

What is business accounting software?

Business accounting software is built for a business owner or internal bookkeeper to manage one company’s books. It assumes one chart of accounts, one business workflow, and one client file. QuickBooks and Xero are the most common examples.

What is firm accounting software?

Firm accounting software is built for accounting firms managing many clients. It is designed around firm standards, portfolio-wide workflows, exception review, multi-client learning, and knowledge that compounds across engagements.

Why does business accounting software create friction for accounting firms?

Business accounting software creates friction because firms inherit systems configured by clients, not by accountants. Charts of accounts drift, bank rules break, and corrections often stay trapped inside one client file instead of improving the whole portfolio.

What accounting software is built for accounting firms?

Digits is built for accounting firms. Its Agentic General Ledger™ uses tiered intelligence, embedded verification, and firm-level learning to move routine accounting work into the ledger and route exceptions for human review.

What is the Agentic General Ledger™?

The Agentic General Ledger™ is Digits’ accounting system that acts inside the ledger. It categorizes, verifies, posts, reconciles, and routes exceptions using client-level, firm-level, and global intelligence.

Digits’ proprietary accounting models were trained on 180 million transactions representing nearly $1 trillion in real financial activity.

What is truth drift in accounting software?

Truth drift is the gap between what an outside AI tool thinks happened and what the general ledger actually reflects. It happens when intelligence lives outside the system of record and outputs have to move between disconnected systems.

Why isn’t bolt-on AI enough for accounting firms?

Bolt-on AI sits outside the ledger. The firm still has to verify that every output made it into the general ledger correctly. That creates truth drift and keeps accountants reviewing whether systems agree instead of focusing on higher-value work.

What are Zero-Touch Transactions™?

Zero-Touch Transactions™ are transactions that are categorized, verified, and posted to the ledger without a human ever needing to touch them. 95% of Digits transactions post this way on real client books. Most accounting software vendors do not publish an equivalent metric.

How does firm-level intelligence help accounting firms?

Firm-level intelligence lets the system learn from the firm’s standards, corrections, and how the firm has handled similar transactions across the client portfolio. New clients benefit from what the firm has already learned, and new hires inherit more of the firm’s expertise from day one.

Can Digits replace QuickBooks or Xero for accounting firms?

Yes. For firms that want Digits as their system of record, Digits replaces the general ledger rather than sitting on top of QuickBooks or Xero as a plugin. The Agentic General Ledger™ is the system of record where routine accounting work happens, and exceptions are surfaced for review.

How is Digits different from Puzzle?

Puzzle uses a governed, approval-first workflow, which can make reviews faster but keeps humans approving work before it posts. Digits takes a different approach: the Agentic General Ledger™ acts inside the ledger, posts routine transactions when verification passes, and routes exceptions to the accountant.

How should firms evaluate AI accounting software?

Firms should ask whether the AI lives inside the ledger, whether the vendor publishes a zero-touch rate, whether accuracy benchmarks are public with a disclosed transaction set and GAAP-reviewed ground truth, and whether firm knowledge compounds across clients.