Sheila Kaye Jameson was a logistics analyst at EnerSys Corporation in Reading, Pennsylvania, not an executive, not someone with unusual authority. Over roughly eleven years she embezzled approximately $1.8 million from her employer using a company she invented herself. She was sentenced to 48 months in federal prison and ordered to pay $1,864,024 in restitution to EnerSys and its insurer, plus $256,447 in back taxes to the IRS.

What happened

Jameson created a shell corporation called Aries Consulting Group. It did no work for EnerSys. It provided no services, delivered no goods, and had no legitimate business relationship with the company at all. What it had was a name, a bank account, and a place in EnerSys’s vendor records. Jameson used her position to submit invoices from Aries Consulting to EnerSys, and EnerSys paid them, for over a decade, on the strength of nothing more than an invoice arriving from a vendor that existed in the system.

She also failed to report any of the embezzled income on her federal tax returns, which added tax fraud charges on top of the mail fraud charge she ultimately pleaded guilty to.

Why the gap existed

This case is the purest version of a problem that shows up across every entry in this series so far: a system that verifies a vendor once, at onboarding, and then trusts that vendor’s invoices indefinitely without asking whether the underlying business relationship still makes sense, or ever made sense in the first place.

Eleven years is the number that should stop anyone reading this. Not eleven months, not two years. Eleven years of invoices from a company that never did a single hour of real work, moving through an accounts payable process that had every opportunity to ask “what does Aries Consulting actually do for us” and never did.

That question doesn’t get asked because vendor verification tends to be treated as a one-time gate. Pass it once at setup, and the vendor becomes permanently trusted infrastructure. Nobody re-examines a vendor relationship that has been running smoothly for years, precisely because it has been running smoothly for years. The absence of a problem gets read as evidence there isn’t one, when it might just mean nobody has looked.

Controls that would have caught it

A recurring vendor spend review is the most direct control here: a periodic requirement that every vendor above a spend threshold be re-justified with a current description of the services being provided and evidence that those services were actually delivered. Not a renewal of a contract. An active accounting for what the money is buying.

A second, more structural control targets exactly the gap Jameson exploited: any vendor whose only interaction with the company is invoicing, with no purchase orders, no receiving records, no contract on file, and no employee outside the person who onboarded them able to describe what the vendor does, should be flagged automatically for review regardless of how long the relationship has run. Tenure should never be treated as verification.

A third control, specific to logistics and operations roles with vendor-creation authority, is separating who can create a new vendor record from who can approve payments to that vendor. Jameson’s position gave her enough reach to do both. A system where those two functions sit with different people doesn’t stop a determined employee from ever attempting fraud, but it does stop one person from running the entire scheme alone for a decade without anyone else’s decision ever touching it.

An AI prompt example for ERP fraud detection

The pattern this scheme depended on, a vendor relationship with invoices but no other supporting business activity, is exactly the kind of thing worth checking continuously rather than during an occasional audit. Against the ERP’s vendor, purchasing, and receiving data, a controller could run something like:

“List all active vendors with total payments over $50,000 in the last three years that have no associated purchase orders and no receiving or goods-receipt records on file.”

A second query targets the tenure blind spot directly:

“Flag any vendor active for more than five years whose invoicing pattern has not been reviewed or re-verified since initial onboarding.”

Neither question is hard to answer once it’s asked. The entire eleven years this scheme ran is evidence that nobody was asking it.

The pattern for this series

Every case in this series follows the same shape: what happened, what shared assumption let it run, what a properly governed ERP control looks like, and one or two concrete AI prompts that turn a periodic audit question into something that can run continuously. The goal isn’t to suggest AI replaces the underlying data governance. It’s to show what becomes possible once that governance exists and someone actually asks it the right question.

Source disclaimer

The case details in this article are drawn from press releases published by the U.S. Attorney’s Office for the Eastern District of Pennsylvania, a public government source. All facts, figures, and quotations describing the case are sourced from those releases. The analysis of the control gap, the proposed detection controls, and the AI prompt examples are original commentary and are not part of the source material.

References

United States Attorney’s Office, Eastern District of Pennsylvania. “Corporate Employee Sentenced For Embezzlement And Tax Fraud.” Press release. https://www.justice.gov/usao-edpa/pr/corporate-employee-sentenced-embezzlement-and-tax-fraud

United States Attorney’s Office, Eastern District of Pennsylvania. “Corporate Employee Charged With Embezzlement And Tax Fraud.” Press release, June 28, 2012. https://www.justice.gov/archive/usao/pae/News/2012/June/jameson_release.htm

