Two Agentic Accounting Apps, Built in an Afternoon on Open Source
The AI-accounting gold rush is on. The hard part is correctness. Here are two working example apps that get correctness right by refusing to invent the numbers, built in an afternoon on open source, both public today.
Update (September 2026): these two demos have since been composed into an AI-native accounting firm.
accounting-runtimeandpersonal-tax-runtimehave been retired (removed from GitHub) and superseded by redevops-io/accounting-firm, which turns the same correctness spine into CPA-signed deliverables (an IRC §41 R&D credit study and an ASC 606 revenue-recognition memo) on rAIls, with a live review console at demo.redevops.io/accounting. The "what these examples aren't" list below is largely built now: see Where this went next, at the end.
Every week brings another "agentic accounting" or "AI tax prep" pitch. The demos look great until you ask the only question that matters in accounting: is the number right, and can you prove it? That's where most fall down, and it's a data problem before it's a model problem. No public dataset pairs a source document with its correct bookkeeping entry, or a taxpayer's inputs with their correct return, because real ledgers and real 1040s are private (and, for returns, criminally protected PII).
So we took the opposite approach: compute the numbers with a real engine, and cross-check with a second, fabricating none.
Two examples
accounting-runtime (now retired: see the update above), a governed AI layer for bookkeeping. It posts invoices through the ERPNext accounting engine, which computes the double-entry (debits = credits) by construction, then reads the ledger back. A second engine, Odoo, independently posts the same invoices; when two real accounting engines agree, the postings are accounting.
personal-tax-runtime (now retired: see the update above), a governed AI layer for individual (Form 1040) tax. It computes the federal return with Tax-Calculator, and cross-validates every return against PolicyEngine-US, an independent implementation of the tax code.
Both follow the same rule: the AI extracts, retrieves, and proposes; a real engine computes; you approve. The runtime never invents the tax owed or the journal entry.
The open source that made it possible
| Component | License | Role |
|---|---|---|
| ERPNext | GPL-3.0 | Accounting engine: computes the double-entry |
| Odoo | LGPL-3.0 | Second accounting engine: cross-validation |
| Tax-Calculator | CC0 (public domain) | Federal tax engine: computes the return |
| PolicyEngine-US | AGPL-3.0 | Second tax engine: cross-validation |
That's the whole trick: pair a computation engine with an independent one, and let their agreement be your correctness signal.
The results
- Bookkeeping: 5,100 invoices posted through ERPNext across eight scenarios (tax, multi-currency, discounts, multi-line, duplicates, plus 300 correct refusals of postings into a closed period): 100% balanced, zero errors. The Odoo cross-check: 50/50 agree.
- Personal tax: 600 synthetic taxpayers across eight scenarios: 583/600 = 97.2% exact agreement between the two engines on AGI, taxable income, and tax. The disagreements? All the student-loan-interest phase-out: a genuine, sub-1% modeling difference between the two engines. We kept them labeled. That's the point of running two engines: it tells you exactly where the tax code's implementation is genuinely hard.
Run it yourself
Note (September 2026): the two example repositories have been retired (removed from GitHub). Their correctness spine (deterministic engines with an independent cross-check) was carried forward into accounting-firm, which is where the runnable code now lives. Clone that repo, or try the live review console at demo.redevops.io/accounting: challenge any line of a CPA-signed §41 study and see its proof.
The datasets we tested on (and where they come from)
Everything is public-domain or clearly licensed: no scraped or gated data:
- CORD (1,000 real receipts, line items + boxes) and SROIE (987 receipts), CC-BY-4.0, the document-extraction inputs.
- SEC EDGAR Financial Statement Data Sets (3.4M tagged facts), public domain, statement-level checks.
- IRC Title 26 (uscode.house.gov), 26 CFR (ecfr.gov), and IRS publications (irs.gov), public domain, the policy/law corpus the runtime cites.
- ERPNext charts of accounts (GPL-3.0) and EU VAT rates (MIT), the ledger seeds.
- For personal tax: IRS individual pubs (17, 501, 502, 505, 596, 936, 970) and the IRS MeF/ATS governing docs, public domain.
We deliberately did not embed copyrighted standards (FASB ASC, IFRS): those are referenced by number, never reproduced.
What these examples are, and aren't
These are reference examples: a tested data foundation and the governance approach, built fast to prove the thesis. A production deployment adds real work we'd love to help with:
- Production document extraction: models that read real W-2s, invoices, and receipts, beyond a schema mapping.
- The QuickBooks Online / Xero / Drake adapters: the commercial API integrations firms actually run on.
- The console / review UI, human-in-the-loop workflows, multi-tenant auth, and SOC 2.
- E-file / MeF transmission, security, and error handling at scale.
- Go-to-market: a team, and pilots with real firms.
If you're building in this space, or you're a CPA firm that wants this deployed as a fully-featured product, we'd love to help.
Where this went next: the AI-native firm
Those reference examples became the correctness spine of a real product: accounting-firm (AGPL), an AI-native accounting firm on rAIls. It keeps the rule above (the AI extracts and proposes; a real engine computes; a CPA signs) and builds the rest of the list:
- Deliverables, with the numbers. A productized IRC §41 R&D credit study and an ASC 606 revenue-recognition memo, each a governed mission: ingest → reconcile → assess → compute → draft → verify → CPA review/sign.
- Hybrid reasoning, enforced. Deterministic engines compute every figure (each with an independent A/B cross-check, the same two-engine trick as above); the model only fills per-criterion assessments (PASS / FAIL / INSUFFICIENT), and a deterministic policy derives the conclusion. The model never decides a number or a qualification, and low-confidence extraction or an unresolved reconciliation escalates to a human, it never guesses.
- A claim graph. Every material sentence in the deliverable carries provenance (evidence, cited authority, or a cross-checked computation) and the memo is a rendering of that graph, so citations resolve by construction.
- A CPA review/sign gate over an append-only, hash-chained evidence ledger (the durable ReDevOps mission ledger): what makes a deliverable signable and auditable. Every CPA amendment feeds a learning loop that tunes the AI layer only (retrieval, extraction, drafting), never the tax or accounting rules, which stay versioned and controlled.
- Messy-document ingestion (scanned/unstructured, with a confidence-gated correction step) and grounded citations via ReDevOps RAG over the IRC / CFR / ASC corpus.
The two engines here are archived and kept for reference; accounting-firm is where the work continues. The regulatory gates stay hard: the licensed CPA alone remains the professional authority; the runtime just makes their review fast and defensible.
A note on licensing
Both examples are AGPL-3.0 with the network-use clause waived (so it behaves like GPLv3 for SaaS). For a commercial product: ship on the CC0 / permissive engines (Tax-Calculator is public domain), keep any AGPL component as an internal validator, and treat ERPNext (GPLv3) as an arm's-length backend. The real gate is the commercial API agreements with QuickBooks/Xero/Drake, and, for tax filing, IRS e-file authorization, over the open-source licenses. (Details in each repo's LICENSES.md. Not legal advice.)
The repo: accounting-firm (active successor), carrying forward the correctness spine of the now-retired accounting-runtime and personal-tax-runtime.