--- title: "Make alternative: FlowRunner vs Make" description: "FlowRunner builds the scenarios Make does and adds AI agents that pause for a person, per-run billing, and waits up to a year. Where each wins and how to choose." url: https://flowrunner.ai/alternatives/make date_published: 2026-07-18 date_modified: 2026-11-03T09:28:56-08:00 --- [Alternatives](https://flowrunner.ai/alternatives) / Make ![Make logo](https://flowrunner.ai/assets/alternatives/make.svg) # Make alternative: FlowRunner vs Make FlowRunner builds the scenarios Make does and adds AI agents that pause for a person, per-run billing, and waits up to a year. Where each wins and how to choose. 2026-07-18 Updated November 3, 2026 11 min ## Use FlowRunner when - A run has to wait for a person longer than Make's 5-minute Sleep allows. - Runs go past Make's 40-minute cap, or wait hours or days. - You want human-in-the-loop on every plan, not an Enterprise closed beta. - You'd rather pay per run than per module run. - You handle health data and need a signed BAA, which Make doesn't offer on any plan. ## Use Make when - A regional or niche app you need is listed in Make's directory and not yet in FlowRunner's. - Your reliability model is Make's per-module error directives and the Incomplete Executions queue. - Your scenarios finish in minutes and never wait on a person. ![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 signed BAA on a published plan, 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 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 Free, Starter, and 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 on published plans.** Audit trails and RBAC start at the Professional tier ($299/month). SSO/SAML, 90-day audit trails, and a signed BAA for HIPAA work arrive at Business ($999/month). - **An 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, built against each vendor’s official API reference. 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. - **Per-module 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 forum and a broad template gallery. 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 30 days on Free, Starter, and Growth and up to a year on Professional and up, 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 on every plan, including Free, 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 human gets the context the agent assembled. - **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 on published plans.** 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 audit trails and RBAC from Professional ($299/month) and signs a BAA on Business ($999/month) and up. For a regulated builder, the compliant configuration is a plan with a published price instead of an Enterprise negotiation or a platform that is ruled out. - **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 Make wins on these points, and if they 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 first-party count (roughly 2,534 by our own app-by-app 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 26 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 time in market.** Make has run in production for years, first as Integromat. For a buyer who weights time in market heavily, that matters, though Make’s design was set before agentic, human-in-the-loop work existed, which is the shape FlowRunner was built for. ![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, or a 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) | Paid plans, from $12/mo Core | | 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 on Free, Starter, and Growth; up to 1 year on Professional and up | 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 (in final QA, shipping soon) | 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 (Business and up) | 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 a signed BAA, which Make does not offer, or audit trails and RBAC without an Enterprise contract. - 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 mixed, run a real workflow on both before committing. ## Ready to move? You don’t rebuild your scenarios by hand. [The Make migration guide](https://flowrunner.ai/alternatives/make/migrate) shows how FlowRunner Prompt to Flow converts one scenario at a time from its exported blueprint, and what’s left for you to connect, schedule, and test. For a bigger migration, [contact us](https://flowrunner.ai/contact). ## 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 Agents start on the paid plans. 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 signs a BAA on its Business plan ($999/month) and up, and ships audit trails and RBAC from 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, audit trails and RBAC from $299, and a signed BAA from the Business plan. ### Does FlowRunner have as many integrations as Make? No, not on raw directory count. Make advertises 3,000+ apps (roughly 3,543 live listings). Our own 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 against each vendor's official API reference, 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 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. FlowRunner Prompt to Flow, connected to the AI tool you already use, reads a scenario's exported blueprint and builds the same flow in your workspace, one scenario at a time. [The step-by-step guide](https://flowrunner.ai/alternatives/make/migrate) covers each part. ### 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). ## Keep reading - [How to move from Make to FlowRunner](https://flowrunner.ai/alternatives/make/migrate) - [FlowRunner vs Zapier](https://flowrunner.ai/alternatives/zapier) - [FlowRunner vs n8n](https://flowrunner.ai/alternatives/n8n) - [FlowRunner vs Activepieces](https://flowrunner.ai/alternatives/activepieces) [All alternatives](https://flowrunner.ai/alternatives) 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/alternatives/make. Site index: https://flowrunner.ai/llms.txt