Make Review 2026: AI Agents Are Live, Does the Rating Change?

Yes, the rating moves. We had Make at 4.2 in May, and the single con holding it there was that the model couldn't pick its own next tool. As of June 2026 it can. Make AI Agents are generally available on every paid plan, and since June 4 those agents can call external MCP tools and native Make modules in the same reasoning loop, with the model deciding which to fire (Make community, June 4 2026). That is the exact capability we said n8n owned and Make faked with router scaffolding. New rating: 4.4 out of 5.

Here is the one thing to leave with. If you are a non-developer ops lead who picked Make for the canvas but kept an eye on n8n for "real" agents, that reason to look elsewhere is mostly gone. The agent loop you wanted now ships inside the tool you already know. The reasons to still choose n8n are narrower and they are about hosting and cost, not capability.

We rebuilt our internal Pondero stack from Zapier onto Make earlier this year, eight production scenarios over six weeks. Recurring cost went from 69.95 USD a month on Zapier Professional to 18.82 USD a month on Make Pro plus a 2.82 USD top-up in the first full month. That migration is the cost evidence below. The agent and pricing changes on top of it are what this refresh is about.

What changed since our last review

The May review predates all of this. Each item is dated and sourced.

• AI Agents went GA on all paid plans (help doc updated January 19 2026). You build reusable agents that run across multiple scenarios, set a global system prompt, override it per scenario, and pick the model, including OpenAI-compatible LLMs (help.make.com). Centralized management means one agent definition instead of the same prompt pasted into ten scenarios.
• MCP tools for AI Agents shipped (community spotlight, June 4 2026). An agent can connect to external MCP servers, read the tool list each one exposes, and "call MCP tools and Make modules in the same reasoning loop, based on the instructions you give them" (Make community). This is the tool-selection loop, not a hard-coded router.
• A next-gen visual agent builder is in closed beta. Agents become "first-class citizens inside the visual Scenario Builder" with step-by-step logs and tool calls today, a reasoning panel "coming soon," and dynamic routing that lets the AI "decide the right way to tackle a task" (Make blog). Waitlist spots are described as very limited. Treat it as a preview, not a feature you can plan around.
• Pricing moved to a credit model (current per Make's pricing page, pulled June 25 2026). Free is 1,000 credits a month, Core is 9 USD for 10k credits, Pro is 16 USD for 10k (Make's recommended tier), Teams is 29 USD for 10k, Enterprise is custom. Annual billing saves 15 percent or more.
• Make Code App runs real code. Custom JavaScript or Python inside a scenario, billed at 2 credits per second of execution time (Make pricing page, June 25 2026). The old "no native code step" con is now a qualified one.

A note on the pricing unit, because it matters for the math later. The old "operations" language is gone from the pricing page. Make now counts credits, where "each module action in your scenario, like adding a Google Sheet row or fetching Gmail account data, counts as one credit" (Make pricing page, June 25 2026). For a standard module run, one action is one credit, so the everyday math reads the same as before. Code execution and some AI calls meter differently, so a heavy agent run is no longer a clean one-credit-per-step estimate.

Updated scorecard

Five axes, each scored 1 to 5, then the overall call.

Axis	Score	The reason
Ease of use	4.5	The canvas still makes branch logic visible; agents now live inside that same builder
AI capability	4.5	Autonomous tool selection across MCP servers and native modules, in one reasoning loop
MCP and integration depth	4.5	3,000-plus app modules plus external MCP servers as agent tools, plus the HTTP catch-all
Pricing	4.0	Low base, but credit math surprises on high fan-out and there is no zero-cost self-host path
Support	4.0	Tiered support, strong docs and community, but key features still carry beta labels

Overall: 4.4 / 5. The straight average lands near 4.3. We weight the agent-capability jump a notch higher because it removes the one structural ceiling that capped the last review, and we hold back from 4.5 because the next-gen builder is closed beta and self-hosting still doesn't exist. A confident 4.4 reflects both facts honestly.

Make vs n8n vs Zapier, on the agent dimension only

This is not a full three-way review. The question that changed is narrow: which platform lets the model run its own tool loop, and at what cost to you. Pricing is dated and cited in the next section.

