Low code workflow automation tools, sorted by what actually writes the workflow file

Most guides rank low code workflow automation tools by integration count. The more useful question is structural: when you pick a tool, who or what writes the workflow definition? That single axis cleaves the market into three categories. This page names them, lists what is in each, and shows the actual data shape the third category produces when the recorder, not the user, is the author.

M
Matthew Diakonov
11 min read

Direct answer (verified 2026-05-01)

Low code workflow automation tools come in three categories defined by what writes the workflow:

  1. SaaS orchestrators (Zapier, Make, Workato, n8n, Tray, Pipedream): a person drags nodes on a canvas; each node is a vendor connector.
  2. RPA studios (UiPath, Power Automate Desktop, Automation Anywhere, Blue Prism): a person records a session in an IDE and edits a sequence with selectors and branches.
  3. Observation-based AI agents (Mediar, Sola, Skyvern, CloudCruise): the recorder writes the workflow file from a single screen capture, no canvas at all.

Authoritative source for the third category's spec: github.com/mediar-ai/terminator, file crates/executor/src/models/workflow.rs lines 41 to 80.

The three categories, in one frame

Pick the category first, then the vendor. The categories are defined by which side of the workflow needs the most help: the API plumbing, the desktop click path, or the up-front design work.

1. SaaS orchestrators

Zapier, Make, Workato, n8n, Tray, Pipedream. Move JSON from one cloud API to another. The 'low code' interface is a node-and-connector canvas where each node is a vendor connector the platform has built. Stops at the API boundary; if the destination is a Windows app like SAP GUI or a banking core, the pattern is to fire a webhook and let something else finish the work.

2. RPA studios

UiPath Studio, Power Automate Desktop, Automation Anywhere AARI, Blue Prism. Reach desktop apps that have no API. The 'low code' interface is a recorder plus a visual sequence editor with selectors, conditionals, and exception branches. Strong on legacy desktops, but the studio is heavy and the selectors break when UIs change.

3. Observation-based AI agents

Mediar. Watch the user do the work once, then emit a small structured workflow that any agent can replay through OS accessibility APIs. There is no canvas to drag, no selector to author, and no node graph to debug. The 'low code' surface is whatever the recorder writes plus a 13-field YAML you can edit.

Category 1: SaaS orchestrators

The category most people picture when they hear "low code workflow automation." Zapier popularized it; Make, Workato, n8n, Tray, and Pipedream each take a slightly different shape on the same idea. The user assembles a graph of nodes in a browser canvas. Each node is either a connector to a third-party SaaS API (Salesforce, HubSpot, Notion, Slack, Stripe) or a first-party utility (a code node, a formatter, a webhook listener, a router). The platform handles auth, retries, polling, dedupe, and rate limiting; the user supplies the wiring.

What this category is good at: gluing SaaS to SaaS in minutes, with a connector library a single team could not build in a year. What it is not built for: workflows that touch a Windows desktop app with no API, or workflows whose value is in the last-mile data entry into SAP, an EHR, or a banking core. The standard exit hatch is a webhook step that hands off to a desktop runtime; the platform provides the orchestrator role, the desktop runtime provides the worker.

Category 1

SaaS orchestrators worth shortlisting

Zapier

10K plus prebuilt connectors, task-based pricing.

Make

Visual scenario editor, ops-based pricing.

n8n

Self-hostable, fair-code license, code nodes.

Workato

Enterprise iPaaS with recipes and a community library.

Tray

Builder geared at solutions teams and revops.

Pipedream

Workflow per HTTP source, JavaScript-friendly.

Category 2: RPA studios

Built for the inverse case: workflows whose value sits inside desktop applications that have no public API. UiPath Studio, Microsoft Power Automate Desktop, Automation Anywhere AARI, and Blue Prism each ship a developer-grade IDE where a user records a session, edits the resulting sequence, attaches conditional branches and exception handlers, and publishes the artifact to an Orchestrator (UiPath) or equivalent for scheduling and monitoring. The workflow file is a real engineering artifact (xaml in UiPath, ppr in Power Automate) under version control, reviewed in pull requests, owned by a Center of Excellence.

The strength is breadth: an RPA studio can drive almost any desktop application a Windows host can launch, including mainframe terminals, SAP GUI, Jack Henry, Fiserv, FIS, Epic, Cerner, and homegrown VB6 forms. The cost is shape: the studio is heavy, the projects look like software projects (12 to 16 weeks for a first deploy is not unusual), and the workflow breaks when target apps change because the user authored selectors that bind to specific UI elements.