In 2022, a Minnesota woman was sentenced to more than nine years in federal prison for embezzling over $881,000 from a Denny’s franchisee and a family-owned construction company. What makes this case worth a second look, beyond the last article’s Randstad payroll scheme, is that the same person ran two separate fraud channels through the same underlying weakness, and neither channel needed to be sophisticated to work for five years.

What happened

As Director of Operations for MI5, Inc., Kimberly Sue Peterson-Janovec had oversight of payroll, vendor billing, and cash deposits across eight restaurant locations. She used that access two ways. First, she submitted false requests for vendor payments, creating fake email accounts to impersonate vendor employees and generate fake correspondence supporting the payments, netting roughly $336,000. Second, and separately, she manipulated the payroll system to issue herself unauthorized pay using the names of employees who no longer worked for the company, netting another $20,000. On top of that, she was held responsible for an additional $181,000 in stolen cash deposits.

Two different fraud mechanisms, one root cause. Both vendor identity and employee identity were things the system trusted once established and never re-verified.

Why one control gap produced two exploits

Most ERP fraud writeups treat vendor fraud and payroll fraud as separate problems needing separate controls. They usually are separate controls in practice, but they share the same underlying assumption: once a master record exists, whether it is a vendor or an employee, the system treats it as valid until someone actively flags it. Nobody was asking the system to continuously re-verify “is this vendor real” or “is this employee still employed” on every transaction. Both checks happened, if at all, as periodic manual review rather than a standing rule enforced on every payment run.

That is the pattern worth generalizing. A fraud scheme doesn’t need two different weaknesses to run two different exploits. It needs one weak assumption that both processes happen to share.

Controls that would have caught it

Vendor side. A governed vendor master process should treat any new vendor contact channel, especially email domains that don’t match a registered business domain, as a flag requiring secondary approval before the first payment goes out. Cross-referencing vendor contact emails against internal employee email patterns is a cheap, high-value check most ERP implementations never configure, because it isn’t a default workflow. It has to be built.

Payroll side. Every pay run should cross-check active employee status at the moment of payment, not rely on a termination flag set once in HR and assumed to propagate. In practice, this means the HR and payroll integration needs to be a hard gate, not a soft sync, so a terminated worker record cannot appear as a valid payee in any pay run regardless of when the termination was recorded relative to payroll cutoff.

Both sides. The five-year duration of this scheme is the real tell. Neither vendor payments nor payroll runs were being reviewed for anomalies as a routine, systemic process. They were being trusted because they had always been trusted.

An AI prompt example for ERP fraud detection

This is where AI-assisted review earns its place, not replacing the controls above but catching what static rules miss because nobody thought to write the rule. Using a natural-language query layer against the ERP’s vendor and payroll data, a controller could run something like:

“Compare vendor contact email domains against our employee email domain. Flag any vendor created in the last 24 months where the contact email domain is unregistered, uses a free email provider, or closely resembles an employee’s name.”

And separately:

“List all payroll disbursements in the last fiscal year paid to employee IDs with a termination date recorded in HR prior to the pay period start date.”

Neither query requires new functionality. Both require someone to think to ask the question, which is exactly what a five-year undetected scheme tells you nobody was doing. The value of an AI layer here isn’t that it catches something a human couldn’t. It’s that it makes asking the question cheap enough to do routinely instead of only after something else triggers an audit.

The pattern for this series

Every case in this series will follow the same shape: what happened, what shared assumption let it run, what a properly governed ERP control looks like, and one or two concrete AI prompts that turn a periodic audit question into something that can run continuously. The goal isn’t to suggest AI replaces the underlying data governance. It’s to show what becomes possible once that governance exists and someone actually asks it the right question.

Source disclaimer

The case details in this article are drawn from a press release published by the U.S. Attorney’s Office for the District of Minnesota, a public government source, along with contemporaneous news coverage of the same case. All facts, figures, and quotations describing the case are sourced from those releases and reports. The analysis of the shared control gap, the proposed detection controls, and the AI prompt examples are original commentary and are not part of the source material.

References

United States Attorney’s Office, District of Minnesota. “Kenyon Bookkeeper Sentenced to More Than 9 Years Prison for $881,000 Employer Embezzlement and Tax Fraud Scheme.” Press release. https://www.justice.gov/usao-mn/pr/kenyon-bookkeeper-sentenced-more-9-years-prison-881000-employer-embezzlement-and-tax

Walsh, Paul. “Woman who embezzled $880,000 from Denny’s franchisee, Rochester company gets 9 years.” Minnesota Star Tribune, June 2022. https://www.startribune.com/9-1-4-years-in-prison-for-woman-who-embezzled-880k-from-dennys-franchisee-rochester-company/600184577

