Make.com AI Agents Setup: Your First Agent in 2026

We may earn a commission if you buy through our links, at no extra cost to you.

Make (the former Integromat) took a different road into AI agents than n8n: instead of a standalone agent builder, it dropped AI agent modules inside the scenario builder you already know. A Make AI agent is a module that sits in a scenario flow and provides non-deterministic, AI-driven logic — where a Router uses fixed conditions, the agent decides on its own which tools to call, how many times, and in what order. That makes it the gentlest on-ramp of the three platforms in this guide series: no Docker, no API keys to start, and a free tier that actually works.

This is a researched setup guide, not a live lab test. Every step is verified against Make's AI-agent documentation, its official scenario-building skill reference, and current September 2026 tutorials (sources at the bottom). Make's UI is mid-evolution — the module may appear as "Make AI Agents (New)" or "Run an agent" depending on your workspace — so treat labels as approximate and the flow as the contract. Pricing below is a September 2026 snapshot; confirm at make.com before spending.

What you'll need

• A free Make account — sign up at make.com. The free plan gives you 1,000 credits/month, up to 2 active scenarios, and a 15-minute minimum schedule interval.
• Something for the agent to work on — e.g. a Google Sheet of leads, a Slack channel, or your inbox via a trigger module.
• No API key to start — free-plan users run agents on Make's built-in AI Provider.

Step 1: Create your Make account

Sign up at make.com with your email and you'll land on the dashboard. The free tier is genuinely enough to build and test your first agent: 1,000 credits a month (a credit is Make's billing unit — one credit per standard module action), two active scenarios, and scheduled runs every 15 minutes at minimum. You don't need a credit card, and you don't need an OpenAI key yet. That's the whole pitch for starting here instead of n8n: your first agent costs $0 and five clicks.

Step 2: Create a new scenario

Click "Create a new scenario" from the dashboard. You'll get the visual canvas — Make's famous node-and-wire editor. First add a trigger that feeds the agent something to work on: for a lead-qualifier agent, that's a "Watch new rows" module on a Google Sheet of incoming leads; for a support agent, a "Watch messages" module on a Slack channel. The trigger's output becomes the agent's input, so pick the trigger that matches the job you actually want done.

Step 3: Add the AI Agents module

Click the + after your trigger, search for AI Agents, and add the module (you may see it labeled "Make AI Agents (New)" or "Run an agent" — same family, evolving UI). This module is the agent: at runtime it receives the incoming bundle, reasons over it according to your instructions, decides which tools to call, and outputs a single bundle representing its result. Wire that output onward — through a router, into a sheet, to Slack — like any other module.

Step 4: Configure the AI provider

Open the module and pick the LLM that powers the agent. Your options: OpenAI, Anthropic, Gemini, or Make's built-in AI Provider. The rule from Make's own reference is simple: free-plan users must select Make's AI Provider; paid users can choose any supported provider. Starting free, this is a feature, not a limitation — Make's provider means zero key management and zero surprise API bills while you learn. When you outgrow it, connect your own key for model choice or your own negotiated rates.

Step 5: Write the instructions

Instructions are the agent's job description — its role, goals, constraints, and step-by-step behavior. This is where agents succeed or fail, and the honest advice from every current tutorial is the same: start with one simple job. A lead qualifier that rates leads HOT / WARM / COLD with a reason will work; a "run my marketing department" agent will not. Cover the role and goal, the inputs arriving from the trigger, the exact output format (the agent outputs one bundle — name the fields), and stop conditions: when to stop, what to do when data is missing, what it must never do (never email the lead directly, never invent contact details).

Keep the system prompt short and put per-run context in the messages/additional-instructions fields, mapped from scenario data. Long rambling prompts cost more tokens and confuse the agent — concise and specific beats thorough and vague.

Step 6: Add knowledge files (optional, powerful)

The agent can carry a knowledge base: upload TXT, PDF, DOCX, CSV, MD, or JSON files (up to 20 MB per file, 20 files per agent) and Make stores them in a RAG vector database, retrieving the relevant chunks per request. This is your FAQ doc, brand guidelines, pricing sheet, or policy manual — the context that turns a generic agent into your agent. Skip this for your first build if you don't have docs ready; add it the moment the agent needs facts it can't guess.

Step 7: Give the agent tools

