Make Review: Visual Automation, AI Agents, MCP and Governance

Make's July 2026 releases strengthen its position as an orchestration and governance platform rather than only a workflow builder. Make Grid can now incorporate selected external automation and agent systems, including n8n, Claude-managed agents, and Relevance AI.

The Grid maps scenarios, agents, applications, prompts, dependencies, and data flows in one visual landscape. New content search can inspect configurations for module names, field identifiers, URLs, notes, AI prompts, and other dependencies, making it easier to find where a system, credential, or instruction is used.

This matters because AI automation is increasingly distributed. A business may have Make scenarios, n8n workflows, Claude agents, MCP tools, direct model integrations, and manually maintained scripts performing related work. Without a map, a change to one API, prompt, credential, or data source can break processes elsewhere.

Make also introduced private spaces for scenarios and connections that individual organization members do not want visible to other members. The combination of personal spaces and organization-wide Grid visibility creates an important governance tension: teams need enough privacy for safe building while still identifying production dependencies, data risk, duplicated automation, and unmanaged agent access.

WhatAI Decision Box

Make has evolved from the visual automation platform formerly called Integromat into an AI orchestration system. It now combines scenarios, Make AI Agents, Maia, Make Grid, MCP Server and Client, Toolboxes, Make Code, API access, CLI tooling, more than 3000 apps, and enterprise governance.

Make exposes the full workflow as a visual graph. Builders can inspect every application, data mapping, branch, transformation, error handler, agent tool, and execution. The same scenario can run deterministically, act as a tool for an AI assistant through MCP, or support a Make AI Agent that reasons before selecting approved tools.

No-code does not eliminate operational complexity. High-volume bundles and AI modules can consume credits quickly, large scenarios are difficult to maintain, and broad credentials or MCP tools can create serious security risk. Teams should modularize workflows, validate inputs, use least privilege, test failures, monitor costs, and keep humans in control of consequential actions.

Use Cases

Pricing varies by plan and region — see current pricing.

Plan features change — last updated: 2026-07-22.

Make Community Discussions

Explore community discussions. Ask and answer questions on Make to grow and learn together.

Make Pros & Cons

How to Get Results with Make: Step-by-Step Workflow

1. Define the business outcome

   Describe the trigger, required result, systems involved, owner, frequency, expected volume, risk, and evidence that the automation succeeded.

   Decision point: Use a deterministic scenario for known rules. Add an AI Agent only when the workflow genuinely requires interpretation or adaptive tool choice.

2. Map the process before building

   List the source systems, data fields, decisions, approvals, exceptions, credentials, downstream effects, and manual fallback.

3. Estimate credit consumption

   Calculate expected runs, bundles, module actions, polling checks, AI tokens, code time, retries, and error paths.

   Decision point: Redesign the workflow when the expected cost per successful outcome is too high or unpredictable.

4. Build the smallest working scenario

   Connect the trigger and one verified outcome first. Name modules and routes clearly and add notes explaining assumptions.

5. Validate and normalize data

   Check required fields, types, dates, identifiers, duplicates, permissions, and schema changes before sending data downstream.

6. Add branches and reusable components

   Use filters, routers, nested if-else, merge, iterators, aggregators, functions, and subscenarios only after the base path works.

   Decision point: Split the workflow when one canvas becomes difficult to understand or independently test.

7. Design failure behavior

   Add error handlers, retries, timeouts, rollback or compensation, alerts, dead-letter storage, and an operator recovery process.

8. Constrain AI and MCP access

   Give agents the minimum tools, credentials, parameters, data, and write permissions required. Use MCP Toolboxes for scoped exposure.

   Decision point: Require human approval before financial, legal, identity, deletion, publishing, or customer-account actions.

9. Test realistic edge cases

   Run duplicates, missing fields, unexpected formats, expired credentials, API limits, unavailable models, prompt injection, and partial failures.

10. Deploy gradually

    Activate with limited volume, known users, monitored credentials, and a rollback path before scaling.

11. Monitor operations and business results

    Track executions, credits, errors, queues, latency, external API failures, agent tool calls, manual interventions, and the intended business outcome.

12. Document and govern the system

    Record the owner, purpose, credentials, dependencies, prompts, models, expected cost, recovery steps, review date, and retirement plan.

Make Gotchas and Limits to Know Before You Start

• Make replaced operations with credits as the billing unit in August 2025
• Most normal module actions use one credit but built-in AI and code features can use variable credit formulas
• A router itself does not consume credits but modules executed after the router do
• Iterating or processing many bundles can multiply credit use rapidly
• Polling scenarios consume credits when modules check or process data
• The Free plan includes one thousand monthly credits and two active scenarios
• Free scheduled scenarios have a fifteen-minute minimum interval
• Paid plans begin at the ten-thousand-credit level but higher volumes change the total price
• Extra credits cost more than credits included in the base plan
• Scenarios can stop when credits run out unless overage arrangements apply
• Make AI Agents remain beta and their configuration or pricing can change
• Maia is not generally available and has plan-based message limits
• Maia cannot run activate or deactivate scenarios for the user
• AI-generated scenarios may contain incorrect mappings conditions or API calls
• MCP Server is included in all plans but scenario execution still consumes credits
• MCP Toolboxes reduce access risk but read-write tools remain consequential
• Make MCP Client can introduce external tool availability security and schema dependencies
• Make Code consumes credits according to execution time
• Connections and tokens can expose broad third-party permissions
• Enterprise security controls still require correct configuration and ongoing ownership
• Large visual scenarios can become unmaintainable without subscenarios naming notes and documentation
• External app API changes and deprecated modules can break scenarios
• Make Grid visibility does not automatically prove that every external dependency is safe or correctly classified
• Private spaces can reduce accidental access but may also hide unmanaged dependencies from colleagues

