Failed ERPs. PBJs. AI Orchestration

During the early years of my career, I was in a room of 60 angry men and women. WIth any more pressure on the fist of the CIO who was very unhappy, his fingers would have turned diamond. The occasion was a SAP cutover and it failed. I was the account manager for a company that supplied some 50 warm bodies to write ABAP code. In plain english, we were ‘customizing’ SAP to suit their processes.

A year later, the rank and file of this automaker was wrestling with SAP interfaces instead of paper forms. The toil simply moved to screens. Ask any manufacturing industry business leader about ERPs and they will look at you in the eye devoid of any emotion – because their eyes are dry with bawling at the damage these systems have inflicted on the careers of their men and women.

One stat and then we will move to the present times.

The total factor productivity measures the marginal increase in productivity for every dollar spent on technology. As you see, since you were born or (if you are as old as I am) out of college, software has largely failed to deliver productivity gains. The problem with the ERP is not that it was garguantan or it didn’t sleep on a fluffy cloud. We went ahead anyway and split it into 213 saas tools that were all on fluffy clouds. We still didn’t get the mythical productivity we were promised. Reason? Instructions.

Austin Vernon is a great explainer of things. Follow him: https://x.com/Vernon3Austin

I can write about why software failed but you should read his PBJ example. I am reproducing it verbatim from his article.

Quote

Tell me How to Make a PB&J

There is a classic game that teachers and camp counselors play with their students. The game is that the teacher acts oblivious, and the students have to give the teacher precise instructions on how to make a peanut butter and jelly sandwich. Hilarity ensues. MIT robotics gives this example from a teacher lesson plan.

1. Take a slice of bread

2. Put peanut butter on the slice

3. Take a second slice of bread

4. Put jelly on that slice

5. Press the slices of bread together

The ideal instruction set is much more complex than you would naturally tell another human:

1. Take a slice of bread

2. Open the jar of peanut butter by twisting the lid counter clockwise

3. Pick up a knife by the handle

4. Insert the knife into the jar of peanut butter

5. Withdraw the knife from the jar of peanut butter and run it across the slice of bread

6. Take a second slice of bread

7. Repeat steps 2-5 with the second slice of bread and the jar of jelly.

8. Press the two slices of bread together such that the peanut butter and jelly meet

The gap between these instructions is a form of tacit knowledge. Humans acquire tacit knowledge through watching or practice. Computers require even more exacting instructions than our acceptable PB&J answer because they have zero tacit knowledge. Every command ends up as ones and zeros. A humbling part of writing software is that the computer does exactly what you tell it to do.

Unquote

ERPs failed because it made humans work unintuitively.

AI is different. It is not a management tool like ERP

AI is different because the tacit knowledge of humans making PBJ sandwich need not be “coded.” AI simply watches (gets trained) and it understands (too simplistic but the framing holds enough merit to proceed).

So far, software has focused on automating shared services functions but through a rigid worldview that there is ‘a right way of doing things’ and most companies should simply adopt them. Even assuming that is the case for shared services, it fails to acknowledge the legacy of how a company is structured and how it grows. All organizations have process debts and variances that are perfectly explainable.

Software companies saw these debts and variances as customization dollars. While in theory, shared services automation promised standardization and de-bottlnecking at the peripheries (not at the production line!), in reality it became a war of attrition between business units and software vendors. The software vendors won, even if it is at the cost of ‘total factor productivity.’

That is until now.

The biggest reason ERPs failed is because the tacit knowledge transfer from the doers (the client) and the implementers (the software vendor) was rarely perfect. Human understanding was sub-par. The other problem was that work slowed down at the altar of process adherence. Process creeped on purpose, whenever an ERP was implemented. Heck, there was an ERP cutover at our largest client and we had to wait for weeks on tenterhooks before they released our payments. Reason? People didn’t understand the systems and someone had to approve something four times. The human understanding of processes and their translation to software, clearly failed here.

With AI, and especially with its multi-modal capabilities, both documented and undocumented standard operating procedures (and the non-standard ones) can be captured – from paper documents to meeting recordings. Besides, with AI, the software get a process executed with all its exceptions, can be custom-coded. With AI agents, some process steps can even be completely skipped – because humans won’t need a bunch of screens to see, do, and push work over to the next human. With AI, the first in the process line human and the subsequent human are the same AI agent. Ergo, process compression!

With the old model, humans were supplying the tacit knowledge, other humans were interpreting them, and building systems that were imperfect representations of that tacit knowledge. As a result, humans did a lot of work to fill the gaps. This is why, with ERPs, you do the real work and then do the work again inside the ERP to “record-keep” and communicate to the next person in the line.

With AI, the tacit knowledge gain, process compression, and process representation & automation through AI agent workflows all happen within one intelligent system. Unlike ERP, this intelligent system is purpose-built. So the ERP (the system of record) simply becomes a data store. The human specialist from the shared services departments that used the ERP, simply becomes an orchestrator. The system of intelligence makes ERP a data store, and the human an orchestrator.

This is the future of software systems that enable work.

Crying Wolf

You cannot get someone to accept a truth when their job depends on not seeing it. This is where software vendors and system integrators are. If they understand this shift, they cannot bill you for expensive box software nor can their system integrators bill you for customizing that box of software. Their revenue is on the line. The best way to beat innovator’s dilemma is to embrace the innovation whole-heartedly, even if it means sacrificing stock prices for years. Very few companies can make that decision. Its harder for SaaS companies to do that because there isn’t much cash reserves to even do it.

The questions of AI safety, consistency, etc. matter. They are perfect wolves to cry about. But they all have reasonable answers. For every LLM hallucination objection there is a knowledge graph. For every agent failure, there is an orchestration engine. The answers are emerging. Depending on which side of the history software vendors are, they either amplify the risks to protect the turf or downplay them to dislodge the incumbents.