For accounting firms · US & Canada at launch
The autonomous accountant that shows its work.
accountsAI does a client's books end to end — intake, coding, reconciliation, close — with a reasoning model as the accountant and a deterministic, verifiable spine as its governor. Every number traces to the pixel it was read from.
Founding-firm cohort forming now — parallel runs measured against your own staff
How it works
From evidence to a closed ledger, continuously.
Not a month-end batch job. Each piece of evidence is processed the moment it arrives, so the books are always current and month-end is a snapshot — not a project.
Evidence arrives
Clients forward receipts and bills to a dedicated per-client intake address, drop them in the portal, or connect bank, card, and payroll feeds. Duplicates are caught by content hash before they cost anything.
Read, with lineage
Vision extraction pulls vendor, dates, line items, amounts, and tax — each field with its own confidence score and the pixel bounding box it was read from. Cross-checks like subtotal + tax = total run before anything is trusted.
A coded draft
The agent codes each item to the client's chart of accounts, dimensions, and tax treatment by reasoning over their policies and coding history — and writes its reasoning down, in plain language.
The governed decision
Deterministic policy code — not the model grading itself — decides per action: act unattended, act behind a verification gate, or escalate to a human. The inputs: confidence, materiality, reversibility, sensitivity, your policy.
Reconciled against the bank
Book and bank are matched continuously: exact matches, fuzzy vendor matches, and subset-sum matching when N receipts add up to one charge. A bank line with no document gets chased, not guessed.
A close you can prove
Verified drafts post atomically to an immutable double-entry ledger and the period locks. Statements are reproducible: the same finalized inputs always yield the same output — down to the content hash.
The governor
Autonomy is a governed privilege, not a product promise.
In accounting, the blocker to autonomy isn't capability — it's liability, trust, and auditability. accountsAI is built around a trust kernel that decides, for every single action, whether the agent may act — and can prove, afterward, exactly why it did.
decide(action) = confidence × materiality × reversibility × sensitivity × firm policy → ACT | ACT+VERIFY | ESCALATEComputed by deterministic policy code — never by the model grading itself. It knows the difference between a $12 coffee and a $1.2M revenue-recognition call, and small unreviewed items can't quietly add up: a cumulative exposure budget caps them per client, per period.
Four verification gates, before anything binds
No agent judgment reaches the ledger without passing checks it doesn't control. The proposer and the verifier are separate by design.
Arithmetic
Debits equal credits, to the cent, on every entry and in aggregate. Line math ties. Schedules sum and roll forward. Computed in code — the model is never asked to do arithmetic.
Evidence
Every asserted figure links to a source document, the exact field, and its bounding box — or carries an explicit, logged rationale. No evidence chain, no posting.
Policy
Coding respects the client's accounts, capitalization thresholds, required dimensions, and accounting method. Duplicates and out-of-range amounts are stopped here.
Adversarial review
For material judgment calls, a second, independent agent is instructed to refute the first — a preparer/reviewer split. If they disagree, a human decides.
Hard invariants
What it can never do — at any confidence
Enforced by the ledger and the policy engine — structurally, not by prompt. There is no autonomy level at which these relax.
Signed, single-use approvals
The agent prepares; a named human approves. Segregation of duties is structural — preparer and approver can never be the same identity. Each approval is cryptographically signed and bound to the exact snapshot it covers, so an attestation can't be reused or repointed.
An immutable audit trail
Every decision is logged with what the agent saw, what it retrieved, which tools it called, each factor of the autonomy decision, the gate result, and the pinned model version. Exportable, and replayable — a reviewer can see exactly what the agent saw.
Pixel lineage
Every number resolves, in one click, to the source document, the exact field, and the bounding box it was read from — computed figures resolve to the arithmetic over those sources. It works identically before and after close.
Autonomy is earned, not assumed: new clients start fully supervised, and each capability graduates only on measured accuracy against your staff's own decisions. If exception rates spike or confidence de-calibrates, circuit-breakers demote it automatically — and a kill switch drops any client back to full supervision instantly.
Capabilities
The whole job, not a wedge.
Each capability carries its default supervision level from the product's own autonomy map: ⟳ acts unattended within policy, ⚑ acts behind a verification gate, ✋ prepared for human review.
Bookkeeping
⟳ / ⚑Multi-channel intake, document understanding, and GL coding with per-field confidence. Vendor and customer masters kept clean. Recurring entries, prepaids, and amortization schedules maintained on time.
Reconciliation
⚑ verifiedBank and card feeds tied to the books as truth arrives — exact, fuzzy, subset-sum, and split matching, transfer recognition, and a bank-rec report for every cash account. Ghost charges get flagged and chased.
Continuous close
⟳ continuousThe books stay current per event, so month-end is a checklist, not a scramble: completeness and cutoff checks, every balance-sheet account reconciled, then a hard close a human signs.
Statements
⚑ reproducibleTrial balance on demand, any date, any dimension slice. P&L, balance sheet, and cash flow with comparatives — reproducible to a deterministic content hash, with compilation wrappers for sign-off.
Tax-prep support
✋ human filesSales/use tax and GST/HST tracked continuously by jurisdiction. Return figures, supporting schedules, and 1099/T-slip data prepared for review. A professional reviews and files — always.
Advisory
⟳ citedCash-flow forecasts and runway from actuals plus known commitments. Variances explained by drilling ledger → vendor → source document. Ask the books anything; every answer carries citations.
Built for firms
Your firm runs it. Your clients just forward documents.
accountsAI is leverage for the practice, not a replacement service competing with it. The firm is the tenant; staff supervise; clients participate — barely.
The firm is the tenant
You set the policy: materiality thresholds, autonomy levels per client and per capability, and who approves what. One console across every client, with exceptions ranked by what actually matters.
Staff supervise by exception
Nobody re-keys anything. Your team works a queue where each item arrives with the agent's reasoning, the evidence with its bounding boxes, and one-click resolutions. A correction becomes memory the moment it's made.
Clients just forward documents
Each client gets a dedicated intake address. They forward whatever lands in their inbox and answer the occasional question the agent asks. That's the entire ask.
Adoption is a parallel run: import history, shadow your current process for a period or two, and compare the agent's work against your own team's — client by client, capability by capability. The measured agreement is the sales pitch, and it's yours to keep either way.
Comparison
Where the trust actually lives.
| Traditional bookkeeping | Generic AI tools | accountsAI | |
|---|---|---|---|
| Who does the work | A person, hours at a time | A model — take it or leave it | A reasoning agent, governed per action by deterministic policy |
| When it's unsure | A judgment call, sometimes documented | It guesses | It stops and asks — escalation is a designed path, not a failure |
| Evidence for a number | A filing cabinet and memory | A chat answer | One click to the document, the field, and the pixel bounding box |
| The close | A month-end scramble | There isn't one | Books current continuously; hard close locks an immutable ledger |
| The audit trail | Reconstructed after the fact | Opaque | Every decision logged with its reasoning and pinned model version |
| Who signs | The person who did the work | Unclear | Your firm — over a package built to be verified in seconds |
FAQ
Fair questions.
What happens when the AI is unsure?
It stops and asks. Anything uncertain or material routes to your exception queue with the agent's reasoning, the linked evidence, its confidence and materiality, and the specific reason it escalated — then your resolution becomes memory it uses next time. Guessing silently is prohibited by design: when in doubt, the agent's only allowed moves are to verify harder or to hand the item to a human.
What does it actually do today?
Document intake by upload or per-client email; vision extraction with pixel-level lineage; AI coding to the general ledger governed by a deterministic trust kernel; bank reconciliation including subset-sum matching; an exception queue for humans; hard close onto an immutable double-entry ledger; reproducible financial statements with deterministic content hashes; and “ask the books” chat with citations.
Will it ever move money or file a return on its own?
No. These are hard invariants, not settings: payments and filings always require a human authorization record, and the agent structurally cannot approve its own work. There is no autonomy level at which they turn off.
How does it learn our firm's conventions?
Memory, not training. Every correction and answered question becomes per-client retrieval memory that changes behavior on the very next item. It's inspectable (you can see which precedent drove a suggestion), it never leaks between clients, and your data is never used to train foundation models.
What does an auditor get?
The complete trail: statement → general ledger → transaction → source document, tied end to end, with an exportable immutable log of every decision including what the agent saw, which checks passed, and which human signed. Statements re-run over the same finalized inputs reproduce exactly.
Do we have to rip out QuickBooks or Xero?
No. accountsAI imports history and the chart of accounts at onboarding, and can sync while you migrate. It does keep its own ledger as the system of record — owning the spine is what makes pixel lineage, hard invariants, and reproducible statements possible. The adoption path is a parallel run: shadow your current process for a period or two and compare against your own staff's decisions.
Early access
Be one of the founding firms.
We're onboarding a small cohort of US and Canadian firms to run accountsAI in parallel with their current process — measured against your own team's decisions. The parallel run is the proof.
We'll only use this to reach you about early access.