Engleman Associates, Inc. · Article
ERP Transaction Precision and the Myth About AI

The myth, and what drives it
A claim heard often is that AI cannot be trusted with precise work such as accounting transactions. This article calls that claim a myth, because it holds only for AI used without structure. The generalized evidence revolves around the potential for AI "slop" and "hallucination": answers that suggest a foundational weakness and seem to end the discussion. However, the claim is not true of AI working under precise instructions and oversight, as this article explains.
In a classic ERP system, precision in business transactions comes from configured rules, custom code, database design and the controls a company puts around them. In AI work it comes from the same place: the method the AI is made to follow. Give an AI loose questions and it gives answers that vary from one run to the next, including errors. Give it written explicit procedures, make it calculate in code, and stop the work when a validation point fails, and the result is precise and can be audited at any time.
Engleman Associates, Inc. (EAI) uses AI this way in its ERP project financial modeling. In a highly complex model, with many dependency rules, every figure is calculated in code, not estimated in prose. Every total is reconciled to its source. Every change is logged and reviewed by a person before it is used. A step that fails a check stops the work rather than passing a warning along.
That is the same discipline ERP control is meant to provide, and AI-enabled control adds two differences over classic ERP. The rules are written in plain language anyone can read. And every result carries its own record of how it was produced. The weakness people see in AI is real, but it is a weakness of method, not of the technology. AI plus precise instructions plus built-in checks can match the process discipline of classic ERP — as this article explains. And AI is only getting started.
How an AI-native ERP delivers transaction precision
Classic ERP's posting engine is precise, and this article does not argue that AI does arithmetic better. The difference lies elsewhere. Classic ERP reaches its precision through layers of hidden code that are costly to keep in condition and risky to change. AI work under precise instructions reaches the same precision with rules anyone can read, and with a record of how each result was produced.
In an AI-native ERP, the whole stack is built and run with AI: the ledger and its posting rules, the database, the integrations, and the daily work on top. Precision comes from how that stack is built. The ledger is still code with fixed rules: entries must balance, accounts must exist, and the period must be open. That code is built and maintained with AI, under precise instructions, and checks prove it before it is used. AI agents then code transactions, match them to what they record and reconcile accounts. Every entry they propose passes the same validation rules before it posts. A transaction that breaks a rule is refused, whoever or whatever submitted it.
The AI-native approach is controlled throughout, and the known AI variances can be contained. On that foundation, the cost and effort for AI to develop capable analytics and automation for system users is estimated to be far lower.
Two ways to control a financial calculation
The chart below compares how a financial calculation is controlled in a classic ERP process with how it is controlled in AI work under precise instructions. The sections that follow take each part in turn.