Tools are what let the agent act: search the web, send an email, update a record, call an MCP server. Equip only what the task needs — each tool is a decision the agent must make, and a confused agent with ten tools is worse than a focused agent with two. Practical control trick from current guides: instead of giving the agent native write access to your CRM, expose a webhook tool so the agent can only do what the webhook allows. And keep sensitive operations out of agent hands entirely — Make's own guidance is to trust agents with tasks you'd trust an intern with, not with high-stakes or legally binding decisions.

Step 8: Test in Chat, watch the Reasoning panel

Here's where Make beats most platforms for learning: you can test the agent in Chat — a free way to iterate without burning scenario credits. Send it a sample input and open the Reasoning panel / execution log to watch it think step by step: which tools it chose, in what order, and why. When the output is wrong, fix in this order: tighten the instructions, improve the tool descriptions, reconsider the tool set, then change the model. A common beginner trap: complex agents with many modules added at once are hard to debug — build up from one tool, not down from ten.

Step 9: Activate and schedule

Once the output matches your goal, toggle the agent to Active and set the scenario's schedule. Free plans run at a 15-minute minimum interval; paid plans go down to 1 minute. Add a second router after the agent module to catch failures — e.g. route "no match found" outputs to a human-handoff Slack channel instead of letting misclassified items die silently.

What it costs

Make bills in credits: most standard module actions cost one credit each, while AI-model actions can bill fractionally by token. Good news: routers, filters, and error-handler modules cost nothing. The practical math is steps-per-run × runs-per-month plus variable AI usage — run a representative scenario and inspect actual credit usage before buying a bigger allowance.

Snapshot from September 2026 reporting — multiple sources noted a roughly 25% price cut that month (Core $12→$9, Pro $21→$16, Teams $38→$29); prices may have moved since, so confirm at make.com/en/pricing. Free plan: max 2 active scenarios, 15-minute minimum interval.

Next steps

Your first agent is a lead qualifier; the platform goes further. Thread IDs keep multi-turn conversations in one thread. MCP integration connects agents to external MCP servers for extra tools. Output files let agents generate PDF, DOCX, TXT, or CSV. And Make's MCP server flips the relationship: external agents (Claude, ChatGPT, Cursor) can drive your Make scenarios through MCP — the same 3,000+ apps, callable by any MCP-compatible client. For the deeper, code-first agent platform, our n8n agent setup guide is the natural next read; for agents as code, our Claude Agent SDK guide.

Frequently asked questions

Can I build a Make AI agent on the free plan?

Yes. Make's free plan includes 1,000 credits per month and access to the AI Agents feature — you just use Make's built-in AI Provider instead of your own OpenAI, Anthropic, or Gemini key. Limits: up to 2 active scenarios and a 15-minute minimum interval on scheduled runs.

Do I need an OpenAI API key for Make AI agents?

Not to start. Free-plan users must use Make's built-in AI Provider, which needs no key of your own. Paid-plan users can additionally connect OpenAI, Anthropic, or Gemini — useful for model choice or your own negotiated rates.

How are Make AI agents billed?

Like everything in Make: credits. Standard module actions cost one credit each; AI-model actions can bill fractionally by token. Routers, filters, and error handlers are free. Test in Chat to iterate without burning credits, and inspect actual credit usage on a representative scenario before buying a bigger plan.

What's the difference between AI apps and AI agents in Make?

An AI app (structured AI) does predefined logic plus AI-generated content with fixed parameters — translate, summarize. An AI agent (flexible AI) reasons on its own: it decides which tools to call, how many times, and in what order, based on instructions and input. Agents suit judgment calls; apps suit repeatable tasks.

Can Make AI agents run on a schedule?

Yes — schedules are a scenario setting, and the agent module is just a step in the scenario. Free plans run at 15-minute minimum intervals; paid plans go down to 1 minute. Toggle the agent to Active and set the schedule on the scenario.

Make or n8n for AI agents — which should I choose?

Make is easier to learn, has a genuinely usable free tier with no API key needed, and credits that suit moderate automation. n8n is the stronger agent platform for technical users: native agent nodes, full code access, local LLM support, self-hosting, and per-execution billing that wins at scale.

Sources

• Make official skill — AI Agents: what it is, provider setup, knowledge, tools
• Make official skill — AI agent module fields (model, instructions, thread ID, timeout)
• FahimAI (2026) — how to use Make AI Agents step by step
• Northryn — Make pricing explained 2026 (plans, credits, costs)
• Neomanex — Make's September 2026 price cut (Core $9, Pro $16, Teams $29)
• Sept 2026 comparison — n8n vs Zapier vs Make pricing and AI agents
• Pondero — Make MCP server setup guide (June 2026)