Why better models won’t solve your ambiguity problem, but explicit rules will.

For a long time, enterprises optimized for speed of insight. More dashboards. Faster queries. Better charts. If a number looked odd, someone would flag it, start a discussion, and eventually straighten it out.

That approach worked, because humans were always in the loop.

What’s changing now isn’t that people are disappearing. It’s that software is starting to act on its own.

AI agents aren’t just analyzing data anymore. They execute workflows, trigger processes, move money, and change system state, much faster than people can react.

Because that happens, the tolerance for ambiguity collapses.

Ambiguity used to be manageable

Most enterprises live with ambiguity every day. Not because they like it, but because it’s manageable.

Revenue means different things depending on who is looking at it. Sales talks in bookings, Finance cares about billed and recognized revenue, and each view bakes in different assumptions about discounts and timing. Customers exist simultaneously in CRM, ERP, and BW, each system being authoritative for a different purpose.
KPIs usually aren’t wrong but they only make sense inside the fiscal variant, organizational unit, or customization they were built for.

People deal with this through experience:

• definitions get negotiated
• conflicts get escalated
• judgment fills the gaps
• tribal knowledge does a lot of quiet work

It’s not elegant, but it functions, as long as decisions stay human-paced.

Agents don’t pause

Agents don’t notice that two answers disagree, and they don’t ask who owns the definition nor do they slow down when context is missing.

They execute.

That turns ambiguity from an inconvenience into risk.

A wrong dashboard is annoying, but a wrong automated action can be expensive, contractual, or create serious compliance issues.

This is the part that’s easy to miss. When things go wrong, it’s rarely because the model can’t do the task. It’s because no one ever clearly defined the assumptions, rules, and ownership the model was expected to operate under.

This isn’t really an AI problem

It’s tempting to assume better models will solve this, but they won’t.

Models can interpolate. They can summarize. They can reason probabilistically.

What they can’t do is decide things like:

• which system is authoritative here
• when a definition applies and when it doesn’t
• who is allowed to override it
• what should happen when two rules collide

Those aren’t modeling problems. They’re organizational decisions.

Until those decisions are explicit, no amount of intelligence on top will make automation safe.

Systems of record were never really products

We talk about “systems of record” as if they were a software category: ERP, CRM, data warehouse.

That framing has always been misleading.

A system of record isn’t a product. It’s an answer with authority.

Authority means:

• this answer wins when others disagree
• it applies in a specific context
• someone owns changes to it
• violations have consequences

Enterprises already have this authority but it usually lives in people’s heads, process documents, and for example, in deeply implicit SAP logic.

Agents force those assumptions out into the open.

Truth is turning into infrastructure

As agents spread, value starts shifting away from interfaces and toward something less visible: semantic authority. Not the UI that shows a number. Not the model that talks about it, but the layer that decides what the number actually means and whether it’s safe to act on.

This layer encodes:

• business definitions
• precedence rules
• contextual constraints
• governance over action, not just access

It’s slow work. It’s unglamorous. And once it exists, it’s extremely hard to rip out.

That’s why it matters.

Governing action, not execution

This is where the conversation often gets stuck on the wrong thing.

When people think about automation, they often jump straight to execution: posting transactions, mutating systems, bypassing controls. That framing misses the more important question.

In an agentic enterprise, the real control point isn’t execution. It’s permission.

A semantic layer at this point doesn’t exist to push data into operational systems. It exists to decide:

• when an action is allowed
• under which definition and context
• with whose approval
• and with what justification

Most of the time, nothing is executed at all. What gets produced are decisions, constraints, and intent – the things that determine whether automation should happen in the first place.

If execution does follow, it flows through the same controlled paths enterprises already rely on. The risk isn’t that software might act.

The risk is that it might act without anyone having made the rules explicit.

Why this shows up over time

If you zoom out and look at how enterprise software actually ages, a pattern starts to emerge.

Products built around interfaces, workflows, or surface-level intelligence tend to be swapped out. They get redesigned, replaced, or absorbed.

What sticks are the things organizations quietly become dependent on:

• shared definitions
• agreed rules
• places where conflicts get resolved
• checkpoints before action happens

Those are the systems people hesitate to remove, because too much breaks when they do.

That stickiness isn’t accidental. It comes from reducing ambiguity at the points where decisions turn into action.

You can see the effect most clearly over time, not in features, but in what organizations are unwilling to let go of.

The real shift

We’re moving from optimizing for speed of insight
to optimizing for safety of action.

Agents compress decision time. That makes meaning, authority, and semantics the scarcest resources in the enterprise.

The future of enterprise AI won’t be defined by who builds the flashiest copilot.
It will be defined by who makes automation safe enough to trust.

One takeaway worth keeping

If there’s one thing to take away from all of this, it’s this:

Ambiguity used to be something organizations could live with. Agents change that. They turn unclear definitions and implicit rules into real risk.

The companies that do well won’t be the ones with the smartest AI on top. They’ll be the ones who took the time to make meaning, ownership, and decision rules explicit before letting software act.

That’s not a trend. It’s a shift in how organizations actually have to operate.

This is part of an ongoing conversation about turning SAP data into real, trustworthy AI outcomes, if this resonates, let’s talk.