Early automations were a straight line. A trigger fired, one step ran, then the next, then it was done. That model is perfect for the simple cases — notify someone, stamp a field, send an email — and most automation starts there. But real processes are not straight lines. They branch. They loop over batches. They occasionally need a piece of custom logic that no fixed set of steps anticipated. And, increasingly, they need a measure of judgement that used to require a human in the loop.
Over the past period the automation builder grew up. It went from a list of steps to a genuine visual workflow engine — one that can express the actual shape of the work, run your own code when it has to, and even hand a task to an AI agent, all without standing up any infrastructure outside the platform.
Decisions and branches
The single biggest limitation of a linear automation is that it cannot say "it depends." Most processes do. An order over a threshold needs approval; one under it does not. A new record from one source is handled differently from another. With conditions and a switch, an automation can now take different paths based on the data in front of it, instead of forcing every case down the same rigid sequence. One automation can handle the whole decision tree of a process rather than splintering into a dozen near-identical copies.
Wire actions freely
Once a flow can branch, the old "ordered list of steps" picture stops fitting. Actions can now be linked freely, like a flowchart, so the structure of the automation matches the structure of the process it represents. A step can lead to the next, to a branch, or back into a shared path that several branches converge on. The diagram becomes the documentation: anyone can open it and read how the process actually works, because the layout is the logic.
Run your own JavaScript
However rich a library of building blocks becomes, there is always the one transformation, the one calculation, the one bit of glue that is specific to your situation. Rather than forcing that logic out to an external service and back over a webhook, you can now drop JavaScript directly into a flow. The custom step lives inside the automation, runs as part of it, and is versioned and visible alongside everything else. The escape hatch is built in, so "we need something custom here" no longer means "we need to leave the platform."
AI that acts, not just answers
A chat assistant answers a question and stops. A growing number of tasks need something more: read this, decide what is relevant, take the next step, check the result, continue. An agent action can now do exactly that inside an automation — working through a task across multiple steps, using the platform's own capabilities to get it done, and returning the outcome to the rest of the flow.
This is distinct from reusable assistants you might set up for people to talk to. This is autonomy embedded in a process: the automation reaches a point where judgement is needed, the agent does the work, and the flow carries on with the result. It lets you put a measure of intelligence into the middle of a workflow without putting a person there.
Work through large datasets
Some automations are not about a single record but about a great many. Iterating over large data streams — with boundaries so you can control exactly which slice gets processed — keeps big imports and batch jobs manageable rather than overwhelming. The process can chew through volume steadily and predictably instead of trying to swallow everything at once.
More moments to react to
An automation is only as useful as the moments it can respond to. New triggers — such as acting just before a record is deleted — let a flow step in at exactly the right point in a record's life. That makes it possible to capture, validate, or clean up at the precise instant it matters, rather than discovering after the fact that the moment has passed.
Dynamic content everywhere
A process that produces the same generic output for every case feels like a process. One that produces the right, specific output feels like a service. Inline variables let automations weave live data into what they produce — including the emails they send — so a single automation generates personalized, data-driven results rather than one-size-fits-all messages.
A redesigned canvas
All of this would be wasted if the builder itself could not keep up. The builder interface was reworked so that larger, branching automations stay readable as they grow — so the tool encourages building real processes rather than punishing you for it. Complexity is something you can see and manage, not something that turns into a tangle.
Why it matters
Automation now covers the full spectrum in one place. At one end, a simple notification anyone can set up in a minute. At the other, a code- and AI-driven process with branches, batches, and embedded judgement. The same visual builder spans both, which means a process can start simple and grow in place rather than being rebuilt the moment it outgrows its first version.
And because it all lives on the platform, these workflows connect naturally to everything around them — the REST API, custom applications, and the platform's AI features — without external services, extra hosting, or glue code to maintain. The automation builder is no longer just for the easy cases. It is where serious processes get built.