Category 2

RPA studios worth shortlisting

UiPath

Studio plus Orchestrator. xaml workflow files.

Power Automate Desktop

Microsoft's desktop RPA, bundled with Windows 11 Pro.

Automation Anywhere

AARI cloud-native bots and IQ Bot.

Blue Prism

Object Studio plus Process Studio, attended and unattended.

WorkFusion

RPA plus pre-built ML for financial services.

NICE Automation

Attended desktop automation for contact centers.

Category 3: observation-based AI agents

A recent category. The user does not author the workflow; the recorder does. The user demonstrates the work once on a Windows machine, the recorder captures meaningful events through OS accessibility APIs, an LLM synthesis pass turns the event stream into a small structured spec with named steps and typed inputs, and the result is a YAML or TypeScript file the executor replays. Mediar is the desktop-native variant of this pattern; Sola, Skyvern, and CloudCruise are browser-native variants that live inside SaaS web flows.

The shape of "low code" here is different from the first two categories. There is no node graph. There is no properties panel attached to a recorded action. The artifact is a small spec the user can read and edit, and a UI that lets them rename steps, change retry counts, or tweak error strategy without touching code. On simple flows the user never opens the spec; on complex flows the spec stays small enough to read in one sitting.

Category 3

Observation-based AI agents to evaluate

Mediar

Watch once, replay through accessibility APIs. SAP, Oracle, Jack Henry, Epic.

Sola

Browser-first AI agent for SaaS web flows.

Skyvern

Open-source browser automation with LLM planning.

CloudCruise

Browser automation aimed at admin SaaS portals.

The anchor: what the third-category workflow actually looks like

When a guide describes "no canvas" or "watch once and replay," it is fair to ask what the data shape is. Mediar's answer is small enough to fit in this article. The full spec for a workflow lives in one Rust struct in the open Terminator runtime, plus one struct for a step. Thirteen fields and nine fields. That is the surface a user, a recorder, or an LLM can produce.

crates/executor/src/models/workflow.rs

A complete workflow that posts a vendor invoice to SAP, with a retry on the Post button and a weekday morning cron, takes fewer than 20 lines of YAML. The recorder writes this file on your behalf the first time you demonstrate the flow. You can edit it later, but on most workflows you do not.

workflow.yaml (written by the recorder)

Field-by-field reference

The complete WorkflowSequence spec, one row per field. If a tool does not produce something this small, it is not in the third category.

FieldPurpose
stepsOrdered list of WorkflowStep entries the executor walks one by one.
inputsTyped arguments the workflow expects at run time. Fills the {{ inputs.x }} interpolations in step arguments.
variablesWorkflow-scope key/value pairs the recorder seeds and steps can read or update.
selectorsReusable element references (role plus name plus tree path) so a step can say {{ selectors.vendor_field }} instead of inlining a literal selector.
stop_on_errorBoolean. If true, the executor halts the run on the first step that errors past its retry budget. If false, it continues and surfaces failures in the run report.
include_detailed_resultsBoolean. Toggles per-step structured output captured into the run record (helpful for debugging, expensive on long runs).
cronStandard 5-field cron string. Empty means the workflow runs only when fired manually or by webhook.
start_from_stepOptional step id. Skip everything before this on a rerun. Used after a debug pass to resume mid-flow without rebuilding state.
end_at_stepOptional step id. Stop after this step. Pairs with start_from_step to bracket a section for a targeted retry.
follow_fallbackBoolean. Whether to walk into ErrorStrategy::Fallback branches when a step fails. Off by default, lets you do a 'dry rerun' that does not chase recovery paths.
execute_jumps_at_endBoolean. Whether to honor jump targets at the tail of a partial execution. Lets the partial run terminate cleanly even when the spec normally branches.
scripts_base_pathOptional Windows path. Where external scripts referenced by run_command steps live for this run (lets a workflow ship its own helper bash/python files).

Plus nine fields on each WorkflowStep: id, tool_name, group_name, arguments, description, retry_count, timeout, on_error, fallback_id. The on_error enum is one of Stop, Continue, Retry, Fallback.

When each category wins