Agent capability	Make	n8n	Zapier
Autonomous tool-selection loop	AI Agents, GA all paid plans	AI Agent node, mature multi-backend	No true agent loop
External MCP tools	Yes, in the agent builder (June 2026)	Yes, MCP client node ([email protected])	Limited
Real code in a step	Make Code App (JS/Python)	Code node (JS/Python), core feature	No
Where the agent runs	Make cloud, credit metered	Your server, no per-run meter	Zapier cloud, task metered
Visual agent builder	Closed beta, logs today	Canvas node, code-leaning	N/A
Setup tax to get there	Low, it's in the UI you know	Docker deployment you own	Lowest, but capped capability

The honest read: n8n's AI Agent node is still the more battle-tested implementation, and its self-hosted model means agent runs don't bill per credit. n8n's June 2026 releases are mostly maintenance, [email protected] security and bug fixes per the n8n release notes, so it isn't pulling away on features right now. Make's advantage is that the agent loop now sits inside a visual builder a non-developer can drive without writing a node in JavaScript. Zapier has no real agent loop to compare; it stays the on-ramp tool, not the agent tool.

Setup: a Make AI Agent with an MCP tool

Here is the shape of configuring an agent, following the structure in Make's AI Agents and MCP docs. Open the AI Agent builder, define the agent, attach a model, and add an MCP server as a tool provider.

# Make AI Agent definition (per help.make.com AI Agents docs + June 2026 MCP spotlight)
agent:
  name: "lead-research-agent"
  model: gpt-4o            # any OpenAI-compatible model, or your own LLM key
  system_prompt: |
    You are a sales research assistant. When a demo request arrives,
    research the company, enrich the contact, and write a structured
    summary. Use the CRM tools to read and write records. Ask for
    nothing the tools can already answer.
  tools:
    - type: make_module          # native Make module exposed as a callable tool
      module: hubspot.create_contact
    - type: mcp_server           # external MCP server, added in the agent builder
      url: "https://<YOUR_MCP_SERVER_HOST>/mcp"
      auth: bearer

The behavior that matters: the agent reads the tool list each MCP server exposes and decides when to call those tools during a run, mixing them with native modules in the same loop (Make community, June 4 2026). You write the instructions; the model picks the path. That is the part router scaffolding could never do.

When a native module doesn't exist, the HTTP module is still the universal escape hatch. A minimal POST body inside an HTTP module looks like this:

{
  "method": "POST",
  "url": "https://api.example.com/v1/enrich",
  "headers": [
    { "name": "Authorization", "value": "Bearer <YOUR_API_KEY>" },
    { "name": "Content-Type", "value": "application/json" }
  ],
  "body": {
    "domain": "{{1.company_domain}}",
    "fields": ["industry", "headcount", "tech_stack"]
  }
}

And the trigger end, a webhook that kicks the scenario off, is a one-field setup: add a Custom Webhook module, copy the generated URL, and point your source system at it.

# Test the webhook trigger that starts the scenario
curl -X POST "https://hook.make.com/<YOUR_WEBHOOK_ID>" \
  -H "Content-Type: application/json" \
  -d '{"company_domain":"acme.com","contact_email":"[email protected]"}'

Expected behavior: the scenario fires once, the agent researches the domain through its MCP and HTTP tools, and a structured contact lands in HubSpot. Execution history shows the payload at every step, which is what made debugging fast in our own migration.

What we built, and where the credit math bit

Our six-week migration covered eighteen scenarios, including a Gmail-to-HubSpot enrichment flow, a Typeform-to-Zendesk ticket router, and lead scoring with multi-branch routing. The linear scenarios took under thirty minutes each. The branchy one took two days, almost all of it on an aggregator-scope bug: a missing aggregator ran the notification block once per scored lead instead of once per batch, quietly multiplying the run count.

That bug is the credit-model warning in miniature. Every module action is a credit, so an iterator over a 500-row array is 500 credits per downstream module, not one. Fan-out is where the bill surprises people. Budget against your real scenario shape, not the list price, and pair every iterator with its aggregator before you trust a "working" scenario.

Pricing, dated, with the break-even math

Current tiers per Make's pricing page, pulled June 25 2026:

