Make Review (July 2026): AI Agents Go GA and the Rating Moves to 4.4
Published April 29, 2026 · Updated July 17, 2026 · by Heidi Hildebrandt
The short version
Make (formerly Integromat) after a 6-week production migration off Zapier, updated for July 2026. AI Agents with MCP tools are GA, the no-code-step gap is closed, and the rating moves to 4.4. Current credit pricing and the verdict vs n8n.
Pros
- ✓AI Agents with MCP tools are GA on all paid plans: the model picks its own next tool from MCP servers and native modules in one reasoning loop
- ✓Canvas scenario builder makes branch logic visible instead of buried in a settings panel
- ✓Credit pricing on a low base: our 8-scenario stack went from 69.95 to 18.82 USD per month migrating off Zapier
- ✓Routers, iterators, and aggregators express loops and merges most no-code tools cannot
- ✓Execution history shows the exact payload at every module, which makes debugging fast
Cons
- ✕The Make AI Agents (New) builder is still in beta, so polish is uneven feature to feature
- ✕Make Code charges 2 credits per second of run time, so code-heavy scenarios deplete a 10k-credit plan faster than the flat mental model suggests
- ✕No self-hosting path, so cost scales with volume in a way n8n's self-hosted tier does not
- ✕The canvas mental model costs about a week before it pays back
- ✕Error handling is a separate route you have to design, not a default safety net
Make Review (July 2026): AI Agents Go GA and the Rating Moves to 4.4
By Heidi Hildebrandt, Co-Founder at Pondero Tested March to April 2026. Updated July 2026 for the AI Agents and MCP launch.
Three things changed on this review since May, and one of them moves the score. Make AI Agents went generally available on every paid plan, and since June 3, 2026 those agents call external MCP tools and native Make modules in a single reasoning loop, with the model choosing which to fire (Make AI Agents MCP tools). That is the exact capability the old version of this review said Make lacked. The single con that held the rating at 4.2 is gone. New rating: 4.4 out of 5.
The verdict up front, one line per buyer. A non-developer ops lead who wanted autonomous agents plus visual automation without running a server should pick Make now. A developer or cost-sensitive team that can run Docker should still pick n8n, because self-hosting removes per-credit metering entirely. A first-time buyer should start on Zapier for the shortest path to a working automation, then graduate to Make once the logic branches.
I rebuilt our internal Pondero stack from Zapier onto Make over six weeks in March 2026: eight production scenarios, eleven sub-scenarios, same triggers, same destinations. Recurring cost went from 69.95 USD per month on Zapier Professional to 18.82 USD per month on Make Pro plus a 2.82 USD top-up in the first full month. Every number and failure below comes out of that migration, not a feature page. What follows adds what shipped since: agents, MCP tools, a real code step, and the credit pricing that replaced operations.
What changed since May 2026
The May 1 review predates all of this. Each change is dated and linked.
Make AI Agents plus MCP tools. This is the one that moves the score. An agent connects to external MCP servers, reads the tool list each one exposes, and calls those tools alongside native Make modules in one reasoning loop, deciding the path from your instructions rather than a hard-coded router (Make AI Agents MCP tools). It shipped June 3, 2026 and is generally available on every paid plan. If you already configured an MCP server for Claude Desktop or Cursor, you point the same server at a Make agent with the Add MCP button and reuse it. That is the tool-selection loop the old review said only n8n owned.
Make Skills. Launched May 25, 2026, Make Skills lets an AI assistant run and modify your Make scenarios from a plain-text prompt (Make 2026 release notes). You describe the change you want in words and the assistant edits the scenario, which lowers the canvas learning curve for anyone who would rather type an instruction than drag modules around.
Unified canvas navigation. The scenario builder got a navigation redesign on June 3, 2026 (Make 2026 release notes). For a single linear flow it is cosmetic. For a multi-branch scenario with routers and nested logic, the reworked navigation is the difference between scrolling a sprawling canvas and moving through it cleanly, which is where anyone building branch-heavy work spends the day.
New model options. Claude Opus 4.8 and Gemini 3.5 Flash joined the model list for the AI modules on June 6, 2026 (Make 2026 release notes). If you route classification or drafting through a Make AI module, you can now pick a current frontier model instead of last year's default.
Together these close the two gaps that capped the old score: no agent loop, and no real code step. Make Code now runs JavaScript or Python inside a scenario, and it meters differently, so it lives in the pricing section below.
Who this is actually for
The fit is a marketing or ops team running ten or more multi-step automations where the logic branches but the per-task bill on Zapier has started to sting. Zapier refugees who can think in flowcharts, in other words, plus, as of June 2026, teams that want an autonomous agent driving those flows without hiring someone to run a server.
Two cases still point elsewhere, and they are not close calls. A developer who wants cost to fall to near zero at high volume should run n8n self-hosted, because it carries no per-run meter at all. A first-time automation user is better served by Zapier's linear step model for a few months before the canvas pays back. The case that used to send AI teams straight to n8n, that Make had no agent loop, no longer holds. Make AI Agents pick their own next tool now.
The scenario builder, and what the three primitives actually buy you
Every comparison says Make's canvas is "visual." The load-bearing point is narrower: the canvas makes control flow a spatial property instead of a hidden setting. In Zapier a branch lives inside a Paths panel you click into; in Make a branch is a fork you can see from across the room. That is why debugging is faster, not an aesthetic preference. Three primitives carry the real weight.
A router forks the scenario into independent paths by condition. Each path is its own module sequence and can merge back or not. The mechanism that matters: a router evaluates filters top-down and the first matching route wins unless you set a fallback, so an unhandled input silently exits instead of erroring. That is the single most common reason a new Make scenario "does nothing" and no comparison page tells you.
An iterator explodes an array into one bundle per element so downstream modules run per item. The non-obvious cost is that every per-item module run is a billable credit, so an iterator over a 500-row array is 500 credits per downstream module, not one. This is exactly the same multiplier shape as Zapier tasks; the win is the base rate it sits on, not immunity to it.
An aggregator is the inverse, collapsing many bundles back into one. The detail people miss: an aggregator must be paired with the iterator or router that fanned out, and it ends the bundle scope. Forget the aggregator and the rest of the scenario runs N times instead of once, which is how a "working" scenario quietly 50x's its credit bill. We hit this in week two on the lead-scoring scenario.
These three let you build genuinely complex logic with zero code. They also impose a real mental-model tax. Plan on roughly a week of fumbling before the canvas stops fighting you.
Pricing, and the arithmetic that actually decides it
Make bills one credit per module action. Each module run, like adding a Google Sheets row or fetching a Gmail message, counts as one credit (Make credits billing explainer). A 5-module scenario that runs 500 times a month is 2,500 credits. Same multiplier shape as Zapier tasks, different base. One exception matters for anyone running code: Make Code charges 2 credits per second of execution time, so a code-heavy or AI-heavy scenario burns a plan faster than the one-credit-per-step mental model suggests (Make credits billing explainer).
Current tiers per Make's pricing page, fetched July 17, 2026:
| Plan | Price | Credits/mo | Notes |
|---|---|---|---|
| Free | $0 | 1,000 | No-code builder, scheduled runs at a 15-minute minimum |
| Core | $9/mo | 10,000 | Unlimited scenarios, minute-level scheduling, API access |
| Pro | $16/mo | 10,000 | Full-text execution log search, custom variables, priority execution |
| Teams | $29/mo | 10,000 | Team collaboration, role-based access, template sharing |
| Enterprise | Custom | Custom | Advanced security, overage protection, 24/7 support |
| Source | pricing page | pricing page | Fetched July 17, 2026 |
What 10,000 credits actually buys depends on the shape of your work, not the plan name. A light stack of standard modules, a few hundred scenario runs a month across simple triggers and CRM writes, sits comfortably under 10,000. A high-fan-out stack, where an iterator explodes a 500-row array and each downstream module runs per row, can clear 10,000 in a single daily job. An agent-heavy or code-heavy stack goes through credits quickly, because Make Code meters per second of execution and an agent run can call many tools before it finishes. Match the plan to the busiest scenario you actually run, not the average.
The decision against Zapier is not "Make is cheaper," it is why. Zapier Professional was 69.99 USD per month for 2,000 tasks at our last check; Make Pro is 16 USD per month for 10,000 credits. Both meter per step run, so the lever is base price plus included volume, and on both Make wins by roughly 4x. Our migration is the proof, not a model: the identical eight-scenario workload that billed 69.95 USD on Zapier ran at 18.82 USD plus a 2.82 USD top-up on Make, same trigger volume and same downstream destinations. Against n8n the math flips at high volume, because self-hosted n8n has no per-run meter at all, but you operate the box. Make is cheaper than n8n Cloud and removes that operational burden.
Integrations, and where the depth runs out
Make lists more than 3,000 app modules (Make's pricing page, fetched July 17, 2026), deep on the tools that matter for mid-market work: Google Workspace, Slack, Airtable, Notion, HubSpot, Salesforce, Stripe, Shopify. The HTTP module is the real coverage guarantee, with API key, OAuth, and Basic auth, so the absence of a native module is an inconvenience, not a wall.
The depth runs out at the field level, not the app level, and that is the part to check before committing. We hit it twice in six weeks. A CRM had a native module that did not surface custom fields, so the data we actually needed was invisible to it and we dropped to raw HTTP. A calendar service shipped a module that covered the wrong half of its API. The pattern: a listed integration tells you the app is reachable, not that the specific object and field you need is mapped. Open the module's field list against your real schema before you trust the logo.
AI: an agent that picks its own tools
Make used to ship AI only as plain module calls: hit OpenAI, Claude, or Google AI, parse the response, feed it forward. That still exists and still covers classify, summarize, and draft cleanly. It is also the layer where an LLM does one job and hands off. What changed is the ceiling above it.
Make AI Agents give the model a tool catalog and let it decide which tool to call next based on intermediate results. An agent reads the tool list from any MCP server you attach and mixes those calls with native Make modules in a single reasoning loop (Make AI Agents MCP tools). You write the instructions and the model picks the path, which is the loop the old version of this review said you had to fake with routers and HTTP modules. Reuse is the practical win: one agent definition with a global system prompt, attached across scenarios, instead of the same prompt pasted into ten places.
Two honest limits sit next to that. The next-generation visual agent builder, the one with an inline reasoning panel, is still in beta, so polish is uneven from feature to feature. And an agent run can call many tools, which under the per-second Make Code meter and the per-action credit model burns a plan faster than a linear scenario does. Neither limit is the old ceiling. The model chooses its own tools now, and that is the change that moves the score.
What we built, and what broke
Eighteen scenarios over six weeks: Gmail-to-Clearbit-to-HubSpot enrichment, an Airtable-to-Buffer social pipeline, Typeform-to-Zendesk-to-Slack ticket routing, a Sheets-plus-GA4 monthly report, invoice processing from email attachment to QuickBooks, and lead scoring with multi-branch routing.
The lead-scoring scenario was the hard one and took two full days, almost all of it on the aggregator-scope bug above: a missing aggregator ran the notification block once per scored lead instead of once per batch. The linear automations took under thirty minutes each. That spread is the real lesson. Make's value is concentrated in the middle of the complexity range, where logic is too branchy for Zapier to stay readable but does not yet need code.
Reliability over the six weeks was a non-issue: no outages, consistent execution, and the execution-history panel showing the exact payload at every module is the feature that made the aggregator bug findable in an hour instead of a day. Error handling is the asterisk. A failed module does nothing useful unless you have built a dedicated error route, so a scenario can fail silently if you skipped that. Build error routes in pass two, after the happy path works end to end.
Make vs Zapier, decided
| Factor | Make | Zapier |
|---|---|---|
| Time to first working flow | About a week to fluency | Minutes |
| Branch logic visibility | On the canvas | Inside a Paths panel |
| Cost at volume | Roughly 4x cheaper per dollar | Per-task multiplier on a high base |
| AI ceiling | Autonomous agent loop with MCP tools | LLM calls only |
| Native branching | Router primitive | Paths Plus (paid) |
| Code step | Make Code (JS or Python) | None |
Choose Make over Zapier once you run ten or more multi-step automations, the task math has started generating overage, you want the model to run its own tool loop, or you need to see branch logic to trust it. Choose Zapier when the team is new to automation and needs the shortest path to a first working Zap, or leans on Zapier's larger template and support library. The full head-to-head with worked migration math is in Zapier vs Make: 2026 candid comparison.
The verdict
Make delivers visual automation without code, and as of June 2026 it delivers an autonomous agent loop on top of that canvas, where the model picks its own next tool from MCP servers and native modules. Pricing is still the compounding advantage: a low base under the same per-run meter Zapier uses, which our own migration cut to about a third.
The remaining limits are real and worth naming, because they are what keep this a 4.4 and not a 4.5. The next-generation agent builder is still in beta. There is no self-hosting path, so cost scales with volume the way n8n's self-hosted tier does not. And Make Code meters per second of execution, so code-heavy work depletes a plan faster than the flat mental model suggests. None of those flip the recommendation for the buyer Make is built for.
The picks, by who you are:
- Non-developer ops lead. Make. You get autonomous agents plus visual automation with no server to run, and the agent loop lives in a canvas you can actually read.
- Developer or cost-sensitive team that can run Docker. n8n. Self-hosting removes per-credit metering entirely, and its AI Agent node is the more battle-tested implementation. The n8n review covers the license clause that decides resale cases.
- First-time buyer. Zapier for the shortest path to a working automation, then Make for teams that will outgrow Zapier's per-task bill within a year.
4.4 / 5. The con that held it at 4.2, no agent loop, is resolved. Recommended for non-developers who have outgrown Zapier and now want autonomous agents in a canvas they can read. You can start free and validate a real agent on 1,000 credits before paying.
FAQ
Is Make better than Zapier? For any workflow with real branching or non-trivial volume, yes, on cost and on logic visibility. Zapier wins on time-to-first-Zap and on template and support breadth.
Is Make free? Yes, 1,000 credits per month. Paid plans start at 9 USD per month (Make's pricing page, fetched July 17, 2026).
Can Make handle AI agent workflows? Yes, as of June 2026. Make AI Agents are GA on every paid plan and call external MCP tools and native modules in one reasoning loop, with the model choosing the tool (Make AI Agents MCP tools).
Does Make support a code step now? Yes. Make Code runs custom JavaScript or Python inside a scenario, billed at 2 credits per second of execution (Make credits billing explainer).
What happened to Integromat? Rebranded from Integromat in 2022. Same engine, new name when the company pushed past European markets.
How much cheaper than Zapier, concretely? Our eight-scenario stack: 69.95 USD per month on Zapier Professional, 18.82 USD plus a 2.82 USD top-up on Make Pro, same triggers and destinations. Roughly a third of the cost for multi-step workflows at volume.
Ready to try it?
Try make →