ERP in the Agentic Era: How to Prepare

In the first week of April, I watched an AI agent handle a complete order-to-delivery workflow inside an ERP system without human intervention. It was 2 AM on a Saturday. Nobody was paying attention. The agent received an order, checked inventory, created a pick list, coordinated with the warehouse management system, triggered a shipment, and updated the customer invoice. All automatically. The customer got their shipment 4 hours earlier than it would have if a human had processed it on Monday morning.

That moment crystallized something I've been thinking about for months: the architecture question for ERP systems has completely changed. It's no longer about how humans interact with systems. It's about how agents will.

Agents Don't Think Like Humans

This is the mistake I see most companies making right now. They're preparing for agents by building better APIs or adding webhook support. That's the minimum viable threshold but it misses the point entirely.

When a human uses an ERP system, they follow a mental model: I need to do X, so I navigate to the X screen, I enter the data, I hit save. That path makes sense for human cognitive load. Agents don't have cognitive load. Agents don't have the context switching costs that make a UI logical.

An agent thinks about problems as graphs of constraints and actions. An agent needs to understand: what are my available actions, what are the preconditions for each action, what are the postconditions, and if I take action A and it violates constraint B, what do I do?

Your ERP system is not designed for that kind of reasoning.

The Competence Question

Here's what I'm actually worried about: ERP systems have been designed around the assumption that a competent human is making decisions.

Humans know not to ship an order to an address that's incomplete. Humans know not to confirm an invoice with an unmatched purchase order. Humans know that if inventory shows 500 units but the shelf is empty, something is wrong. Humans have judgment.

Agents have rules. If you tell an agent "invoice everything in the queue," and someone has queued an invoice with corrupted data, the agent will invoice the corrupted data. Confidently. Instantly.

The companies I respect are rebuilding their ERP workflows to be agent-proof. That means:

Every step requires explicit validation before it moves forward. Not "looks reasonable," but "meets these specific criteria." An agent needs to know the hard boundaries of acceptable action.

Every critical action has a verification step. Before an agent triggers a shipment, it should verify inventory, verify the order is valid, verify the destination is real, verify nothing is on hold. Each of these is a separate check. If any fail, the agent has explicit instructions on what to do.

Every agent action is logged with traceability. If an agent did something wrong, you need to understand exactly what it did and why. That means immutable audit trails, not transaction logs you can modify later.

The API Problem

Right now, most ERP systems have APIs that are human-centric. They return data in the shape that's useful for a person reading a screen. They require pagination. They sometimes return partial data. They have rate limits. They were designed to avoid overloading the server, not to enable autonomous agents.

Agents need different APIs. Agents need:

APIs that return complete, consistent data. If an agent asks "what is the current inventory," it needs one call, not ten paginated calls that might have changed between requests. It needs the data to be consistent—if the total is 500 units, the sum of locations should actually be 500.

APIs that support transactions. An agent needs to be able to say "check this, then do that, then verify the result, and if anything fails, roll back the whole thing." Most ERP APIs are single-action. An agent needs multi-step atomic operations.

APIs that can be called from untrusted code. An agent running in a sandboxed environment making decisions it might not be 100% sure about needs permission models that don't require a human to approve every action. That's different from how permissions work in human-centric systems.

I've been working with ERP vendors to rethink API design for agents. It's a real problem. The companies that solve this first will have a massive advantage.

The Governance Nightmare

Here's the thing nobody talks about: agents break governance.

In your current ERP system, you have approval workflows. A payment over $10,000 needs two signatures. An agent can't give signatures. What does it do? Skip the approval? Wait forever?

You have segregation of duties rules. The person who creates a purchase order shouldn't be the person who approves it. But an agent can do both in microseconds. How do you enforce segregation of duties on an agent?

You have audit requirements. Regulators want to know who did what and when. If an agent did it, "agent" isn't enough. You need to know which human owns the agent's actions, why the agent was authorized to take them, and what controls should have prevented it from going wrong.

The companies that are being smart about this are building governance that's separate from the execution layer. They're saying: agents can execute anything they're technically capable of, but only after governance rules have been checked and logged.

That requires a whole new layer in your ERP stack.

The Honest Risks

I need to be direct about the risks here because I'm seeing companies move too fast:

An agent that's been given permission to process invoices and has a bug in its reasoning can process thousands of bad invoices in seconds. The damage is done before a human notices.

An agent that's coordinating with another agent (agent A creates a purchase order, agent B approves it) can get into loops where agents are fighting each other trying to satisfy conflicting constraints.

An agent that's supposed to be operating only on recent data might not understand data dependency and try to process something based on stale information.

These aren't theoretical. I've seen all three happen in production in the last six months.

How to Start

If you're serious about agent-readiness, here's what I'd do:

First, audit your current processes. Which ones are mechanical and rule-based? Those are your agent candidates. Which ones require judgment and context? Those need human involvement. Be honest about this.

Second, build sandboxes. Run agents against a copy of your data in a limited environment. Let them make mistakes. Learn from what breaks.

Third, start with agents on low-stakes workflows. Let an agent handle purchase order creation for routine items. Let it process standard invoices that match POs. Don't start with mission-critical revenue recognition or financial close procedures.

Fourth, build governance and verification. Every agent action should be logged, justified, and reversible. If an agent does something wrong, you should be able to undo it and understand what went wrong.

Fifth, think about your API layer. Whether you're using an ERP system from a vendor or building your own, the API layer is where agent capability lives or dies.

The Timeline

This isn't a future problem. By 2027, agentic ERP workflows will be a standard feature in every major ERP system. Companies that wait until then will be behind. Companies that start preparing now—fixing their processes, rethinking their APIs, building governance—will be running laps around their competitors.

The infrastructure for agents is here. Your ERP system just needs to be ready to host them.