An AI-native, agentic open-source toolkit for accounting. These are the deterministic, auditable building blocks an AI agent needs to actually do accounting work: parse a messy bank statement, classify a document, validate an engagement against an open spec, do money math without floating-point drift, and check a webhook signature. Every tool is built to be called by an agent, and maxed-mcp is the front door.

Maxed is a commercial, AI-native accounting platform. We open-source the commodity building blocks our industry shares, released under Apache-2.0 with real tests, real docs, and stable interfaces. What we keep is the higher-level automation that is actually ours to keep. The shared foundation underneath it is here, and it is useful on its own whether or not you ever touch the Maxed product.

Agents are good at judgement and bad at arithmetic, parsing, and signature checks. So the deterministic parts of this work belong in deterministic tools an agent can call, not in a prompt. Across the suite that means:

• maxed-mcp speaks the Model Context Protocol, so any MCP client can call the whole toolkit through one server, with structured JSON in and out.
• --json everywhere. The CLIs and validators emit machine-readable JSON with documented error envelopes and stable exit codes, so a tool call either succeeds with data or fails with a reason an agent can branch on.
• llms.txt and AGENT.md on each tool document the machine interface (tool name, JSON shapes, exit codes) for the agents that read them.
• Deterministic and honest. The same input always yields the same output, and an unconfigured tool says what it needs rather than inventing an answer. Nothing here is generative and nothing is faked.

• maxed-mcp - one MCP server that fronts the suite's deterministic tools so an AI agent can call them the way it calls any other MCP tool: normalize a bank statement, normalize an OFX/QFX download, classify a document, validate a workpaper-spec document, do exact money math, and verify a webhook HMAC. It shells out to the tools that ship a CLI and parses their JSON, computes the small pure primitives in-process, and returns a uniform error envelope. This is where an agent starts.

These define the common language and the developer on-ramp to the suite.

• cpa-workpaper-spec - Open JSON Schema and OpenAPI vocabulary for CPA engagements: engagements, monthly-close checklists with the open-items loop, tax-prep stage models, engagement-letter config, and request-list (PBC) items. It standardizes how to describe this work so two systems can exchange it. The offline validator speaks stdin and --json.
• accounting-adapters - One normalized read interface over public accounting APIs (QBO, Xero, Bill.com, TaxDome, Plaid, FreshBooks, Wave). A single provider-agnostic data model plus a cross-provider diff, with a list/diff CLI that has a zero-credential --sandbox mode and --json output.
• maxed-cli - The developer front door. Scaffolds a local dev project pre-wired to the suite, validates configuration, lints workpaper-spec documents, and runs a fully local sandbox connector smoke-test. Every command supports --json, and maxed tools --json prints a self-describing command manifest for agents.

The deterministic, auditable file-to-data layer.

• statement-normalizer - Turns messy bank and credit-card statements (CSV, OFX/QFX, MT940, CAMT.053, QIF, and line-oriented text) into clean, normalized transaction JSON with a consistent sign convention, parsed dates, and proper decimal amounts. Deterministic and dependency-free.
• ofx-normalizer - A small Go library and a single static CLI binary (ofxnorm) that parse OFX/QFX bank downloads and CSV exports into one normalized transaction schema, with no runtime dependencies.
• doc-classifier-kit - A pluggable evaluation harness for classifying accounting documents into a fixed taxonomy (W-2, 1099, invoice, bank statement, receipt). A stable taxonomy, a hard synthetic eval set, confusion matrices, a leaderboard, and a single-doc classify --json surface, so you can drop in your own model and measure it.

Small, pure, correct building blocks.

• money-rs - Exact decimal money arithmetic in Rust with currency-aware rounding and lossless allocation. Amounts are integer minor units, so floating-point drift cannot happen.
• webhook-hmac-verifier - Constant-time HMAC verification of inbound webhooks (Stripe, QuickBooks Online, Bill.com schemes) in Go, with a configurable replay window and zero dependencies.
• idempotency - An idempotency-key store and Plug for safe retries of financial mutations (Elixir): a charge or ledger posting submitted twice applies exactly once.
• backoffer - Retry with exponential backoff and jitter (Ruby). Zero dependencies; the delay schedule is a pure, testable object, so retries are deterministic under test.
• datelite - Timezone-safe date-only (YYYY-MM-DD) parsing, formatting, and math (TypeScript). A date is three plain integers and never passes through a timezone conversion, so the off-by-one-day bug cannot happen.
• mimefix - Re-derive a real content type for uploaded documents (Swift): extension plus magic bytes, with the bytes winning over a renamed file. Fixes the octet-stream forced-download problem deterministically.

The backend foundation a multi-tenant app builds on.

• deploy-templates - A developer starter kit for multi-tenant backends: a one-command local stack (Postgres with row-level security, Redis, S3-compatible storage, and an API), vendor-neutral storage and accounting-export adapters, deployment starters, and a registry-ready Terraform module. Tenant isolation is enforced by the database, and a scripted demo proves tenant A cannot read tenant B's rows.
• rls-tenant - Postgres row-level-security multi-tenancy for Rails and ActiveRecord: set the tenant once per request and the database enforces isolation for every query.

The presentation layer.

• maxed-ui - A lightweight TypeScript and React component kit for accounting and bookkeeping screens: a register table with aligned debit/credit columns and a running balance, a forgiving money input, status pills, and a reconciliation diff view.

An agent connects to maxed-mcp and calls the toolkit through one server. Under the hood: parse a statement with statement-normalizer or ofx-normalizer, classify the documents around it with doc-classifier-kit, read live data through accounting-adapters and diff two systems in one call, describe the engagement and its checklist with cpa-workpaper-spec, keep the money exact with money-rs, and verify inbound webhooks with webhook-hmac-verifier. Render any of it with maxed-ui, scaffold and validate the whole thing with maxed-cli, and stand up the multi-tenant backend it runs on with deploy-templates and rls-tenant, with idempotency, backoffer, datelite, and mimefix as the retry, date, and upload plumbing around it.

Each repo stands on its own and is separately installable. Use one, use all of them, wire them into your own agent, or use them as a reference for how we think about the problem.

Apache-2.0 on the anchor repos (maxed-mcp, cpa-workpaper-spec, accounting-adapters, maxed-cli, statement-normalizer, doc-classifier-kit, deploy-templates, maxed-ui) and MIT on the small libraries (money-rs, ofx-normalizer, webhook-hmac-verifier, idempotency, backoffer, datelite, mimefix, rls-tenant); see each repo's LICENSE. Build whatever you want on top.