There is a tension at the heart of building with AI. Large language models are remarkable at the things traditional software is bad at — reading messy input, reasoning, deciding, summarizing, adapting. But they are non-deterministic: ask the same thing twice and you may get two different answers. Automations are the opposite. They are utterly reliable and utterly literal — they do exactly what you specified, every time, which is wonderful right up to the moment the situation needs a little judgement.
Most platforms make you choose. You either get rigid, predictable workflows, or you hand a task to an AI and hope. The work that landed this period refuses that choice. You can now launch an AI agent from an automation, watch it work turn by turn, and let your own deterministic logic steer what happens next. The reliability of a workflow and the reasoning of a model, in one process.
The two halves of a good process
Think about how a capable person handles a task. There are the parts that follow rules — check the value, route to the right team, record the outcome — and the parts that need thought — read this awkward request and work out what it actually wants. A good process needs both, and historically you had to build them in different worlds: deterministic steps in your automation tool, reasoning somewhere off in an AI integration, with a brittle handoff in between. Bringing the two together in one flow is what makes this powerful.
Launch an agent from a workflow
An automation can now start an agentic run as a step — not a single question-and-answer, but a genuine agent that can work through a task across multiple turns, using tools to get things done. The workflow sets it going with the context and the goal, and the agent gets to work. Everything around it — the triggers, the branches, the other steps — stays exactly as dependable as before. The agent is one capable participant inside a process you still control.
Steer it turn by turn
This is the heart of it. An agentic run is not a sealed box you open only at the end. As the agent works, your automation can see each turn as it happens — the output, the progress, the direction it is taking. And because your deterministic logic is watching, it can act on what it sees: nudge the run, notify someone, branch the workflow, or decide the agent has done enough and move on. Per-turn visibility turns "let the AI run and pray" into "let the AI reason, and keep a firm hand on the wheel." That blend — model reasoning under deterministic supervision — is exactly the combination that has been so hard to achieve until now.
Reusable, named agents
The agents you put to work are not anonymous, one-off configurations. You can set up an agent — its instructions, its tools, its behaviour — and then call it by name from inside a workflow. The same well-tuned agent can be reused across many automations, and improving it in one place improves it everywhere it is used. Your processes compose from reliable building blocks, and your agents are some of those blocks.
Long-running, but never a black box
Real agentic work takes time — several turns, external calls, genuine effort. Tasks like that used to mean staring at a spinner with no idea what was happening. Now these runs are properly asynchronous, with live results: the work happens in the background, and you can watch it unfold in real time rather than waiting blindly for a final answer. A long-running agent becomes something you can observe and trust, not a mystery you hope resolves.
Suspend, wait, and resume
Because the work is asynchronous, a workflow does not have to sit and block while an agent thinks. It can dispatch the run, suspend, and pick up exactly where it left off when the result arrives — carrying on with the next deterministic step as if no time had passed. Processes that involve waiting — for an agent, for an external system, for anything that takes a while — stay efficient and orderly instead of holding everything hostage.
Why it matters
This is the combination people have been reaching for since LLMs arrived: the creativity and adaptability of a model, fenced and guided by logic you can count on. Deterministic where it must be, intelligent where it pays to be — and, crucially, with the deterministic side in charge. You are not replacing your workflows with an AI; you are giving your workflows access to reasoning, on your terms, turn by turn.
It connects naturally to everything around it: the agents can reach your data and external MCP servers for tools, the runs slot into the same automation builder you already use, and results flow on through the rest of your process and out via the REST API. The line between "automation" and "AI" has effectively dissolved — what is left is simply a more capable way to get work done.