How control works in a classic ERP process
In a classic ERP process, the rules that most control whether a transaction is processed correctly are ones users and auditors never see. They sit below the screens, in layers kept away from those using the system for good reason: changing them takes specialist skill, and a mistake there can have material ripple effects.
- Rules buried in the code and database layers. Below the screens users work in, the ERP's program code and its core database rules and structure govern how transactions are processed: how records relate, how values are calculated and stored, how data is validated, and what happens when a step fails partway. Users can see and set many interface and transaction options. The company's technical staff can go further: they can see data tables and the tools for configuration and functional extensions. The seller's core source code is generally not open to them, and in a cloud ERP it almost never is. For users, and largely for their own technical staff, these deeper layers are a black box.
- Integration layers add more. Each connection to another system, such as a bank, a warehouse system or a reporting tool, carries its own rules and coding discipline, often written by different people at different times.
- The black box is delicate. Keeping these deep system layers in reasonable condition takes serious management over years. Without it, they become a source of legacy slop of their own: workarounds, patches and custom code that few people understand.
- Every major change is a risk. A major functional change, an upgrade or a new integration touches this delicate structure. Each one is a chance for real issues, which may surface only later and are often hard to trace. Because of this, many contemplated system improvements are not pursued.
- The record is partial. An ERP audit trail usually shows what data changed, when and by whom. It does not show the logic in the hidden layers that produced the result.
The point is that ERP control depends on code and structure that users cannot see, that internal IT staff can see only in part, and that only the seller's own specialists can see in full. So when criticism of AI-native ERP rests on this AI instability argument, it is worth remembering what the current paradigm is built upon. An AI wrapper added to a classic ERP leaves these layers as they are.
How AI works under precise instructions
AI work under precise instructions generally follows the steps listed below. Each step closes off a way that AI output goes wrong when it is produced without the structure described.
- Written instructions. The procedure is written in plain language before the work starts: what to calculate, from which sources, in what order, and what counts as a correct result. Anyone in the business can read it, not only a specialist. When the procedure changes, the salient details of the change are documented, a testing protocol is applied, and specific approval standards are used before final approval.
- AI carries out the steps. The AI follows the procedure as written. It does not decide on its own to skip a step, add one, or change a rule because it found a better idea — because the procedure forbids it, and the checks and the review catch it if it happens. A better idea is raised with the person responsible, who decides on their own or tests the idea with AI in a controlled exploration sandbox.
- Figures calculated in code. The AI does not do arithmetic in its digital head or estimate figures in prose, which is where AI arithmetic errors come from. It writes and runs code that calculates every figure from the source data. The code is kept and versioned, and reused on each run rather than rewritten, so the same inputs give the same result every time.
- Automatic checks. Every calculated result is tied back to its source, and each result is tested against rules set in advance. A failed check stops the work. It is not logged as a warning and passed along, because a check that only warns is a check that gets skimmed.
- Person reviews and rules. A person responsible for the work owns each result and rules on anything the procedure leaves open. Review usually runs through exception scans or other highly efficient means of detecting unexpected variances. The AI does the work. The person owns the decisions.
- Logged record. Every result carries its record: the procedure version followed, the sources used, the checks run and their outcome, and who ruled on what. The record shows why a result came out as it did, not only what changed.
The method does not make the AI infallible. It can still misread a procedure, write code that is wrong the same way every time, or write a check that tests the wrong thing. The method is built to catch such errors. Checks tie to independent source totals, not to the AI's own figures. Code is kept and reused, not rewritten each run. An error that gets through is exposed by the record, not hidden by it. That is the standard classic ERP itself is held to.
What auditors look at
Auditors judge a financial system on evidence: its controls and its results. Their role is to test whether controls are designed and operating to support reliable numbers. It is not to prefer one technical approach over another.
For public companies under the Sarbanes-Oxley Act (SOX), auditors test internal controls governing financial reporting, including the IT controls around the systems that produce the numbers. With classic ERP, including classic ERP with an AI wrapper added, much of what they rely on sits in a black box they cannot see. They do not read the seller's code or the hidden database and integration layers. They test the controls around them (access, change management, operations) and they test the results. For a cloud ERP, they often rely on the seller's own SOC 1 report, a report on the seller's controls by the seller's auditor. A judgment on the hidden layers themselves is not one they can make, because the evidence is not available to them.
AI work under precise instructions turns that black box into a clear box, open to anyone with the right permissions. Every part of what the system does can be explained and point-tested on request. An operator with the proper privileges can ask it why a result came out as it did, and test the answer against the code and the record. What it produces can be opened to an auditor when needed: the written procedure, the code that calculated each figure, the checks and their outcome, and who ruled. These give an auditor more to test, not less:
- The control design is written down. The procedure is the control description, in plain language, with its version history.
- The control operation is recorded. Each run logs the checks performed and their outcome, so an auditor can test operation without reconstructing it.
- The calculations can be re-performed. Figures come from kept, versioned code run on source data, so an auditor can run the same code on the same data and get the same result.
- Changes are controlled. The procedure version, the code version and the AI model version are recorded for each run. AI providers update their models, so a change to any of the three is rerun against the checks before it is used.
- Responsibility is named. A named person owns each result and rules on the exceptions, and the record shows who.
In a classic ERP process, much of this has to be pieced together from configuration, hidden code and interviews with specialists, where it can be found at all. In AI work under precise instructions, it is produced as part of the work.
What this means for a buyer
For a company weighing AI in its business systems, the question is not whether AI can be precise. It is whether the AI work is held to a method that makes it precise. A buyer can test that directly with any seller:
- Ask for the written procedure. The transaction rules each process follows should exist in plain language. This includes validation rules and other rule sets. Ask also whether the system keeps those plain-language rules in step with the code as it changes.
- Ask where the figures are calculated. Figures should come from code run on source data, not from an AI's own estimate. Pick a few figures yourself, rather than taking the seller's examples, and have the system trace each one down to its detailed calculation rules (item 1) and its source data. The trace should also show the record of the run: the procedure version, the sources, the checks and their outcome, and who ruled.
- Ask what happens when a check fails. The work should stop. A warning passed along is not a control. See a failed check stop the work on a test case you choose.
- Ask who rules on the result. A named person should own every result, for day-to-day operations and for system changes. Learn the methods that let review run on efficient exception analysis: every result is checked automatically, and people review the exceptions and variances. Validation stays on. As ongoing transactions prove repeatably stable, human review can move from every exception to sampling.
- Ask how the process is watched and kept current. There should be a management layer over the AI work that continually tests and probes for structural issues. It should also let the changes the buyer's users ask for be made, checked and put into use quickly, under the same written procedure and record.
- Ask what can post without passing the validation rules. The answer should be nothing. Every entry, whoever or whatever proposed it, should pass the same rules before it posts. Those rules should be written, tested and versioned like the rest of the system.
The same six questions apply to an AI-native ERP product, to AI wrappers added to a current ERP, where the answers will show the limits described above, and to a company's own AI work. As AI takes on more of the work classic ERP has done, these controls are estimated to become a standard part of judging any business system. EAI's ERP strategy planning, selection and pre-implementation services build them into each stage.