How to Build an AI Agent with Make

Make (formerly Integromat) is a visual workflow automation platform with more than 3,000 app integrations, and it added a dedicated AI Agents capability on top of its existing scenario engine. Instead of following a fixed, linear scenario, a Make agent receives a task, reasons over it with a connected LLM, and decides which of the tools you've attached to call, in what order, to get the job done. You build one by assembling four pieces: a brain (the LLM), instructions (a system prompt that acts like a job description), tools (the modules, scenarios, or MCP connections it's allowed to use), and memory (the context it keeps across steps).

This guide covers why Make fits certain agent-building teams, what its AI Agents module is actually made of, a full build walkthrough, a real customer case study with real numbers, cost and limits, and when to pick Make over the alternatives.

Why Teams Build Agents in Make

Make's core strength predates its AI Agents feature: it connects to more SaaS applications, out of the box, than most competing platforms. That breadth is exactly what makes it a strong foundation for an agent, because an agent is only as useful as the systems it can actually reach.

The integration catalog is the widest in the category. Make lists 3,000-plus app integrations, maintained directly by the Make team for the most common SaaS tools, plus a generic HTTP module for anything without a pre-built connector. For an agent that needs to touch five or six different business systems in one run, that catalog removes most of the plumbing work.

The AI Agents layer sits on top of, not instead of, Make's scenario engine. You can turn an existing scenario into a callable tool for an agent without redefining its inputs and outputs by hand. That means teams that already automated a process in Make don't start over when they add an agent, they wrap what they've already built, close to the shape described in the workflow copilot pattern: AI assisting inside a process that already exists, rather than replacing it outright.

It's built for business teams, not just engineers. Make's visual canvas, module library, and error-handling routes are designed to be configured by an ops or RevOps person, not exclusively by a developer, which is why it's frequently the first agent-building tool a non-technical team reaches for.

Make is now part of Celonis, the process intelligence company, which has been rolling its own workflows through Make's AI Agents feature, evidence the platform is being used for real production automation, not just demos.

What Make's AI Agents Module Is Made Of

The practical shift from a normal Make scenario is control. A scenario runs the same fixed sequence every time. An AI agent decides, at each step, which tool fits the current situation, closer to the reason, act, observe loop covered in how AI agents reason than to a flowchart. When you set up a module as a tool, Make automatically creates the scenario for it behind the scenes, so you don't hand-define inputs and outputs the way you would wiring a raw API.

That flexibility is also why the Role and Rules building blocks matter more here than in a fixed scenario. A rigid workflow can't wander off script because there's no script to wander from. An agent with a vague system prompt can.

The Build Walkthrough

1. Define the agent's job in the instructions. Treat this like the Role and Rules blocks: one sentence for what it owns, a short list of always-on rules for what it must never do.
2. Connect a brain. Use Make's built-in AI provider to start, or connect your own OpenAI, Anthropic, or Google account on a paid plan if you need a specific model or want usage billed directly to your own account.
3. Build the agent's tools. Add existing Make modules as tools directly, or wrap a scenario you've already built so the agent can call it as one unit. Each tool needs a clear, specific description; the agent picks tools based on what you tell it the tool does, not on what it secretly does under the hood.
4. Set up memory. Decide what the agent needs to remember within a single run versus across separate runs, and configure accordingly. Don't give it more persistent memory than the job requires.
5. Add human-in-the-loop checkpoints for anything consequential. Route any output that should be reviewed, an approval, a payment, an external communication, to a human step before it goes live, rather than letting the agent act unsupervised on the riskiest steps.
6. Test with real historical inputs, not invented ones, and watch which tools the agent chooses before you turn on a live trigger.
7. Turn on the trigger and monitor early runs closely, tightening the instructions wherever it picks the wrong tool or misses a case you expected it to catch.

A Real Example: How Celonis Built an Expense-Auditing Agent in Make

Rather than a hypothetical, here's a documented production example. Celonis needed to audit employee expense reports without a human reviewing every single one, so its team built a human-in-the-loop agent in Make:

1. An employee submits an expense report in Workday, which fires a webhook into Make.
2. Make creates a structured item in monday.com so the team has a central view of every report in flight.
3. The agent runs an initial policy check: amounts, dates, spending limits, category rules.
4. Anything that needs deeper judgment gets sent to Google's Vertex AI (Gemini) to read the receipt and evaluate it against company policy.
5. Make runs supplementary checks, like currency validation, then routes the result: reports that pass advance automatically in Workday, and anything flagged moves to a review queue in monday.com with a templated response the team can send back to the employee.

The result, per Celonis's own published numbers: a 99.7% reduction in auditing cost, from tens of thousands of dollars a year down to roughly $150 a year in Vertex AI spend, processing on the order of 1,000 documents per dollar, with near-100% accuracy achieved through careful context engineering and a 60-to-70-day parallel testing period before the team trusted it with full volume. That parallel-run discipline mirrors what how to build an AI agent recommends: test against real historical cases before an agent gets real authority, and the AI Expense Approval Agent blueprint covers the same function's full rules and guardrails if you're building something similar from a template instead of from scratch.

Cost and Limits

Make's own pricing runs on "operations," roughly one operation per module execution in a scenario, priced per plan tier. The AI Agents feature is available on all plans using Make's own AI provider, with custom provider connections (bring your own OpenAI or Anthropic account) available on paid tiers. That second option matters at volume: routing high-frequency agent calls through your own model account, rather than Make's built-in provider, is often the more predictable way to manage spend as usage grows, worth understanding fully before you commit, per AI total cost of ownership.

The main limit isn't the model, it's scenario complexity. An agent with many tools and branching logic can turn a Make canvas into something genuinely hard to audit months later if nobody documents why each branch exists. Build in error-handling routes deliberately, the same discipline any workflow needs, and treat every tool connection as a permission grant: an agent with write access to your CRM and your billing system in the same run has a wider blast radius if its instructions are wrong, the same over-permissioned-tools risk covered in AI agent security.

When to Pick Make vs Alternatives

Make's honest strength is breadth of integration paired with a gentle learning curve for non-engineers. Its honest limit is that the AI Agents layer is newer than the workflow engine it sits on, so for the most demanding multi-step reasoning tasks, some teams still reach for a more code-forward platform once the agent's logic outgrows what a visual canvas comfortably expresses. For most operational agents, an approval workflow, a data-entry agent, a policy-check agent like Celonis built, Make's combination of breadth and approachability is the reason it gets picked.

Key Facts

• Make's AI Agents feature layers a brain (LLM), instructions, tools, and memory on top of its existing 3,000-plus integration scenario engine, letting the agent choose which tool to call rather than following a fixed sequence.
• Make is part of Celonis, whose own team used Make AI Agents to cut expense-report auditing costs by 99.7%, from tens of thousands of dollars a year to roughly $150 a year in model spend.
• You can use Make's built-in AI provider on any plan or connect your own OpenAI, Anthropic, or Google account on paid plans.
• Existing Make scenarios can be wrapped as agent tools directly, so teams don't rebuild what they've already automated.
• The main operational risk is scenario complexity and tool over-permissioning, not raw model cost.

Where to Go Next

Make is the strongest choice when the job spans many SaaS tools and your team wants to configure it visually. If you'd rather self-host and control more of the logic by hand, see how to build an AI agent with n8n. If you want the fastest path to a first agent with essentially no setup, see how to build an AI agent with Lindy. The automation tools roundup and the best no-code automation tools guide are useful next stops for comparing Make against the rest of the field before you build.