Enterprise software has spent forty years arguing about the same question in different clothes. Should a function do one thing correctly, or should a tool be given enough authority to figure things out on its own. Agentic AI has not settled that argument. It has just given it a new vocabulary.

Look at the two ends of what is shipping right now. SAP’s Joule agents, and most of the enterprise agent catalog around them, are built narrow. Each one has a defined job, a defined sequence, and a defined set of systems it is allowed to touch. An invoice reconciliation agent reconciles invoices. It does not decide to also check vendor master data for anomalies unless that step was explicitly wired into its process. Microsoft’s Cowork points at the opposite pole. It is handed a single broad tool, effectively full reach into a Dynamics 365 Finance and Operations environment, and told to figure out how to get a stated outcome done. Nobody hand built a sequence for it. It builds its own.

Both are called agents. They are not the same kind of thing, and the difference matters more than the marketing suggests.

What a specialized agent actually is

A specialized agent is closer to a very well automated macro than it is to a colleague. It has a fixed task, a fixed order of operations, and a boundary around what data and systems it can reach. This is not a limitation bolted on as an afterthought. It is the entire design philosophy. You get predictability in exchange for narrowness. When the invoice reconciliation agent runs, you know what steps it took, in what order, against what data, because those steps were specified in advance. If it fails, it fails in a way you can trace to a specific step that did not resolve.

That traceability is not incidental in a finance system. It is the whole point. An auditor does not want to hear that an agent figured out how to close the period. They want a sequence of steps that can be replayed, checked, and defended.

What a generalized agent actually is

A generalized agent like Cowork inverts that trade. Instead of many narrow tools each doing one job, it gets one wide tool and the discretion to decide, at run time, what sequence of actions gets it from the stated goal to a finished result. Ask it to reconcile a vendor’s account for the quarter and it will decide for itself which records to pull, which discrepancies are worth flagging, and in what order to check them. Two runs against the same request, on the same data, are not guaranteed to take the same path to get there.

That is not a bug in the current generation of these tools. It is the feature being sold. A generalized agent does not need someone to have anticipated every scenario in advance and built a process for it. It reasons its way through situations nobody wrote a workflow for. The cost of that flexibility is that the path it takes on any given run is not fully knowable ahead of time, and reproducing it exactly on demand is harder than reproducing a fixed sequence.

The real axis underneath the label

Specialized versus generalized describes the shape of the agent. It does not describe the thing that actually matters to a finance or operations leader deciding whether to trust one of these near a ledger. That deeper axis is deterministic versus probabilistic.

A deterministic process, whether run by a person, a script, or a narrow agent, produces the same output from the same input every time. A three way match either passes or it does not, based on rules that do not change between Tuesday and Thursday. A probabilistic process, which is what a large language model doing open ended reasoning actually is underneath the interface, produces an output that is likely to be correct given the input, not guaranteed to be correct. Run it twice and you may get two answers that are both individually defensible and are not identical.

Specialized agents tend to sit closer to the deterministic end, because their designers constrained the decision space in advance and left little room for the model to improvise. Generalized agents tend to sit closer to the probabilistic end, because improvisation across an open ended tool is the entire value proposition. But the two axes are not the same axis wearing different names, and conflating them is where a lot of the current enterprise anxiety about agents actually comes from. A specialized agent can still make a probabilistic judgment call inside one of its fixed steps, such as classifying a transaction description as likely fraudulent. A generalized agent can still land on a fully deterministic sub task, such as pulling a specific ledger balance, where there is only one correct answer and no room to improvise.

Why D365 F&O is the place this gets tested for real

Dynamics 365 Finance and Operations is a useful proving ground precisely because it already lives with both philosophies side by side. Its native controls, workflow approvals, posting rules, three way match, are deterministic by construction. They were built that way before anyone was talking about agents, because a ledger that produces a different answer on a re-run is not a ledger anyone can close a period against.

Layer Copilot style features and Cowork on top of that and you get a system where the system of record stays deterministic while the layer working on top of it is free to reason probabilistically about what needs attention. That is not a contradiction. It is the correct division of labor. The ledger should never guess. The agent looking for the discrepancy that the ledger’s own rules were not written to catch is allowed to guess, because guessing well is precisely what it is there to do.

The mistake worth watching for is treating a generalized, probabilistic agent as if it were a specialized, deterministic one because it happens to be plugged into the same system. Giving Cowork the same blind trust you would give a fixed three way match rule is a category error. One was built to never deviate. The other was built to deviate on purpose, whenever deviating produces a better answer.

