Make is the visual-automation middle ground done well — a flowchart canvas deeper than linear builders, three thousand plus app integrations, and routers and filters that handle real branching. Its AI agents layer puts models on that canvas too.
The run model is classic automation: an activated scenario executes on its schedule or trigger, and once an execution is in flight it's essentially out of reach — Make's own community confirms you can't terminate an active run from outside the editor, and even Stop waits for the current module to finish every bundle. LiveGraph runs the opposite model: the canvas you're watching is the thing executing, and it stays editable.
| Dimension | Make | LiveGraph |
|---|---|---|
| What a run executes | The activated scenario, on its schedule or trigger — a run is fire-and-forget once it starts. | The live graph, re-read on every hop — what you see is what's executing. |
| Stopping a run | Active runs can't be terminated from outside the editor; Stop lets the current module finish all its bundles first. | A cancel reaches the executing hop. |
| Mid-run rerouting | Not supported — a wrong route means a failed or incomplete execution. | Drag an edge; the next hop follows the new route. |
| Recovering a failed run | Incomplete executions can be fixed and resumed where they stopped — genuinely good. | Steer before it fails — reroute, interrupt, or gate the hop while the run is still live. |
| Integrations | 3,000+ apps — among the deepest catalogs in automation. | MCP servers, scoped http_request endpoints, and file tools — narrower, but every connection is one you configured and can see. |
| Human approval gates | Not evaluated | Run-level gates that park at the approvals queue, plus per-tool-call gates (e.g. a single http_request endpoint) — the pending payload is always visible to the approver. |
| Run history | Per-run history with module outputs, plus a change log of scenario edits. | Every hop lands as an ordered run event — input, output, the routing explanation, and its cost — and approval decisions are stamped with who and when. |
| Pricing | Credit-metered — roughly one credit per module operation, with AI modules billed dynamically on token usage. | Flat team price — runs are never metered. Model usage on hosted keys is metered on top; your own keys are never marked up. |
Competitor rows are limited to claims verified in our own research — "Not evaluated" means we didn't check, not that the capability is missing. On the LiveGraph side, one nuance: runs started from chat or the canvas Run button are steerable; unattended runs (API, schedules, webhooks) run pinned to the graph they started on — steering is a watched-run feature, by design.
Make's bet is that a run is something you schedule and check on later — and for most of its workloads that's correct. The moment the payload is an agent making a routing decision you'd want to catch, “fix it in incomplete executions” becomes the whole workflow. LiveGraph is for the runs you're watching, where catching it is the feature.
The live demo runs a real multi-agent graph in your browser — no signup, no API key — including the mid-run edge drag. If the canvas earns it, an account takes a minute.