Which Make Feature Fits Your Use Case

How Well Make Fits Common Use Cases

Starter Prompts for Make

Design a Make scenario that watches for a closed-won Salesforce deal, validates the required customer fields, creates an onboarding project in Asana, creates the customer in the billing system, sends an approved welcome email, and alerts the account owner. Include duplicate protection, idempotency, retries, error storage, human approval for billing, structured scenario outputs, and estimated credits per successful onboarding.

Design a Make AI Agent for internal support triage. It may search the approved knowledge base, summarize tickets, classify urgency, and draft responses. It must not send messages, modify accounts, issue refunds, or expose private customer data without explicit human approval. Define tools, permissions, inputs, outputs, guardrails, test cases, logging, escalation, and credit controls.

Plan an MCP Toolbox for a sales assistant used from Claude and ChatGPT. Expose only three outcome-oriented tools: prepare an account brief, create approved follow-up tasks, and draft a CRM update. Specify read-only versus write permissions, fixed parameters, required user inputs, validation, unique tokens, audit logs, failure outputs, and confirmation before any write action.

Review this Make scenario for credit waste. Calculate expected credits from polling frequency, bundle volume, iterators, downstream modules, retries, AI tokens, and code execution. Recommend batching, filtering earlier, bulk endpoints, caching, schedule changes, subscenarios, or deterministic replacements without changing the required outcome.

Create a failure-handling design for this production scenario. Classify temporary, permanent, authentication, rate-limit, malformed-data, duplicate, and downstream-partial failures. Define retry limits, backoff, rollback or compensation, dead-letter storage, alerts, replay, ownership, and the evidence required before a failed item is closed.

Prompt pattern: When [trigger] occurs in [source], validate [required data], then perform [actions] across [systems]. Use [conditions and approvals]. Handle [failure cases]. Return [structured output]. Limit [permissions credits and retries]. Log [audit evidence and business result].

Iteration tip: After Make or Maia creates the first scenario, test one normal case, one duplicate, one missing field, one expired credential, one downstream outage, and one high-volume batch before activation.

Make is one of the strongest automation platforms for users who want more control than a simple trigger-and-action tool but do not want to build and host every integration themselves. The visual scenario builder makes branching, data mapping, bundles, errors, transformations, and execution history inspectable, which is valuable once workflows become operationally important.

The platform's current direction is agentic orchestration. Make AI Agents can choose among approved tools, while deterministic scenarios continue to enforce business rules. MCP Server exposes scenarios to assistants such as ChatGPT, Claude, and Cursor. MCP Client lets Make use tools hosted elsewhere. Toolboxes narrow access to selected scenarios with scoped tokens and monitoring. Maia lowers the building barrier by creating and fixing scenarios from natural language, although it remains a non-GA feature that requires testing before activation.

Pricing remains accessible at the entry level. Free includes one thousand monthly credits. Core begins at nine dollars for ten thousand credits, Pro at sixteen dollars, and Teams at twenty-nine dollars. The important cost is not the headline plan but the number of module actions, bundles, AI tokens, code execution time, retries, and polling runs required by the real workflow.

Choose Make over Zapier when visual control, complex branching, transformation, and cost optimization matter. Compare n8n when self-hosting, source access, and developer control are priorities. Compare Microsoft Power Automate when the organization is deeply standardized on Microsoft and enterprise licensing. Make is strongest when cloud applications, AI tools, APIs, and human processes need to be orchestrated visibly in one managed platform.

Evaluate Make with a real production process. Include several applications, one branch, one failure, one retry, one human approval, and one AI step. Measure credits per successful outcome, error recovery, maintainability, permission scope, auditability, and the time required for another team member to understand the scenario.

What is Make best used for in 2026?

Make is best used for visual cross-application automation, complex data routing, AI-agent orchestration, API integration, MCP tools, and governed business workflows.

Is Make the same product as Integromat?

Yes. Integromat was renamed Make. Existing users still commonly search for both names, so the WhatAI record keeps Integromat as an alias while using the current Make brand.

How much does Make cost?

Make has a Free plan with one thousand monthly credits. At the ten-thousand-credit level, Core is nine dollars per month, Pro is sixteen dollars, Teams is twenty-nine dollars, and Enterprise uses custom pricing.

What are Make credits?

Credits are Make's billing unit. Most ordinary module actions use one credit, while some built-in AI features and code execution use variable credit calculations. A complex scenario can consume many credits in one run.

What are Make AI Agents?

Make AI Agents are reusable agents that reason about a task and choose among approved tools, scenarios, apps, and MCP resources. They remain beta features and need testing, monitoring, and constrained permissions.

What is Maia by Make?

Maia is an AI co-worker inside the Scenario Builder. It can create, modify, explain, and troubleshoot scenarios from natural-language instructions. Maia is not yet generally available and cannot activate scenarios for the user.

What is Make MCP Server?

Make MCP Server turns selected scenarios into structured tools that ChatGPT, Claude, Cursor, and compatible assistants can call. It is included across Make plans, and the executed scenarios consume normal Make credits.

What is the difference between Make MCP Server and MCP Client?

MCP Server exposes Make scenarios and account tools to external AI clients. MCP Client lets Make scenarios or AI Agents call tools hosted by external MCP servers.

What is Make Grid?

Make Grid creates an interactive map of automations, AI agents, applications, prompts, connections, and dependencies. It can also incorporate selected third-party automation and agent platforms for broader governance.

Is Make suitable for production automation?

Yes, provided scenarios use controlled credentials, validation, error handling, monitoring, documentation, testing, and human approval for high-impact actions. Enterprise plans add stronger security and governance.

Related Automation & Process Tools

Explore the Network