Where this actually lands

Neither shape is the correct answer in general. A specialized agent is the right tool when the process is well understood, the stakes of an unreviewed error are high, and an auditor will eventually ask for the sequence of steps. A generalized agent is the right tool when the problem is not well understood in advance, when the value comes from adapting to a situation nobody scripted for, and when a human is still positioned to review the output before it becomes a transaction that cannot be undone.

The organizations getting this right are not the ones picking a side. They are the ones that have stopped asking whether an agent is good, and started asking where on both axes, specialized to generalized and deterministic to probabilistic, a given task actually belongs. Get that placement wrong in either direction and you either waste a general reasoning tool on a task a five line business rule already solved, or you hand a fixed script a problem it was never built to handle and call the resulting failure a bug instead of what it actually is, a design mismatch.

In 2009, a former branch manager at Randstad was sentenced to five years and one month in federal prison for wire fraud and aggravated identity theft. The scheme ran for three years before anyone caught it. The method behind it was almost boring, which is exactly why it worked.

What happened

Cynthia Whitehead used the real names of former Randstad employees, people who had already left the company, to generate wage payments through the payroll system. She then kept those “wages” for herself. From 2004 to 2007 she embezzled more than a quarter of a million dollars this way. She pleaded guilty on July 8, 2009, and was ordered to pay $286,388.37 in restitution on top of the prison sentence.

Nobody defeated a clever fraud control here. The scheme worked because a former employee’s identity remained valid and payable inside the system long after that person had stopped working there.

Why the gap existed

The failure point sits exactly at the boundary between two systems that were supposed to agree with each other: HR, which knew someone had left, and payroll, which kept generating payments as if they hadn’t. That boundary is where this kind of fraud always hides. It isn’t defeating a rule. It’s exploiting the fact that two systems of record were allowed to disagree for as long as nobody checked.

A termination event should be the kind of thing that instantly and automatically closes off every downstream ability to pay that person again. In practice, in a lot of ERP implementations, it’s a status field that gets updated in one module and trusted to eventually matter everywhere else. Three years of undetected fraud is what “eventually” costs.

Controls that would have caught it

The control here isn’t exotic. A payroll run should not be able to issue a payment to any employee ID with an active termination date, full stop, checked at the moment of disbursement rather than assumed from a status flag set once and never re-verified. In practice, this means the integration between the HR module and the payroll module needs to function as a hard gate on every pay run, not a background sync that payroll happens to respect most of the time.

The harder part isn’t designing that rule. It’s noticing that it needs to be designed at all, because on paper the termination process already “worked.” The employee’s status did get updated. Nobody had built the check that made that status update actually block a payment.

An AI prompt example for ERP fraud detection

This is a case where an AI-assisted review layer earns its keep, not by replacing the underlying control but by making it cheap enough to run constantly instead of only during an annual audit. Against the ERP’s HR and payroll data, a controller could run something like:

“List every payroll disbursement in the last three fiscal years paid to an employee ID with a termination date recorded prior to the pay period start date.”

A second, complementary query catches slower variants of the same pattern:

“Flag any employee ID that received a payment more than 30 days after their most recent termination or leave-of-absence date recorded in HR.”

Neither prompt requires new system functionality. Both require someone to think to ask the question on a recurring basis rather than only after a tip or an audit forces the issue. That is the actual lesson of this case. The rule that would have stopped it wasn’t complicated. It just wasn’t being asked.

The pattern for this series

This is the first case in a series looking at real, documented ERP fraud schemes: what happened, what shared assumption in the underlying system let it run, what a properly governed control looks like, and a concrete AI prompt that turns a periodic audit question into something that can run continuously. The goal is never to suggest AI replaces the governance. It’s to show what becomes possible once the governance exists and someone actually asks it the right question.

Source disclaimer

The case details in this article are drawn from a press release published by the U.S. Attorney’s Office for the Northern District of Georgia, a public government source. All facts, figures, and quotations describing the case are sourced from that release. The analysis of the control gap, the proposed detection controls, and the AI prompt examples are original commentary and are not part of the source material.

References

United States Attorney’s Office, Northern District of Georgia. “Former Randstad Branch Manager Sentenced to Federal Prison for Embezzlement.” Press release, September 16, 2009. https://www.justice.gov/archive/usao/gan/press/2009/09-16-09c.pdf

I have heard rumours that some companies are starting to vibe code their own ERP systems. Is this the start of the decline of standardized ERP systems, and the start of company specific Business Operating Systems? If every business had its own OS, and an agentic framework, why is there any need to have standardized ERP systems?

