Axiom takes an AR export and the contracts behind it, and returns the short-pays those contracts do not support — each one quoting the clause that proves it. A model reads the contract. Code does every calculation after that.
No target metrics. No dated promises. No figure on this page that nobody measured.
3
File types in
PDF, CSV and XLSX — decided by the leading bytes, not the extension
5
Model providers
Interchangeable behind one adapter. Switching is a flag.
0
Integrations
Nothing to build, nothing to maintain, no credentials into your ERP
30d
Retention
Until your intake files are purged, on a scheduled job
This is the whole of what Axiom says about itself. Each line names the rule the code enforces, so the claim and the way to falsify it arrive together.
Three file types in, and the bytes decide which.
PDF, CSV and XLSX. The type is read from a file's leading bytes; the filename extension is never trusted.
A file carrying active content never reaches the engine.
PDF actions, spreadsheet macros, OLE objects, embedded executables and DDE formulas are rejected at the door.
Real exports survive the parser.
Title rows above the header, merged cells, currency symbols, thousands separators, and (123.45) read as a negative.
The model reads. It is never asked for a number.
It returns typed contract terms and a verbatim quote for each — never a dollar amount, never a verdict.
Five providers, and switching one is a flag.
Anthropic, Gemini, OpenAI, DeepSeek and GLM sit behind one adapter, one injection boundary, one retry contract.
Contract text enters the model as data, never as instruction.
One delimited block. The call gets no tools and no network, and nothing the model returns becomes control flow.
A quote that will not resolve is dropped, not downgraded.
Each quote is matched as an exact substring of the extracted text, and the page is derived from character offsets.
There is no demo mode that fakes an answer.
The fixture provider replays canned answers for tests only. It is never auto-selected and refuses to run in production.
Every amount is integer-cent arithmetic.
Discount windows, freight caps, rebate thresholds and price variances are computed in code, so any finding can be recomputed by hand.
A deduction reason matching no category is marked unknown.
Five categories, and a sixth state for the reasons that fit none of them. Nothing is pushed into the nearest bucket.
The same inputs return the same findings.
The engine imports no React, no Next and no database. It takes documents in and returns findings out.
One customer's data cannot be read by another.
Row-level security on every table, tenant identity on every row, and composite keys that make a cross-tenant reference unrepresentable.
Results leave as files. Nothing is posted into your systems.
Workpaper, dispute package and recovery ledger come out as documents. No connector holds credentials into your ledger.
Your intake files are deleted 30 days after delivery.
A job scheduled inside the database, not a promise somebody has to remember to keep.
14 rows, and every one of them names something in the repository rather than a number somebody liked the sound of. Ask about any line on a call — the answer is a file.
An audit is worth what its weakest step is worth. So the interesting work sits in one place — reading a contract — and everything downstream of it is deterministic, inspectable, and dull on purpose.
Server-rendered product surface
Every dashboard route is gated at the edge before it renders, and again inside the service that fetches its data.
Tenanted system of record
Row-level security on every table, with the tenant carried on each row so a boundary check is one non-recursive lookup.
Page-anchored contract text
Text is reconstructed page by page with character offsets retained, which is what makes a page citation derivable rather than asserted.
Surviving real exports
Header junk above the table, merged cells, currency formatting and parenthesised negatives — the shapes AR exports actually arrive in.
No model lock-in
One registry, one prompt-injection boundary, one retry contract. No part of the product assumes a particular vendor stays available or priced as it is.
Code does the arithmetic
Pure TypeScript importing no React, no Next and no database. Documents in, findings out, which is why its behaviour can be asserted directly.
No quarters and no target metrics. A dated promise is the easiest thing in the world to write and the hardest to be held to, so every track below sits in one of three states we can verify about our own code.
Spreadsheets and CSVs straight out of your ERP, and contracts as PDFs. Nothing is asked of your IT team: no API keys, no connector, no sandbox account, no ticket in someone's backlog.
Real exports are messy. Title rows above the header, merged cells, currency symbols, thousands separators, negatives written in parentheses, columns named whatever the person who built the report felt like naming them. The normalizer expects all of that.
A finding per short-paid line the contract does not support, with the governing clause quoted verbatim and the arithmetic shown. Plus the workpaper, the dispute package, and a recovery ledger that tracks what has actually been collected.
Finding the sentence that governs a deduction is a reading problem, and models are good at it. Deciding whether a payment landed inside a ten-day window is an arithmetic problem, and models are bad at it. The model is only ever asked the first question.
Each extracted term carries a verbatim quote. Code resolves that quote against the document text as an exact substring and derives the page from character offsets. A quote that does not resolve is not flagged for review or given a lower confidence — the term is dropped and no finding is built on it.
Anthropic, Gemini, OpenAI, DeepSeek, and GLM sit behind a single adapter with one prompt-injection boundary and one retry contract. Changing provider is a flag. No part of the product is built on one vendor's model being available, priced a certain way, or behaving the way it does today.
Remittance advice arrives as lockbox scans, buyer-portal exports, and payload formats nobody designed to be read twice. We parse the spreadsheet and PDF cases now. We are not going to tell you we parse the others until we do.
A format counts as supported when it survives real documents, not a sample we chose. Until a format clears that bar it stays off this page, off the pricing page, and out of a sales call.
Whatever else becomes readable, the citation rule holds: a finding either quotes a clause that resolves exactly in the source document, or it does not ship.
The moment a vendor holds write credentials into your general ledger, your finance team inherits a review process, your IT team inherits an integration to maintain, and the thing that made the first audit take two days instead of two quarters is gone.
Findings, workpapers, and dispute packages come out as documents and exports. Your team posts what it decides to post. The recovery ledger tracks what was collected without needing to be the system of record for it.
It would be announced as a shipped capability with the connectors named, not as a quarter on a roadmap. Nothing on this page is a commitment to a date.
A predictive score is only as good as the history behind it, and it would be trained on data we do not have. Shipping one early means shipping confident-looking numbers with nothing underneath — which is the exact failure this page exists to avoid.
We audit what already happened. A short-pay that occurred, against a clause that exists, for an amount that can be recomputed. That is a smaller claim, and it is one we can defend line by line.
Axiom will not tell you which invoice is at risk next quarter. It will tell you which of the deductions you already wrote off should not have been taken, and show you the sentence that proves it.
You are being asked to hand a stranger your contracts and your receivables ledger. Here is everything a page like this is expected to assert, and does not.
Axiom holds no compliance certification and claims none: no SOC 2 audit has been performed and no auditor has been engaged. What we can point at instead is the code — how tenants are separated, what happens to a citation that will not resolve, and what becomes of your files after delivery. Ask about any of it on a call.
There is no invoices-per-hour figure on this site, because no benchmark in this repository produces one. What we will tell you is the shape of the work: the expensive step is reading contracts, it happens once per contract rather than once per invoice, and everything that runs against each line afterwards is arithmetic.
You will not find an accuracy percentage here either. The figure that would matter is how often a finding survives the buyer's own challenge, and that is a number earned by running audits, not by choosing one. Until it exists, the substitute is the citation rule: a finding either quotes a clause that resolves, or it is not sent.
No customer count, no waitlist total, no recovered-to-date figure. Earlier versions of this page carried a number for each of those, plus a testimonial from a finance director who does not exist, and every one of them was invented. They are gone, and nothing replaces them.
We onboard a small number of finance teams at a time so each one gets the product team directly. Leave an address and we will reach out when the next set of places opens.
Or skip the queue and put a quarter of short-pays through the audit today.