You’re not doing AI transformation. You’re doing AI decoration.

Every enterprise AI story right now follows the same plot. You pick a system — Salesforce, Workday, SAP, NetSuite — and you bolt an AI agent on top of it. The agent can summarize deals. It can write follow-up emails. It can pull a report without you clicking through five dashboards.

It is genuinely useful. And it is not transformation.

What you have built is a smarter interface on top of a system designed for humans. The underlying architecture, the data model, the process logic — all of it was built assuming a human being would sit in the middle, making judgment calls, translating between departments, compensating for the gaps.

You did not transform your operations. You gave them a nicer hat.

The 20% problem

Here is what makes this more than a philosophical complaint.

Every enterprise has roughly 20% of its processes that are unique — specific to how your company actually operates. Your deal structure. Your approval chains. Your exceptions. That 20% is where your competitive differentiation lives. It is also where your system of record breaks down.

Salesforce was not built for your 20%. Neither was SAP or Workday. They were built for the 80% common across industries. To cover your 20%, you customize. That customization costs, conservatively, 30–40% of your annual license fee.

For complex implementations, Forrester puts it closer to 100–200%. You are paying roughly as much to bend these systems to your reality as you are for the system itself.

Now add an AI agent. That agent inherits every compromise you have made. It learns your customization debt. It hits the same walls your human operators hit, just faster. You have not removed the constraint. You have automated the collision.

The three steps

True transformation requires rebuilding the foundation. Not ripping everything out on day one — that is how projects die in committee. But rebuilding deliberately, in sequence.

• Map your processes and capture the decisions your people make daily.
• Build a business process API that encodes that logic — before integrating anything.
• Integrate into production, run in parallel, then decide whether to keep or promote.

Step 1: Map your processes and capture the decisions

Before you build anything, understand your business process as it actually runs — not the version your system of record was configured to approximate. Right now, your process has been bent to fit Salesforce's data model, constrained by SAP's approval flows, forced to route around Workday's exceptions.

The real process lives in the gaps: the Slack thread that bridges two systems, the spreadsheet that handles what the SoR cannot, the workaround your team runs every Thursday because the tool never learned your edge case.

That is what you need to map. Not the system — the process the system was supposed to serve.

This is where tools like Klarity (klarity.ai) are useful. Unlike traditional process mining that reads system logs, Klarity observes human workflows across applications — capturing the decisions, handoffs, and compensations that never make it into Salesforce. Those are critical. They are the algorithm you need to encode. And right now, they exist only in your people's heads.

Step 2: Build a business process API — before you integrate with anything

This is the step most companies skip, and it is the whole game.

For each process you have mapped, build an API that encodes the logic — including the decisions your people make daily. Then build an emulator: a fully functioning simulation of how your ideal agent-native system of record would operate, running on synthetic data.

At this stage, nothing touches your production systems. Agents run on top of the business process API through CLI and MCP. You iterate in a sandboxed environment until you are satisfied with how the process works — optimized for agents, not for human navigation.

We did this at Keboola. We started with purchase orders in finance. Built the API, built the emulator, ran agents against it with synthetic data. When we were satisfied, we moved to the next process: travel. Then, eventually, CRM.

Step 3: Integrate into your existing systems — then decide

Once the emulator is validated, you start integrating into your production environment. You connect to Salesforce, HubSpot, or whatever your system of record is, and you immediately see where it does not fulfill what you designed. Where the existing system is the constraint, not the facilitator.

You run both in parallel. Your new agent-native system and your legacy system of record operate simultaneously. You back all data. You observe.

At some point you make a decision: keep the agents as an orchestration layer on top of both, or promote your native system to your core system of record.

We made the latter choice with CRM. We were not happy with how Salesforce fit our actual process. We now have a fully agentic CRM built specifically for how Keboola sells. Agents call into it via Claude, via CLI, via MCP. It is SOC 2 Type 2 certified, HIPAA compliant, DORA aligned — enterprise-grade in every dimension that matters.

The process that used to require navigating multiple screens now requires a conversation.

What the end state looks like

In a native agentic system, agents do not just query data — they transact. They close steps in a workflow. They update state. They coordinate with other agents across processes that your legacy system of record would have treated as entirely separate.

The question everyone asks: what do humans see?

You are not looking at a dashboard. You describe the view you need and an agent builds it for you — an ad-hoc interface, generated on demand, scoped exactly to your question. Think of it like Claude artifacts applied to your operational data. You are not waiting for a data team to build a report. You ask. It renders.

And if you want to change a process? You update one endpoint in the API. The change propagates. No customization ticket. No six-month implementation project. One endpoint.

The system is fully auditable, secure, and owned by you. You decide what to do with it.

Why this matters now

The companies that survive the agentic shift are not the ones that added the most AI features to their existing systems. They are the ones that rebuilt their operational foundation while their competitors were still bolting chatbots onto dashboards.

This is achievable in months. We did it in three — from starting the CRM emulator to running production on the native system. But you have to start.

Every quarter you spend optimizing agents on top of your legacy system of record is a quarter your competitors could be spending building something that operates without the constraints you inherited.

Decoration is comfortable. Transformation is competitive.

Start here

Run this audit on your own stack before you do anything else.

• What percentage of your SoR budget goes to customization annually?
• How many of your core processes live partly outside the system — in spreadsheets, Slack, or tribal knowledge?
• Pick one process that causes the most friction today. Count how many systems and workarounds it touches.

If the answer to the last question is more than two, you have a candidate for the emulator approach. If the answer to the first two questions is uncomfortable, you have an architecture problem dressed as an AI problem.

The good news: it is solvable, and faster than you think.

We have run this transformation on our own systems and on those of our customers. If you want to talk through where to start, reach out directly: talkto@keboola.com