The honest answer is that the categories are complements more often than substitutes. A finance team running invoice intake on Salesforce plus SAP B1 will end up with a Zapier or Make flow on the Salesforce side and either an RPA studio or an AI agent on the SAP side. The choice between the third-category AI agent and a second-category studio is the live decision in most enterprise teams right now.

70%

we moved an LG-customer F&B chain from UiPath to Mediar; their CFO told the board they're now saving 70% on costs

from a Mediar deployment, 2026

$750K/yr

claims intake at one mid-market carrier went from 30 minutes per claim to 2 minutes. that's $750K/year, not a press-release number, that's their AP-team headcount math

from a Mediar deployment, 2026

Use category one when the work is SaaS-to-SaaS and the connectors already exist. Use category two when you have a mature Center of Excellence, an existing license footprint, and a tolerance for a 12-week first deploy. Use category three when you want a working pilot in two weeks, you do not want a per-bot license model, and you can tolerate a smaller artifact you read rather than a graph you click through.

browser-based AI agents are great for new SaaS, but if your data lives in SAP GUI or a Jack Henry green-screen they will not help. that's the whole reason the accessibility-API approach exists
M
Mediar
from a customer call, 2026

The honest limits of category three today

Three things go wrong, in roughly this order. First, modal dialogs in legacy desktop apps that only appear on the first run of the day; the recorder did not see them, the executor stalls until a human intervenes, and the spec needs a one-time edit to dismiss them. Second, identity: the executor runs as a real Windows user and the user has to be logged in to the target apps; an unattended bot needs a dedicated unattended identity with a screensaver policy that does not lock the session. Third, deep branching: a workflow with eight conditionals and two recovery paths is more readable as a UiPath flow than as a YAML, and we will tell you to drop into a TypeScript workflow file or split the flow before forcing it into YAML.

Where category three pulls ahead is the long tail of small variable workflows that are not worth a 12-week studio build. That is most of the work an enterprise back office actually does. The numbers we have seen on real pilots: 2 weeks to first deploy on a mid-market bank onboarding flow, an 8 weeks to 2 weeks compression on a Jack Henry account-open workflow, and a 70 percent cost reduction at the F&B chain quoted above. We are not going to tell you those numbers transfer one-for-one, but the shape of the savings is real and traceable to the third-category model: no per-bot license, no studio time, and self-healing on selector drift.

See category three on your own workflow in 25 minutes

Show us the desktop flow that has been stuck in your queue. We will demonstrate Mediar against it on a shared screen and tell you honestly whether the third category is the right fit, or whether a SaaS orchestrator or an RPA studio is the better answer.

Frequently asked questions

What does 'low code' mean in workflow automation, exactly?

It means the workflow definition is something a non-developer can read, write, and modify without writing a programming language. In SaaS orchestrators that surface is a node graph in a browser canvas. In RPA studios it is a sequence of recorded actions plus a properties panel. In observation-based AI agents like Mediar it is a small YAML or JSON spec the recorder writes, plus a UI that lets a person tweak step names, arguments, and error strategy in plain fields. The line between 'low code' and 'no code' is fuzzy in practice; 'low code' usually implies you can drop into a code node when you need to, while 'no code' implies you cannot. All three categories on this page allow both modes.

Where do SaaS orchestrators stop working?

At the API boundary. Zapier, Make, Workato, and n8n connect cloud services that publish a REST or RPC API. SAP GUI is a Windows desktop client that talks to its server over the SAP RFC protocol; there is no public REST API for SAP GUI. Jack Henry, FIS, and Fiserv core banking systems are Windows desktop terminals that talk to a private host. Epic and Cerner expose FHIR for some patient data but not for the in-clinic desktop screens a medical assistant fills out. When one end of a workflow is a desktop app, the orchestrator-only categories cannot reach it; the standard pattern is to fire a webhook from the orchestrator into a desktop runtime that does the desktop work.

Where do RPA studios stop scaling?

Two places. Maintenance and time to production. UiPath, Power Automate Desktop, and Automation Anywhere ship a developer studio where a user authors selectors and conditional branches by hand; the studio is a real IDE and the workflow files (xaml in UiPath, ppr in Power Automate) become real artifacts the team has to version, review, and patch. When a target app's UI changes (a relabeled button, a moved tab, a new modal), the selector breaks and a human edits the workflow. Documented industry numbers suggest the maintenance tax on a mature RPA estate runs 30 to 50 percent of total RPA cost. Time to production is the second drag: a typical UiPath project takes 12 to 16 weeks from kickoff to first deploy, mostly spent in studio.

