Correcting the machine
Software reading statements will misjudge a line sooner or later: a customer whose company name sounds like a funder, a transfer that was really a sale. The interesting question is not whether an underwriter can fix it — everything worth using lets them — but what the product does with the correction. A tag is not a label stuck on a row. It is an input to a dozen figures that were computed from it.
- One tag changes revenue, burden, positions and the score
- The rerun is deterministic — the model does not run again
- Nothing about the document is allowed to change with it
A correction re-derives everything, or it lies
Say a credit was read as an advance from a funder and it was really a customer paying an invoice. Correcting it does not change one cell. Revenue rises, which changes the burden percentage, the headroom figure and payer concentration. The funder loses a payment, which can change whether it is a position at all, which changes the stacking count, which changes the risk score. The month it sits in changes, which changes the trend.
A product that patched the label and left the rest would produce a report whose panels disagree with each other — and the underwriter would have no way of knowing which figures had been updated and which were left over from before. So a correction re-runs the analysis from the corrected rows: every derived number is computed again, from scratch, exactly as it was the first time.
Four things the rerun must guarantee
Re-running everything is the easy half. These are the properties that make the rerun trustworthy.
It is the same statement
A correction changes what a row means, never what it says. The resubmitted rows have to fingerprint-match the analyzed statement — same dates, same amounts, same descriptions — and a mismatch is refused. Without that binding, the correction path would accept any rows at all and quietly replace the case’s analysis with them.
It is deterministic
The AI classifier does not run again. Re-invoking it would spend on a statement already paid for, and worse, it could group payees slightly differently this time — so saving one tag edit could move numbers nobody touched. The labels it produced on the original run are replayed instead, because a position only the classifier had found must not vanish from the corrected report.
The document’s own facts survive
The authenticity verdict, the statement’s printed summary and reconciliation figures, the business name, the rows that fell outside the period: all of these describe the document, not the tags, so they are replayed from the stored run rather than recomputed or re-sent. Rebuilding without them once turned a statement that had failed its authenticity check into one that passed.
The stored run is the authority
Those facts come from the run on record, not from the copy the browser sends back. A viewer without full access sees a redacted report, so persisting their copy would strip diagnostics from the corrected run — and trusting it at all would let a client launder a failed verdict into a clean one. What a correction saves never depends on who was looking at it.
A correction is not a new analysis
Recalculating after a correction costs nothing. No file is parsed, no extraction runs, no model is called; the statement was paid for once and the arithmetic is ours to redo. Charging for it would be charging a customer to fix our mistake, and it would also teach them not to fix it — which is much worse, because an uncorrected report is one that quietly circulates a number somebody already knew was wrong.
The same reasoning runs through the rest of the product. A figure should cost nothing to question, and a figure nobody can question should not be printed at all.
Judgement upstream, arithmetic downstream
What an underwriter brings to a corrected line is context the statement does not contain: that this payer is the merchant’s largest client rather than a lender, that this transfer went to a business the owner also runs, that the deposit in question was a one-off equipment sale. None of that is in the document. All of it is knowable by a person who picks up the phone.
What follows from it is not a judgement at all. Once the line is what it is, the revenue base, the burden, the position list and everything built on them follow mechanically, and re-deriving them by hand is how mistakes get made twice. The person supplies the fact; the machine redoes the sums. Getting that boundary right is most of what separates a tool that gets corrected from one that gets worked around in a spreadsheet.
There is a quieter benefit too. Corrections are evidence about the reading, and confirmed ones make the recognised-funder knowledge better for the files that come after. The statement in front of you is fixed once; the next one arrives slightly less wrong.
Common questions
Does correcting a transaction tag cost a credit?
No. A recalculation re-runs the analysis on a statement that was already paid for, with no parsing and no extraction, so it is free by design. Charging to fix a misread line would only discourage fixing it.
What changes when I correct one tag?
Everything derived from it: the revenue base, the burden percentage, headroom, payer concentration, the position list and stacking count, the risk score, and the month the trend reads. The whole analysis is recomputed rather than patched in one place.
Can I change a transaction’s amount or date?
No. A correction changes what a line means, not what it says — a different amount describes a different statement. If the document itself was wrong or incomplete, the fix is to upload the correct one, which is analyzed as the new document it is.
Does the AI run again on a recalculation?
No, deliberately. Re-running it could group payees slightly differently, so one tag edit could move numbers nobody touched. The labels from the original run are replayed, keeping the correction confined to what was actually corrected.
Can a recalculation hide a failed authenticity check?
No. Facts about the document — the authenticity verdict, the printed summary, the reconciliation figures — are replayed from the stored run rather than from anything the browser sends back, so a correction cannot turn a flagged statement into a clean one.
Related
Fix the line, keep the arithmetic
Upload a statement, correct anything the read got wrong, and watch every figure follow.