A year of counter-narrative

One year ago, we started building kyma with a thesis that felt almost heretical: the biggest threat to successful AI deployment isn't bad models or poor data quality. It's using AI where you don't need it. Twelve months later, that thesis has hardened into conviction.

When we started we didn't know what to build, nor how to build. But we know have learned a few things along the way.

Here's a summary of things we have learned along the way.

The 95% Problem

An MIT study confirmed what we've been seeing in the trenches: 95% of generative AI implementations have zero measurable impact on company P&L. The successful 5%? Back-office automation, the unglamorous work that Intelligent Automation practitioners have been doing for years. Sound familiar? This is RPA 2015 all over again. Different technology, same overpromises, same fundamental mistakes.

Three Principles That Don't Change

While everyone scrambles to figure out what AI "just killed," we've held firm on three unfashionable principles:

Treat It as Technology, Not Magic

AI isn't sentient. It's a tool with specific capabilities, limitations, and use cases. Just like you wouldn't deploy RPA everywhere, you shouldn't deploy AI everywhere. The moment you anthropomorphize it, you've lost the plot.

Make It Human+

The MIT study showed that failed investments overwhelmingly targeted replacing human judgment in customer service and marketing, rather than augmenting it. This is the classic automation mistake: technology that doesn't bring humans along fails to stick, or becomes prohibitively expensive to implement.

Process is Still King

Our most costly mistake in Intelligent Automation was overstressing technology while neglecting process improvement. Shitty processes don't magically become good when you sprinkle AI on them. They become shitty processes with probabilistic failure modes.

The Probabilistic Tax

Here's what nobody talks about: every LLM interaction introduces a point of failure that's exponentially harder to debug than deterministic logic.

Consider a simple workflow. With deterministic rules, failure analysis is straightforward—each step either worked or didn't. Now introduce AI components. When something breaks, you face a combinatorial explosion:

• Did the LLM misinterpret intent?

• Was the reasoning correct but context insufficient?

• Did it hallucinate something plausible but wrong?

• Is this an edge case that worked yesterday?

• Are multiple AI components interfering?

  
  

The kicker? These failures often aren't reproducible. The same input might work fine on retry. You can't fix what you can't consistently break.

This is the probabilistic tax, the hidden cost of replacing deterministic logic with AI when you don't actually need to.

The Direction Problem

Conversational interfaces are having a moment. They feel natural, intuitive, almost magical. They're also fundamentally broken for business processes.

LLMs are pathologically helpful. Ask a question poorly, and the model won't push back—it'll give you the best answer to the question you asked, not the one you should have asked.

"How can I automate this approval process?"

The LLM will enumerate automation strategies. What it won't tell you: maybe the approval process shouldn't exist at all.

Direction is set in the first exchange. Everything downstream flows from that initial framing. Try pivoting three turns deep into a conversation. Watch the model politely acknowledge your new direction while carrying the baggage of everything discussed before. Context compounds. Each exchange adds weight. The further you go in the wrong direction, the harder it becomes to course-correct.

Unstructured chat optimizes for natural conversation, not correctness. You've replaced a structured process with thousands of bespoke conversations, each one a snowflake of inefficiency. The LLM is working hard. Your employees feel heard. And absolutely nothing is standardized, measurable, or improvable.

The Minimum Viable LLM Principle

Our building process follows one rule: use deterministic logic wherever possible, LLMs only where necessary.

The Deterministic Zone (no LLMs needed):

• Data structure operations—JSON parsing, XML processing, data transformations

• Template generation—if you know the pattern, code the pattern

• Mathematical calculations—math doesn't need interpretation

• Validation rules—rules are rules

• Workflow state management—these should be predictable, not creative
  

The LLM Zone (cognitive tasks only):

• Document classification when formats vary significantly

• Business language translation into technical specifications

• Architectural decision-making based on contextual understanding

• Semantic matching between capabilities and existing libraries
  

In the deterministic zone, you're replacing human labor. In the LLM zone, you're replacing human judgment.

The Counter-Intuitive Bet

Here's our prediction: embedded AI capabilities might actually trigger a new wave of Intelligent Automation implementations led by the old workhorses, RPA and BPM.

Why? Because it's easier to build guardrails and orchestrate AI with predictable IA tools than to do pure-play AI projects. Pure AI implementations are still missing functionalities needed to scale: trust frameworks, monitoring capabilities, deterministic workflow orchestration, battle-tested error handling.

The established tools provide the containment structure that makes AI usable at scale.

Services-as-Software

Time and material contracts have been the backbone of services for decades. The model spawned an entire hidden world of timesheet memes and created toxic incentives: consultants are rewarded for being slow.

AI threatens to destroy this model entirely. Instead of selling time, you productize services, staff them with AI labor, and sell outcomes, delivered in minutes, not weeks. The value proposition flips: customer doesn't like the outcome? Customer doesn't pay. No artificial complexity, no perverse incentives.

This is the delivery framework we're building at Kyma: where AI compresses the build phase, giving teams more time for what actually matters, process design and user testing.

What We've Learned

Structure is not the enemy of AI power. Structure is what makes AI power usable.

The most sophisticated AI implementations we've seen don't look like chat interfaces. They look like structured workflows with AI embedded at specific decision points. The prompt isn't freeform; it's templated with variable injection. The direction isn't negotiated through conversation; it's predetermined by process design. The evaluation isn't optional; it's built into the workflow before results move forward.

When you need an LLM to classify a document, you don't give users a chat box and ask them to describe it. You build a classification endpoint, feed it structured inputs, evaluate outputs against known patterns, and route results deterministically.

When you need business context translation, you don't let every stakeholder prompt however they want. You design the transformation once, test it systematically, and apply it consistently.

The future of AI in enterprise isn't more autonomy. It's better orchestration.

Not every process needs an agent. Most need better process definition, deterministic scaffolding, and AI carefully applied at specific decision points where human judgment is genuinely required.

The companies that win won't be the ones with the most "agentic" systems. They'll be the ones who know exactly when to use AI and, more importantly, when not to.