AI is Rewriting the Rules of Workflow Engines

I've been thinking a lot about workflow engines lately — tools like Zapier, Make, and Workato — and how much AI is starting to reshape them.  

Traditionally, these platforms are built around deterministic logic: clear inputs, clear outputs, and strict definitions of what each step can do. A spreadsheet plugin, for example, can read rows or columns, maybe loop through them or apply some conditional logic. But under the hood, every one of these actions is hard-coded. Someone has written a function, defined its inputs and outputs, and mapped out exactly how it connects to the next step.  

That’s how every workflow engine of the last decade has worked — a neatly wired chain of deterministic blocks.

The AI Shift: From Inputs and Outputs to Context

AI changes this model completely.  

Instead of predefining what every step can do, we can now let steps learn from context. Each step doesn’t need to have hard-coded inputs and outputs anymore — it can contribute to a shared context that evolves as the workflow runs.  

By the time a later step needs to act, it can simply query that context (using structured outputs, embeddings, or even natural language) to find what it needs. The “output” of a step becomes less of a fixed result and more of an update to a shared memory space.

This fundamentally changes what a workflow engine is. It’s no longer just a flowchart of logic — it becomes something closer to a conversation with state.

No-Code, Finally as Promised

This also brings workflow engines closer to where no-code and low-code users have always wanted to be.  

In the old world, no-code tools still relied on users to understand inputs, outputs, and data mappings — just hidden behind friendlier UIs. With AI, users can describe what they want in natural language: “Take the data from yesterday’s survey and summarize the key themes” — and the system can figure out the rest.  

An AI-first workflow engine could even infer whether it has enough context to complete a step and visually warn the user if something’s missing — maybe a red indicator saying, “This step doesn’t have access to the survey data yet.”

That’s a huge leap. It means non-technical users can build complex automation without writing code or thinking in terms of function signatures.

Between Deterministic and Agentic

What’s even more interesting is how AI workflows let us operate anywhere along the spectrum between deterministic and probabilistic behavior.  

We can be as strict or as flexible as we want. On one end, we can still define rigid, code-based steps that guarantee predictable outcomes. On the other, we can hand an agent a goal — “Write a blog post about this dataset” — and let it figure out which tools to use and in what order.  

That’s the agentic approach: a self-directed process where the system chooses how to reach a goal.  

AI workflows blur these lines beautifully. We can define deterministic steps when we need control, and let agents handle fuzzier goals when we need flexibility. The workflow becomes a sliding scale between precision and autonomy.

The New Risk: Hidden Requirements

But this freedom comes with a risk.  

Traditional workflows forced users to specify inputs and outputs, which meant every step had clearly defined requirements. AI-driven workflows, by contrast, hide those boundaries. Non-technical users may not realize that a step depends on data that hasn’t been generated yet.  

That’s where hallucinations or failures can creep in — the system might just “guess” what’s missing. So while AI makes things easier to start, it also raises the bar for understanding what’s really happening behind the scenes.

There’s also the question of shareable components. In deterministic systems, developers create reusable building blocks — each tested and reliable. But in AI systems, users might build steps that work once but fail later when the context changes. Without guidance, these steps might not be portable or reusable at all.

Martin Fowler Was Right (Mostly)

Martin Fowler once argued that no-code tools are fundamentally flawed because they try to remove developers from the equation.  

His point was that once systems grow complex enough, you inevitably need a developer to make them maintainable. No-code, he said, is often a symptom of business impatience — a desire to move faster than development cycles allow.  

If we take his logic forward, AI offers a better path: instead of removing developers, augment them. Let AI write the code faster, fill in boilerplate, and translate business logic directly into working systems. That’s a more scalable way to deliver what businesses want — speed — without the chaos of unstructured no-code workflows.

Where Workflow Engines Go From Here

So where does that leave workflow engines like Zapier, or even OpenAI’s new Agent Builder?  

Right now, workflow engines act as duct tape between apps — the glue that holds together what software hasn’t yet automated. AI is changing that. The next generation of workflow tools won’t just move data between apps — they’ll reason about why they’re doing it, when, and what else might need to happen next.  

It’s a big shift. And while it opens the door for more natural, flexible, and intelligent automation, it also demands new thinking about how we teach non-technical users to design reliable workflows.  

AI gives us the tools. But whether we end up with magic or mess depends entirely on how we help people use them.