---
title: "FlowRunner vs Make"
description: "FlowRunner vs Make: FlowRunner does everything Make does and adds native AI-agent orchestration with human oversight. Where FlowRunner wins, where Make still helps, how to choose."
url: https://flowrunner.ai/compare/flowrunner-vs-make
date_published: 2026-07-18
date_modified: 2026-09-15T10:10:03-07:00
---

# FlowRunner vs Make

FlowRunner vs Make: FlowRunner does everything Make does and adds native AI-agent orchestration with human oversight. Where FlowRunner wins, where Make still helps, how to choose.

2026-07-18 Updated September 15, 2026 12 min

![Shared foundation, different ceilings: Make's linear scenario beside FlowRunner, which runs that same workflow and adds the agentic layer above it, agent-invoked human review, long waits, and runtime tool choice.](https://flowrunner.ai/images/compare/make-shared-foundation.webp)

**TL;DR**

-   Start with what these two share: the cloud, connector-based scenarios Make is known for, connecting apps, chaining modules from a trigger through a set of actions. FlowRunner builds all of that. FlowRunner is [Orchestration as a Service](https://flowrunner.ai/concepts/orchestration-as-a-service), so it also runs the layer above: coordinating AI agents, governing multi-agent work, and keeping a human in control of the decisions that need judgment. Read them side by side and the shape is plain: Make does the linear scenario; FlowRunner does that and the agentic orchestration on top.
-   This page is about AI-agent automation with human oversight. For that specific work the fit is not 50/50: FlowRunner is built for it, and Make is being stretched to reach it. We will still show you exactly where Make is the better call, because sometimes it is.
-   FlowRunner is stronger where this reader lives: human-in-the-loop as a native agent tool on every tier, run-based billing that does not multiply with steps, waits up to a year, HIPAA with a BAA at mid-tier prices, and agent-tool metadata on the whole catalog.
-   Make is stronger on raw connector count, per-module error handling, and community depth.

## Who this comparison is for

You are building AI-agent automation where the agent has to do more than fire a linear scenario and finish. It needs to stop and pull in a person when the rules do not cleanly apply. It may run for a while. It may touch data an auditor will ask about later. You might be coming from Make or starting fresh; either way you are deciding which platform is built for that work.

The overlap is large: the linear, cloud scenario building Make is known for, FlowRunner does too. What FlowRunner adds on top is the agentic layer, agents that pause for a human, long-running orchestration, and built-in compliance. Where that added layer matters, FlowRunner is not merely also an option; it is the platform built for it. This page is about exactly where Make’s ceiling is and where FlowRunner keeps going: the agent that hits an [automation exception](https://flowrunner.ai/concepts/automation-exceptions) it should not decide alone and has to hold the run open until a human answers.

## What FlowRunner is good at

FlowRunner is built around one commitment: agents that know when to stop and ask a human for help. Everything else in the platform exists to make that commitment reliable at production scale.

The mechanism is the part that linear tools do not have. In FlowRunner, an AI agent invokes one of your own Flows as a callable tool. When the agent calls that flow-tool, it suspends while the flow runs, and the flow can hold on an external callback until a human replies through email, Slack, WhatsApp, phone, or a Form, then resume mid-run. This is [human-in-the-loop](https://flowrunner.ai/concepts/human-in-the-loop) as an execution pattern: the agent pauses on its own judgment, assembles the context and the choices available, routes to a human on their preferred channel, and resumes the moment they answer. Some teams call it a [digital andon cord](https://flowrunner.ai/concepts/digital-andon-cord), after the Toyota factory pull cord any worker can pull to stop the line when something needs a human eye.

![Human review built into the run versus a workaround assembled around it. Make's Enterprise-only closed-beta approach stores state externally and reprocesses through another scenario, while FlowRunner's agent calls a human-review flow, suspends, and the human answers in-channel (email, Slack, WhatsApp, phone, or Form) before the same run resumes.](https://flowrunner.ai/images/compare/make-human-in-the-loop-architecture.webp)

FlowRunner is strong on:

-   **Human-in-the-loop as an agent tool, native on every tier.** The agent decides at runtime to pull in a person, calls a human-review flow as a tool, and suspends until they reply in their own channel: email, Slack, WhatsApp, phone, or a Form. It can loop over a batch, ask a follow-up question, and escalate if no one answers. This is native on every plan, including Free, not gated behind an Enterprise plan.
-   **Run-based billing.** One complete workflow run, start to finish, is one execution. A 10-step run is one execution, not ten, and there is no per-step or per-operation multiplier. That removes the step-multiplication math that per-operation billing forces on builders.
-   **Long waits and long runtimes.** A run can suspend for up to 30 days on Growth and up to a year on Professional, Business, and Enterprise. Cumulative runtime runs to 1 hour on Growth, 4 hours on Professional, 12 hours on Business, and unlimited on Enterprise.
-   **Compliance at mid-tier prices.** Audit trails and RBAC start at the Professional tier ($299/month). HIPAA support with a BAA is available. SSO/SAML and 90-day audit retention arrive at Business ($999/month).
-   **A verified, agent-ready catalog with depth.** 2,100+ integrations and 56,000+ callable actions, each carrying the structured metadata an LLM needs to call it as a tool, all built and verified against each vendor’s official API. The catalog includes full-CRUD databases, vector stores, and deep ERPs, plus 75 integrations with no first-party Make equivalent, including X, Redis, Oracle, DynamoDB, and the major vector stores.
-   **[BYOK](https://flowrunner.ai/concepts/byok) with no markup.** BYOK is a model where the customer supplies their own AI provider API credentials, pays providers directly for usage, and FlowRunner orchestrates calls across providers without taking a markup on inference. For a buyer who already has an Anthropic, Google, or Azure agreement, that means your own rates, your own data-processing terms, and a provider your security team already approved, rather than a new bundled inference vendor to review.

That pause-for-a-human moment is the load-bearing part of FlowRunner’s architecture. It is why agentic work that needs human judgment is native here rather than assembled from workarounds.

## What Make is good at

Make (formerly Integromat) is a cloud scenario builder with a large connector directory. Make advertises 3,000+ integration apps, with roughly 3,543 listings live today.

Make is strong on:

-   **Connector directory size.** The 3,000+ figure is real as a directory count. If you need to touch a long tail of services, Make probably lists something for it.
-   **AI features on the low paid tiers.** Make’s Core plan starts at $12/month (as of July 2026), and AI features reach down to the low paid tiers, with an effective AI entry point around $9 to $12/month on annual billing. Make does not hold its AI back for higher plans. FlowRunner includes AI agents on its Free plan and $5 Starter, so the entry price itself is not a Make advantage, but Make’s low tiers are a real place to build.
-   **Mature error directives.** Make gives each module explicit error handling: Ignore, Resume, Commit, Rollback, and Break, plus an Incomplete Executions retry queue that parks a failed run for later reprocessing.
-   **Community and templates.** A large community, an active forum, and a broad template gallery mean most problems have a documented answer.
-   **Track record.** Make has been in market for years under two names and has handled a lot of production traffic. It is a known quantity.

Make is built for linear, cloud-based scenario work.

## Where FlowRunner is stronger

For the agentic, human-oversight work this page is about, these are the differences that decide the platform:

-   **Wait and runtime ceilings.** This is the single largest architectural gap. A Make scenario run is capped at 40 minutes on paid plans and 10 minutes on the free plan, and the Sleep module tops out at 300 seconds, which is 5 minutes. If a human does not answer within 5 minutes, a native Make wait cannot hold the run, and you fall back to webhooks and reprocessing scenarios. FlowRunner suspends a run for up to a year and runs for up to 12 hours or unlimited. For any workflow that waits on a person, this difference decides the platform.
-   **Human-in-the-loop native on every tier, as an agent tool.** Make’s Human in the Loop app is available on the Enterprise plan only and is currently in closed beta, available only to invited customers. FlowRunner’s human-in-the-loop is native starting at Growth ($45/month), and it is architecturally different: the agent invokes a Flow as a callable tool and suspends until a human replies, rather than routing through a linear approval step. The pause condition is decided at runtime based on what the agent sees, and the context delivered to the human is assembled, not pasted.
-   **Run-based billing.** Make bills per credit (formerly operations), where one module run over a batch of items burns many credits. A 3-module scenario over 10 items is roughly 31 operations. FlowRunner bills per execution, where the whole run is one unit. At volume, the difference between per-step and per-run billing is large and, more importantly, predictable. You are not re-budgeting every time you add a step to an agent.
-   **Compliance at mid-tier prices.** As of July 2026, Make does not sign a BAA on any plan, and its SSO, audit, and RBAC controls live on the Enterprise plan. FlowRunner ships HIPAA support with a BAA, plus audit trails and RBAC, starting at Professional ($299/month). For a regulated builder, this moves the compliant configuration down from Enterprise pricing to mid-tier.
-   **Agent-tool metadata on the whole catalog.** Every one of FlowRunner’s 56,000+ actions carries typed parameters, descriptions, and sample output, so an agent can call it as a tool directly. Make and other workflow-first tools treat apps as steps first; FlowRunner treats every action as a tool an agent can reach for. FlowRunner also has 75 integrations with no first-party Make equivalent, including X, Redis, Oracle, DynamoDB, and the major vector stores.
-   **BYOK with no markup on inference.** You supply your own AI provider keys and pay providers directly. FlowRunner does not resell inference. Your orchestration fee stays separate from your model spend.

![Wait and runtime ceilings from five minutes to one year. Make's native wait tops out at the 5-minute Sleep module and a 40-minute paid run cap; FlowRunner suspends up to a year and runs up to 12 hours or unlimited by tier.](https://flowrunner.ai/images/compare/make-wait-runtime-ceilings.webp)

## Where Make is stronger

This is the section most comparison pages skip. Make wins on several dimensions that matter, and if these are your priorities, Make is the right call.

-   **Raw connector directory.** Make advertises 3,000+ apps against FlowRunner’s 2,100+ integrations, and even after discounting the community-built, internal, discontinued, and long-tail regional connectors, Make’s verified first-party count (roughly 2,534 by an independent audit) is far larger. But the few hundred mainstream apps that most teams actually build on are the ones FlowRunner already covers, in depth (roughly 18 callable actions each). Where Make still wins outright is the long tail: if a specific regional or niche service is your single deciding factor, Make probably lists it and FlowRunner may not.
-   **Per-module error directives.** Make’s Ignore, Resume, Commit, Rollback, and Break directives, plus the Incomplete Executions retry queue, are more granular out of the box than FlowRunner’s Handle Error block and Repeat plus Wait pattern, which cover the common retry and rollback cases with less per-module wiring.
-   **Community size and templates.** Make’s community, forum, and template gallery are larger than FlowRunner’s today, a real head start for self-service problem-solving. FlowRunner’s answer is a growing catalog of install-and-configure packages, but Make’s ecosystem is larger right now.
-   **Longer track record.** Make has been in production for years under two names, and for a buyer who weights operational maturity heavily, that road matters. The tradeoff is that Make’s design center was set before agentic, human-in-the-loop work existed, which is the shape FlowRunner was built for.

If any of those outweigh the differences above, Make is the right call, and choosing it is defensible.

![One scenario, two meters: Make's credits (formerly operations) multiply per module over each item, roughly 31 credits for a 3-module run over 10 items, while FlowRunner counts one execution per whole run. Your data branches; your bill should not.](https://flowrunner.ai/images/compare/make-billing-credits-vs-executions.webp)

## Starting free: FlowRunner Free against Make Free

Both platforms have a permanent free plan, so the comparison is on what the free number buys. FlowRunner Free includes 100 executions a month, where one execution is one whole scenario run regardless of how many modules it touches. Make Free includes 1,000 credits a month, where a credit is one module run over one bundle of data, so a three-module scenario over ten items uses roughly 31 credits in a single run. Make’s free plan also caps you at two scenarios, a 10-minute run, and a 15-minute scheduling interval.

FlowRunner Free includes every integration, AI agents on your own provider keys, human-in-the-loop across email, Slack, WhatsApp, phone, and Form, unlimited users, unlimited workflows, one concurrent run, and 24 hours of log history. Make’s AI Agents arrive on the paid tiers, and its Human in the Loop app is Enterprise-only, in closed beta.

Past free, the first paid rungs are $5 a month on FlowRunner (Starter, 300 executions; $15 for 3,000) and $12 a month on Make (Core, as of July 2026). Every new FlowRunner account starts with 14 days of Professional, the tier with audit trails and RBAC.

## Feature comparison

| Dimension | FlowRunner | Make |
| --- | --- | --- |
| Primary buyer | Builder plus operations team | Builder, cloud scenario author |
| Billing unit | Execution (one whole run) | Credit / operation (per module run) |
| Cost of a 10-step run x 1,000/mo | 1,000 executions | Many thousands of credits |
| Entry price | Free $0 (100 executions); Starter $5/mo (300) or $15 (3,000); Growth $45/mo (12,000) | Free $0 (1,000 credits); $12/mo Core (as of Jul 2026) |
| AI entry point | Free plan (BYOK, no markup) | ~$9 to $12/mo (annual) |
| Unlimited users | Yes | Yes |
| Max single-run time | 1h Growth, 4h Pro, 12h Business, unlimited Enterprise | 40 min paid / 10 min free |
| Max native wait | 30 days Growth, up to 1 year other tiers | Sleep module 300s (5 min) |
| Human-in-the-loop | Native on every tier, agent-invoked callable tool | Enterprise-only, closed beta |
| HITL channels | Email, Slack, WhatsApp, phone, Form | Webhook / Slack workarounds; beta app |
| AI agents | Native ([Agent Factory](https://flowrunner.ai/concepts/agent-factory)) | Yes (paid plans) |
| MCP | Consumes external MCP servers; exposes catalog as MCP server (shipping ~Aug 2026) | Native server and client |
| Integration directory | 2,100+ integrations, 56,000+ actions | 3,000+ listed apps (~3,543 live) |
| Agent-tool metadata on actions | On every action | Not the model |
| Error handling | Handle Error block + Repeat/Wait retry | Per-module directives + retry queue |
| HIPAA / BAA | HIPAA with BAA | No BAA on any plan (as of Jul 2026) |
| Audit trails / RBAC | Professional ($299) | Enterprise |
| SSO/SAML | Business ($999) | Enterprise |
| SOC 2 | Security program designed to meet common audit requirements | Type II |
| Self-hosting | Enterprise on-prem; Community Edition coming | No (cloud-only) |
| BYOK for AI | Yes, no markup on inference | Model-provider connectors |

## Decision framework

![A compliance decision gate for PHI workflows: if a signed BAA is required, Make is unavailable and FlowRunner is supported. HIPAA and BAA, audit trails, RBAC, and SSO compared, with FlowRunner reaching audit and RBAC at Professional versus Make's Enterprise tier.](https://flowrunner.ai/images/compare/make-compliance-gate.webp)

**Pick FlowRunner if:**

-   Your agents need to stop and pull in a human mid-run, and the human might take hours or days to answer.
-   You are building AI agents where human-in-the-loop is the point, and you do not want it gated to an Enterprise closed beta.
-   Predictable run-based billing matters more than a low sticker price, because your workflows run many times a month at many steps each.
-   You handle regulated data and need HIPAA with a BAA, audit trails, and RBAC without paying Enterprise prices for them.
-   You want every action in the catalog to be callable by an agent as a tool, with the metadata to make that reliable.

**Pick Make if:**

-   Your scenarios are short, run in the cloud, and finish in well under 40 minutes with no mid-run human wait longer than 5 minutes.
-   Raw connector directory breadth is your single most important criterion and you need a listing for a long tail of services today.
-   You want the granular per-module error directives (Ignore, Resume, Commit, Rollback, Break) and the Incomplete Executions retry queue as your reliability model.
-   You do not handle protected health information and do not need a signed BAA.

If the answer is honestly mixed, run a real workflow on both before committing. The right platform is the one that fits the shape of your work, not the one with the larger directory.

## Migration considerations

![Migration map from a Make scenario to a FlowRunner flow: triggers, actions, filters, and routers carry over; Make's error directives and Incomplete Executions map to Handle Error and Repeat plus Wait, and a native Human Review Flow is added. The logic carries over; the execution model changes.](https://flowrunner.ai/images/compare/make-migration-map.webp)

For builders already on Make and weighing a switch, the practical questions:

-   **What maps mechanically?** Triggers, actions, and basic scenario structure map directly. A Make module usually has a FlowRunner action equivalent, and Make’s router and filter logic maps to FlowRunner’s Condition and Value Router blocks.
-   **What gets re-expressed?** Make’s per-module error directives (Ignore, Resume, Commit, Rollback, Break) become FlowRunner’s Handle Error block and the Repeat plus Wait retry pattern. The Incomplete Executions retry queue maps to that same retry pattern. The logic carries over; the shape changes.
-   **What gets better in the process?** Any scenario that fought the 40-minute run cap or the 5-minute Sleep ceiling stops being a workaround. Long waits and long runtimes become native, so the “split it into two scenarios that hand off” pattern disappears.
-   **Who runs the migration?** The Midnight Flow consulting team runs migrations as part of FlowRunner Enterprise onboarding. Other tiers self-migrate with the platform’s import tools.
-   **How long does it take?** A typical mid-market deployment with 20 to 50 scenarios migrates over 4 to 8 weeks with consulting support, or longer self-served, depending on how many scenarios relied on Make-specific error directives.

If you would like a free migration consultation, reach out via the [Contact page](https://flowrunner.ai/contact) and we will scope the engagement before any commitment.

## Frequently asked questions

### Is FlowRunner cheaper than Make?

Yes on the sticker, and usually per run as well. Make's Core plan starts at $12/month (as of July 2026) and its AI entry point sits around $9 to $12/month on annual billing. FlowRunner's Free plan is $0 for 100 executions a month with AI agents, every integration, and human-in-the-loop included, and Starter is $5/month for 300 executions or $15 for 3,000. The real comparison is the billing unit. Make bills per credit (formerly operations), where every module run burns a credit and a single module run over a batch of items burns many, so a 10-module scenario costs about ten credits per run and Core's 10,000 credits are roughly 1,000 runs, around $0.012 a run. FlowRunner bills per execution, where one complete run from start to finish is one execution regardless of how many steps it has: Starter at $15 is $0.005 a run, and Growth at $45 for 12,000 executions is under $0.004. Make is cheap to start; FlowRunner is cheaper to start and stays flat as scenarios grow.

### What is Make's execution time limit?

A single Make scenario run is capped at 40 minutes on paid plans and 10 minutes on the free plan, and each individual module is capped at roughly 40 seconds (community-documented via Make's own timeout error). Make's Sleep module allows a maximum delay of 300 seconds, which is 5 minutes. That ceiling is the practical reason Make is a poor fit for long-running or human-in-the-loop work: if a person does not respond within 5 minutes, a native Sleep-based wait cannot hold the run. FlowRunner suspends a run for up to a year and runs for up to 12 hours or unlimited depending on tier.

### Does Make have human in the loop?

Yes, but with two constraints. Make's Human in the Loop app is available on the Enterprise plan only and is currently in closed beta, available only to invited customers (per Make's own app listing). Outside that, teams build approvals with webhooks, Slack messages, and the Incomplete Executions retry queue. FlowRunner's human-in-the-loop is native on every plan, including Free, the AI agent invokes a Flow as a callable tool and suspends until a human replies through email, Slack, WhatsApp, phone, or a Form, and the wait can last up to a year.

### Is Make HIPAA compliant?

As of July 2026, Make does not sign a Business Associate Agreement on any plan, and healthcare teams should treat it as not HIPAA compliant for workflows that touch protected health information (per Make's community support responses and third-party compliance reviews). Make is SOC 2 Type II certified, which covers general security posture but is not the same as a signed BAA. FlowRunner offers HIPAA support with a BAA and ships audit trails and RBAC starting at the Professional tier ($299/month).

### What is a good cheaper alternative to Make for AI agents with human oversight?

If your work is short, cloud-only, and per-operation, Make fits that shape well. If your work is long-running, needs a human to weigh in mid-run, and touches regulated data, Make's ceilings (40-minute run, 5-minute native wait, Enterprise-gated human-in-the-loop and compliance) push the total cost up through the Enterprise tier. FlowRunner is built agent-first for exactly that case: per-execution billing, waits up to a year, human-in-the-loop native on every tier, and HIPAA plus audit plus RBAC at mid-tier prices.

### Does FlowRunner have as many integrations as Make?

No, not on raw directory count. Make advertises 3,000+ apps (roughly 3,543 live listings). A verified app-by-app audit shows a large share of that directory is community-built, internal utilities, discontinued apps, or long-tail regional and vertical connectors. FlowRunner covers 2,100+ integrations and 56,000+ callable actions, built and verified against each vendor's official API, with agent-tool metadata on every action so an LLM can call it directly. FlowRunner also has 75 integrations with no first-party Make equivalent, including X, Redis, Oracle, DynamoDB, and the major vector stores. The honest summary: Make has more listings; FlowRunner has verified, mainstream, agent-ready coverage plus depth Make's directory does not.

### Can I migrate from Make to FlowRunner?

Yes. Triggers, actions, and basic scenario structure map over. Make's per-module error directives (Ignore, Resume, Commit, Rollback, Break) are re-expressed with FlowRunner's Handle Error block and Repeat plus Wait retry pattern. The Midnight Flow consulting team runs the migration as part of Enterprise onboarding, and other tiers can self-migrate. A typical mid-market deployment with 20 to 50 scenarios migrates over 4 to 8 weeks with consulting support.

### Is there a free alternative to Make with AI agents and human-in-the-loop included?

Yes. FlowRunner's Free plan includes AI agents on your own keys and human-in-the-loop on every channel at $0, permanently, on 100 executions a month where one execution is one whole scenario run. Make Free includes 1,000 credits a month, but a credit is one module run over one bundle of data, Make's AI Agents start on the paid tiers, and its Human in the Loop app is Enterprise-only in closed beta. Paid plans start at $5 a month on FlowRunner and $12 a month on Make (as of July 2026).

By [Mark Piller](https://flowrunner.ai/about#mark-piller), Founder of FlowRunner [Editorial policy](https://flowrunner.ai/editorial-policy)

> _I like that aspect of the human in the loop when it's needed. That's ultimately what we need to get to._

VP Operations, CPG brand

---
Markdown version of https://flowrunner.ai/compare/flowrunner-vs-make. Site index: https://flowrunner.ai/llms.txt