Plan	Price	Credits/mo	Notes
Free	0 USD	1,000	No-code builder, 3,000+ apps, 15-min minimum interval
Core	9 USD/mo	10,000	Unlimited scenarios, minute-level scheduling, API access
Pro	16 USD/mo	10,000	Make's recommended tier; priority execution, custom variables
Teams	29 USD/mo	10,000	Team roles, shared scenario templates
Enterprise	Custom	Custom	Advanced security, overage protection, 24/7 support

Annual billing saves 15 percent or more (per Make's pricing page, June 25 2026). The comparison most readers want is against Zapier and self-hosted n8n. Zapier Professional was 69.99 USD a month for 2,000 tasks at our last check; Make Pro is 16 USD for 10,000 credits. Both meter per step, so the lever is base price and included volume, and Make wins by roughly 4x on that math. Our migration is the proof rather than a model: the identical eight-scenario workload billed 69.95 USD on Zapier and ran at 18.82 USD plus a 2.82 USD top-up on Make Pro, same triggers and destinations.

Against n8n, the calculation changes because n8n self-hosted has no per-run meter at all. Here is the break-even, worked at a moderate volume.

# Break-even: Make Pro vs self-hosted n8n (illustrative volumes)
# Make Pro:    16 USD/mo for 10k credits, ~9 USD per extra 10k
# n8n self-host: server cost only, no per-execution charge

Scenario: 50k module actions/month
  Make Pro:        16 USD base + 4 x 9 USD overage  = 52 USD/mo
  n8n self-host:   ~6 to 20 USD/mo small VPS         = ~6 to 20 USD/mo
                                                      (plus your ops time)

Break-even tilts to n8n once volume clears ~30 to 40k actions/mo
AND you can run and patch a Docker box. Below that, or if you can't,
Make's managed credit model is cheaper in total cost of ownership.

The number that doesn't show up in that block is your time. n8n is cheaper in dollars at volume and never on the day a backup fails or an upgrade breaks a workflow. If nobody on the team wants that pager, Make's managed model is the rational buy even where the raw dollar math favors n8n.

The verdict, by who you are

Make earns a 4.4 in June 2026 because the agent loop finally lives inside the visual builder, and that was the one thing keeping it a tier below n8n on capability. The candid cons are real and worth restating: the polished next-gen agent builder is closed beta, there is still no self-hosting, and credit math can surprise you on high-fan-out work. None of those flip the recommendation for the buyer Make is built for.

The picks, by situation:

• Non-developer ops lead. Make is the pick, full stop. You get autonomous agents with MCP tools in a canvas you can actually read, without learning Docker or writing a node. This is the buyer the 4.4 is for.
• High volume on a tight budget, with technical chops. n8n, once your monthly module actions clear roughly 30 to 40k and someone can run the box. Self-hosting deletes the per-credit meter that Make charges, and the n8n review covers the license clause that decides resale cases.
• Team that needs autonomous agents and wants them in the UI today. Make. The agent loop with MCP tools is GA on all paid plans now, where Make's competitors either gate it behind code (n8n) or don't offer a real one (Zapier).
• First-time automation team. Still Zapier for the first few months. The linear step model is the shortest path to a working automation; graduate to Make's canvas once the logic branches.

If you land in the first or third bucket, you can start free and validate a real agent on 1,000 credits before paying. When you're ready to run it for real, Make's paid plans start at 9 USD a month. For the full head-to-head with worked migration math, see Zapier vs Make.

FAQ

Did Make's rating go up? Yes, from 4.2 to 4.4. The reason is AI Agents going GA on all paid plans plus MCP tool support, which closes the autonomous-tool-loop gap that capped the last score.

Can Make run real AI agents now? Yes. AI Agents are GA on every paid plan, and as of June 2026 they call external MCP tools and native Make modules in the same reasoning loop, with the model choosing the tool (Make community, June 4 2026).

What is the current Make pricing? Free is 1,000 credits a month. Core is 9 USD, Pro 16 USD (recommended), Teams 29 USD, each for 10,000 credits a month, with Enterprise custom. Annual saves 15 percent or more (Make pricing page, June 25 2026).

Is Make better than n8n for agents? For a non-developer, yes, because the agent loop lives in a visual builder. For a technical team at high volume, n8n's self-hosted model removes the per-credit meter and its AI Agent node is more mature.

Does Make support a code step now? Yes. Make Code App runs custom JavaScript or Python in a scenario, billed at 2 credits per second of execution (Make pricing page, June 25 2026).