It is a fair question, and one worth taking seriously instead of dismissing on reflex. But after digging into what is actually happening in the market, I do not think ERP is dying. I think something more interesting and more useful is happening at its edges.

What Companies Are Actually Vibe Coding

The companies experimenting with AI generated business software right now are almost entirely building at the periphery of ERP, not in its core. A Copilot Cowork style agent that reconciles a report. A custom approval workflow. A data cleanup script. A bolt on dashboard that nobody wanted to wait six weeks for IT to build. Very few organizations are vibe coding their general ledger, their costing engine, or their multi entity intercompany eliminations, and there is a good reason for that.

There is a real gap between “AI helped me build software” and “AI helped me build enterprise grade, auditable, multi user, transactionally consistent financial software.” That gap is where most of the current enthusiasm quietly runs out of road. One recent piece on the risks of vibe coding put it plainly: the danger is not that these tools fail to work. The software appears to work right up until the business reaches a level of complexity that exposes what was never built in the first place. Security, monitoring, compliance, and disaster recovery do not show up in a demo. They show up eighteen months later when something breaks and there is no vendor to call.

We Have Been Here Before

There is also a useful historical echo worth remembering. Standardized platforms like SAP, Oracle, PeopleSoft, and later NetSuite and Salesforce did not emerge in a vacuum. They emerged because “build your own” had already been tried extensively in the eighties and nineties, and the industry collectively decided that a professionally maintained, continuously improved, shared system was the better bargain. One system, supported by a vendor with thousands of customers absorbing the cost of getting tax law and audit controls right, beat a thousand bespoke systems each carrying that burden alone.

Vibe coding does not remove the reasons that decision was made three decades ago. It just lowers the upfront cost of relearning them the hard way.

Two Layers That Want Different Economics

The question of “why standardize if every business can have its own OS” collapses two layers of the business that actually want very different things.

The first layer is the system of record. This is the ledger, inventory, costing, tax, and consolidation logic. This layer wants low variance, not customization. Its value comes from being provably correct under audit, from producing the same math every quarter regardless of who is running the company, and from a vendor carrying the liability of getting VAT rules or SOX controls right across thousands of customers instead of one company carrying that risk alone. Agentic capability does not change the incentive to pool that risk and cost across an ecosystem. If anything it raises the stakes, because an agent posting a bad journal entry at two in the morning with no human review is a considerably scarier proposition than a person doing it.

The second layer is orchestration. This is how a specific company actually gets things done around that system of record. This is exactly where variance is valuable, and exactly where agentic frameworks and vibe coding are already winning, because it is low blast radius, fast changing, and does not need to survive a financial audit on its own merits.

The Composable Core, Not the Bespoke Empire

So the more likely outcome is not that every business ends up building its own ERP from scratch. It is something closer to a composable core: a thin, standardized, vendor maintained transactional spine, surrounded by a thick, company specific, largely agent authored layer of workflow, automation, and decision logic that talks to that spine through APIs. This is not a new architecture invented for the agentic era. It is basically the direction that platforms like Dynamics 365 Finance and Operations were already heading, with data entities and business events designed precisely so that logic could live outside the core without touching it.

The Business Operating System that gets discussed in these conversations is real. But it gets built on top of standardized ERP, not instead of it, because nobody actually wants to own tax engine liability, and no CFO wants to explain to auditors that the general ledger was vibe coded last quarter.

Where the Real Disruption Sits

If I had to point at where this trend genuinely threatens the standard ERP model, it would be three places.

The mid market and small business segment, where compliance and audit stakes are lower and the cost of a full ERP license and implementation is disproportionate to the size of the operation. This is where skipping a Tier 2 ERP entirely in favour of an agentic build of the operations layer is most economically rational.

Verticals with no good off the shelf fit, where companies already customize ERP into something barely recognizable compared to the base product. Vibe coding just makes that customization faster and cheaper. It is not a fundamentally new behaviour, it is an acceleration of an old one.

And the vendors themselves, who will not sit still and watch this happen. Expect Microsoft, SAP, and Oracle to lean hard into a “we are the trusted core, bring your own agents to the edges” positioning rather than fight the trend directly. Given where Copilot and Cowork are already headed inside the Microsoft ecosystem, this is not speculation. It is already the direction of travel.

The Verdict

Vibe coding is not the death of standardized ERP. It is the arrival of a cheap, fast way to build the layer of the business that ERP vendors were never well suited to build in the first place. The ledger stays boring, standardized, and vendor owned, because boring is exactly what you want from something an auditor has to sign off on. Everything wrapped around it just got a lot more interesting.