Make (formerly Integromat) is the power-user's workflow tool. The visual scenario editor handles routes, iterators, aggregators, error handlers, and array operations natively. Where Zapier requires workarounds, Make has a node. The result is a product that long-time integration builders love and many SMB buyers find intimidating. The 2020 Celonis acquisition rebranded Integromat to Make in 2022 and added enterprise sales motion (Celonis press release, 2020).

Make is genuinely good at what it does. It is also, fundamentally, a workflow tool. The AI capabilities added through 2024-2025 do not change that. This piece is the honest comparison and the migration framework.

What Make is in 2026 (post-Integromat, post-Celonis)

Make's product surface is the scenario canvas. A scenario is a connected graph of modules, where each module is a step (HTTP request, database operation, API call, transformation). The canvas supports routers for branching, iterators for arrays, aggregators for merging, and an error handling layer that lets you define per-module retry and fallback paths.

The data-in-flight visibility

Make's strongest differentiator is that you can inspect the JSON output of any module mid-run. The debugging surface is excellent. Power users build complex scenarios because they trust the visibility.

The Make AI additions

Make AI (released 2024) is an assistant that drafts scenarios from natural language description. AI Agents (beta) embed an agent node inside the scenario, with tool calling and LLM reasoning. The framing has moved toward agents; the architecture has not. The agent is a smarter node in the same graph.

The Make scenario at scale

A real story from a friend's marketing agency. They built a Make scenario to onboard new clients: pull data from Typeform, create a Notion page, create a Slack channel, invite team members, post a welcome card, generate a custom onboarding doc with GPT, send a welcome email, set up tracking in HubSpot, schedule the first follow-up. Twelve modules. Three branches. One aggregator. Reasonable complexity for the work.

Year one: the scenario worked. Year two: it had grown to 47 modules, six branches, two iterators, three error handlers. Every new client requirement was another module. Every new SaaS in the stack was another integration. The scenario was technically working but only the one person who built it could safely edit it.

By year three the scenario had crossed 200 modules and become a single point of failure for the whole client onboarding process. When the original builder went on a two-week leave, three onboarding incidents happened. The scenario was working as designed; the design was the problem.

This is the workflow tax at the power-user end of the market. Make is cheaper than Zapier per operation and faster to build complex flows, but the maintenance burden scales with complexity, and complex scenarios are exactly what Make is best at.

What Gravity does differently

Gravity gives up the canvas and the per-module visibility in exchange for outcome-level definition and adaptive recovery. The same onboarding flow described above looks like a single outcome description ("when a new client signs up, run our full onboarding sequence"). The agent figures out the steps, calls the right tools, recovers from transient errors, escalates when human input is needed, and continues. For the deeper version see describe outcome, not workflow and AI agent vs workflow automation.

The trade-off is real. Power users will miss the canvas at first. The argument for switching is that the maintenance tax of the 200-module scenario is invisible at year one and dominant by year three.

Capability comparison

DimensionMakeGravity
AuthoringVisual scenario canvasPlain-language outcome
Power featuresRoutes, iterators, aggregators, error handlersAdaptive planning, agent recovery
DebuggingJSON visibility at every moduleDecision logs and audit trail
Pricing modelPer-operationPer-outcome (planned)
Integrations1500+ appsTop SaaS native + MCP long tail
Best buyerPower-user ops, agenciesFounder / ops lead / non-engineer
Maintenance burdenScales with complexityAbsorbed by the platform

Pricing reality

Make's pricing is published. As of May 2026 the tiers are a free plan with 1,000 operations per month, Core at $9 per month, Pro at $16 per month, Teams at $29 per month, and Enterprise on custom pricing (Make pricing, retrieved 2026). The per-operation model is the cheapest in the workflow category at high volume; 10,000 operations on Make is meaningfully cheaper than the same on Zapier.

Gravity is in pre-launch waitlist as of May 2026. Public pricing has not been announced. The instinct is per-outcome, on the principle that outcomes are what the buyer cares about. See AI agent cost models.

Where Make is still the right tool

Three categories.

Deterministic ETL pipelines

Pull data from A, transform, push to B. The steps are stable, the variance is low. Make's per-operation pricing wins on cost at any reasonable volume. Adding an agent here is over-engineering.

Power-user agencies

Agencies that build automation for clients often have a Make specialist on staff. The visual canvas is part of how they sell. The maintenance tax is somebody else's bill.

Cross-tool data orchestration

Sync HubSpot to Notion to Airtable to a spreadsheet. Pure data-shape work, well-suited to Make's strengths. Per-module debugging is genuinely useful here.

Where Gravity wins

Three opposite categories.

Adaptive recurring ops

Tasks where the path changes based on context, exceptions are routine, and the same scenario can not capture the variance. Lead follow-up with context-sensitive messaging. Invoice chasing that adapts to client stage. Ticket triage that learns from past resolutions. See AI agent orchestration.

Non-power-user buyer

The founder, the ops lead, the small team without a Make specialist. The visual canvas is friction, not feature. The outcome prompt is the right shape. See three startups, three shutdowns.

Long-time-horizon maintainability

If you intend for this automation to run for years across organisational change, the maintenance burden of a complex scenario is the hidden cost. An agent platform amortises that. See why I bet against workflow platforms.

Migration considerations

Two practical paths.

Keep Make for the deterministic half

If your Make portfolio has stable ETL scenarios, leave them alone. The migration cost is real and the benefit is small.

Move the high-maintenance scenarios

The 100+ module client-onboarding scenario, the lead-routing scenario with five branches, the inbox-triage scenario with twenty filters. These are the cases where the agent platform earns its keep within weeks. The migration is from "we drew the scenario" to "we describe the outcome", which is a smaller rewrite than it sounds. See AI agent failure modes.

Frequently asked questions

What is Make and how is it different from Zapier?

Make (formerly Integromat) is a visual workflow automation platform acquired by Celonis in 2020 and rebranded to Make in 2022. The visual scenario builder is more powerful than Zapier's: routes, iterators, error handlers, aggregators, and array operations sit on the canvas. The trade-off is steeper learning curve in exchange for substantially more control at high volume.

Does Make have AI agents?

Make has added AI capabilities through 2024 and 2025 including Make AI (an assistant that drafts scenarios from a description) and AI Agents in beta inside the scenario canvas. The agents are inside the scenario graph as nodes, similar to n8n's AI Agent and Zapier's AI step. The unit of work is still the scenario, with an agent node embedded.

Why do power users still pick Make over Zapier?

Three reasons. First, the per-operation pricing model is meaningfully cheaper at high volume. Second, the scenario canvas supports complex branching, iteration, and error handling natively, where Zapier requires workarounds. Third, the data structure visibility (Make shows you JSON at every step) is excellent for debugging.

When is Make the right tool versus Gravity?

When you need deterministic integrations at high volume, when your scenario is well-defined and stable, when you want to see every step of the pipeline on a canvas, and when your buyer is a power user who enjoys the scenario editor. Make is excellent for deterministic ETL-style workflows and data pipelines.

When does the scenario model fail?

The same way every workflow model fails: when reality has more variance than the scenario captured. A 200-node Make scenario is a thing of beauty until the SaaS API returns a slightly different shape and the scenario silently drops half the rows. The maintenance tax compounds with complexity. An agent recovers within the bounded outcome instead of failing inside one node.

Three takeaways before you close this tab

Sources