What is different about observation-based AI agents?

The author is the observer, not the human. The user demonstrates the workflow once on a Windows machine, the recorder captures meaningful events through OS accessibility APIs (clicks, typed text, hotkeys, application switches), an LLM synthesis pass turns the event stream into a structured workflow with named steps and inputs, and the result is a small YAML spec the executor can replay. The 'low code' surface is no longer a builder canvas; it is the YAML and a small UI for editing step descriptions, retry counts, and error strategy. The user only touches the spec when they want to override what the recorder picked, which on simple flows is never.

What does the Mediar workflow spec actually look like?

Thirteen top-level fields on WorkflowSequence and nine fields on WorkflowStep, defined in crates/executor/src/models/workflow.rs lines 41 to 80 of the open-source Terminator runtime at github.com/mediar-ai/terminator. The full top-level set is steps, variables, selectors, inputs, stop_on_error, include_detailed_results, cron, start_from_step, end_at_step, follow_fallback, execute_jumps_at_end, scripts_base_path. Each step has id, tool_name, group_name, arguments, description, retry_count, timeout, on_error, fallback_id. The on_error enum has four values: Stop, Continue, Retry, Fallback. There is no graph, no canvas, no separate 'orchestration layer' file. One file is the workflow.

Why so few fields? Where do conditionals and loops live?

Conditionals and loops are step-level, not spec-level. A condition becomes a group with an early-exit step that checks state and returns; a loop is implemented by a step whose tool is execute_sequence with a different sequence. The spec stays small because branching is expressed in the step graph rather than in the wrapper. The trade-off is honest: deeply nested branching is harder to read in this shape than in a visual UiPath flow, and we recommend either a code workflow (TypeScript, same SDK) or a multi-file split for genuinely complex flows. Most automations a back-office team needs end up small enough that the YAML stays readable.

Which tools fit which workflows?

Match the tool to where the data lives. If both ends are SaaS apps with public APIs, a SaaS orchestrator (Zapier, Make, n8n) is the cheapest path. If one end is a SaaS app and the other is a Windows desktop with no API, the right composition is a SaaS orchestrator on the SaaS side and an RPA studio or AI agent on the desktop side. If both ends are Windows desktops with no APIs (a banking core to a CRM, a healthcare EHR to a billing system, an SAP GUI to an internal Access database), the SaaS orchestrator drops out and you are choosing between an RPA studio and an AI agent for the entire flow. The AI agent is faster to ship and self-heals on UI changes; the RPA studio gives you a heavier IDE and a longer audit trail by default.

Is Mediar an alternative or a complement to UiPath?

Either. Some pilots replace a stalled UiPath project end to end (an LG-customer F&B chain moved off UiPath onto Mediar and reported 70 percent cost savings to their board). Others run Mediar inside an existing UiPath estate as the agent that handles the workflows where the UiPath selector kept breaking. Mediar's executor exposes webhook and cron triggers, so an existing Orchestrator schedule can call into it. The interesting question for a team with a Center of Excellence is usually not 'which platform' but 'which workflows belong on which platform,' and observation-based agents tend to win the long-tail of small variable workflows that are not worth a 12-week studio build.

Is the runtime open source?

Yes. The desktop agent's executor crate, the queue processor, the workflow parser, the MCP transport, and the WorkflowSequence model this page describes all live under github.com/mediar-ai/terminator. The hosted dashboard at app.mediar.ai/web (the no-code recorder, the workflow library, the run history, the auth and billing) is the proprietary surface. A team that wants to run the executor on its own infrastructure and skip the hosted dashboard can do that, and the workflow file format stays the same.

What does pricing look like across the three categories?

SaaS orchestrators charge per task or per operation. Zapier's tiers run a few cents per task at low volume; Workato is closer to enterprise iPaaS pricing on annual contracts. RPA studios charge per bot license and per developer seat; UiPath public pricing has historically run in the low five figures per attended bot per year and higher for unattended, with separate Studio and Orchestrator costs on top. Mediar charges $0.75 per minute of executor runtime with no per-seat license, and a $10,000 turn-key program fee that converts to credits and effectively prepays usage. A 30-second SAP post costs about 38 cents in Mediar regardless of how many users kicked off the workflow.