AI in Make: AI modules, Make AI Agents and MCP

Video lecture

AI in Make: AI modules, Make AI Agents and MCP

13 chapters · about 8 min · full transcript

Coming soon

Chapter 1 of 13

AI in Make

AI modules
Built-in AI features
Make AI Agents + MCP
Reliable patterns, cost control

The narrated lecture is in production

Every chapter is scripted and ready. Browse the chapters and read the full transcript now — the video will appear here when it’s published.

Chapters

Transcript of the narration, chapter by chapter.

0:00 AI in Make

Imagine a property agent in Dubai fills in a short form, and two minutes later there's a polished listing in English and Arabic, an Instagram caption with hashtags, and a compliance check flagging a risky claim, all waiting for approval. That's what AI inside Make can do when it's designed well. In this lesson you'll learn the three ways to use AI in Make, the pattern that keeps AI steps reliable, how Make AI Agents and MCP work, and how to control costs.

0:36 Why structure matters

Why does design matter so much here? Because a language model's output varies. Ask the same question twice and you may get different wording, a different format, or occasionally something wrong. If your scenario routes on that free text, it will break in strange ways. The fix is structure: make the model return data in a fixed shape, check it, and let deterministic modules do the rest.

1:05 Three ways

There are three ways to use AI in Make. First, AI app modules, for providers like OpenAI, Anthropic's Claude and Google Gemini, using your own API key, where you pay the provider for tokens and Make charges credits per module run. Second, Make's built-in AI features, including its own AI provider option, billed in Make credits based on usage. Third, Make AI Agents, built and monitored inside the scenario builder, with instructions and tools. Make has also introduced Maia, an assistant that helps you build scenarios from plain-language descriptions. These evolve quickly, so check the help center.

1:47 The reliable pattern

Here's the analogy for the reliable pattern. Treat the AI step like a talented freelance writer who hands in work on a standard form. You don't let the freelancer run the business. You give them a brief, require the form filled in exactly, check the form, and then your own staff take action. In Make terms: clean the data, call the AI step with strict instructions and a JSON schema, parse the JSON with a data structure, route with filters on the parsed fields, take deterministic actions, and add human approval where it matters.

2:28 Make AI Agents

Make AI Agents have instructions, like a system prompt with role, goal and rules; tools, which can be your scenarios with defined inputs and outputs, app modules, or MCP tools from external servers; context, like files and data; and a reasoning panel that shows what the agent decided and why. The golden rule: expose narrow, well-described scenarios as tools, like create HubSpot deal or get order status, rather than giving the agent broad access to an app. And keep write actions behind approvals.

3:04 MCP and Make

MCP works both ways in Make. The Make MCP Server exposes your scenarios as tools that external AI systems, like a desktop assistant or another agent platform, can call with defined inputs and outputs. And MCP tools for Make AI Agents let your agents call tools hosted on external MCP servers. Both are powerful, so authenticate, scope tools narrowly, and log usage.

3:31 Example 1: email categorizer

Example one, simple. A support inbox scenario sends each email's text to an AI module with instructions to return JSON: category, urgency and a one-line summary. Parse JSON turns that into fields. A router sends urgent complaints to a Slack channel for the support lead, and everything else into a helpdesk queue with the summary attached. The AI does one small judgment task. Everything else is deterministic.

4:00 Example 2: Dubai listing assistant

Example two, realistic. A Dubai real estate agency's listing assistant. A form trigger collects property details. Set variables normalize the price in dirhams, the area and the community name. An AI module, using Claude or GPT, gets a system prompt with brand voice and banned claims, like no guaranteed returns and no best price, and must return JSON with English and Arabic titles and descriptions, an Instagram caption, hashtags and compliance flags. Parse JSON, then a router: any compliance flag goes to the compliance lead in Slack; clean drafts go to Google Docs and a content calendar. A human publishes after review, and a native speaker checks the Arabic.

4:47 Costs and limits

Costs and limits need attention. AI module runs cost Make credits, and tokens cost provider fees, or Make credits if you use Make's AI provider. Set maximum output tokens, avoid sending huge blobs of text, and summarize first when inputs are long. Watch rate limits: sequential processing or a sleep module helps with bursts. And put an error handler on the AI module: break with automatic retry for rate limits, and route parse failures to a human.

5:20 Common mistakes

Three common mistakes. Routing on free-text AI output instead of parsed fields, which breaks the first time the model rephrases. Letting an agent write straight into production systems without approvals. And publishing Arabic or Urdu marketing copy without a native speaker's review. AI can draft fluent text that is still subtly wrong or off-tone for the market.

5:45 Watch me do it: AI step in Make

Watch me do it. I add AI extraction to the Make scenario. After the dedupe filter I insert an AI module from our model provider, connected with our own API key. In the system instructions I write: extract lead fields from the message; output only valid JSON matching this schema; use only the allowed values; return null when unknown. In the user message I map the cleaned message text. Next, a Parse JSON module. I create a data structure called lead fields with service, budget amount, currency, urgency and language, generated from a sample JSON. I run the scenario once and inspect the bundle: the AI output parses cleanly into separate fields. Now I change the router filters so they use parsed fields: urgent paid social leads route to the paid social lead with a Slack mention. Then error handling. On the AI module, I add a break handler with automatic retries for rate limits. On Parse JSON, I add an error route that writes the raw message to a Google Sheet called needs human and posts to Slack. To test it, I temporarily change the instructions so the model returns plain text, run it, and confirm the bundle lands in the needs human sheet. I restore the instructions and record the credits and tokens per lead.

7:19 Recap + try this now

Recap. Use AI in Make as a step with strict instructions and a JSON schema, parse it, route on fields, and let deterministic modules act. Give agents narrow scenario tools and approvals. Use MCP deliberately and securely. Try this now: build the email categorizer from example one with a data structure for the JSON, run it on ten real emails, and check how many were routed correctly. Then add an error handler to the AI module.

7:52 Try this now

Try this now. Build the email categorizer. Add an email trigger, then an AI module with instructions that require JSON with category, urgency and a one-line summary, and allowed values for each. Add parse JSON with a data structure matching those keys. Add a router: urgent complaints to Slack, everything else to your helpdesk. Attach an error handler to the AI module that retries on rate limits and sends parse failures to a human. Run it on ten real emails and count correct routes.

Three ways to use AI in Make

AI app modules inside scenarios: modules for OpenAI, Anthropic Claude, Google Gemini and others (for example "Create a completion", "Generate an image", "Transcribe"). You connect with your own API key and pay the provider for tokens, while each module run costs Make credits.
Make's built-in AI features: Make offers its own AI provider option and AI toolkit-style modules (for example for summarizing, categorizing or extracting) that bill via Make credits based on usage. Check the current names and availability on your plan.
Make AI Agents: agents built and monitored inside the scenario builder, with a goal, instructions, and tools that can be scenarios, modules or MCP tools. Make has also introduced Maia, an AI assistant that helps build scenarios from natural-language descriptions. These features evolve quickly; check Make's help center.

Pattern: AI as a step, not the whole workflow

The most reliable Make + AI designs look like this:

Trigger -> clean data (formulas) -> AI step with strict instructions + JSON output
        -> Parse JSON (data structure) -> Router with filters on AI fields
        -> deterministic actions (CRM, email, Slack) -> human approval where needed

Ask the model for JSON matching a schema, parse it with JSON > Parse JSON using a data structure, and route on the parsed fields. Never route on free text.

Make AI Agents in practice

An agent in Make has:

Instructions (system prompt): role, goal, rules.
Tools: scenarios you expose as tools (with defined inputs and outputs), app modules, and MCP tools from external MCP servers.
Context and knowledge: files or data you give it.
A reasoning panel to inspect what the agent decided and why.

Good practice: expose narrow, well-described scenarios as tools ("create_hubspot_deal", "get_order_status") rather than giving the agent broad app access. Keep write actions behind approvals.

MCP and Make

Make MCP Server: exposes your Make scenarios as tools that external AI systems (for example a desktop AI assistant or another agent) can call, with defined inputs and outputs.
MCP tools for Make AI Agents: lets Make agents call tools hosted on external MCP servers.

Treat both as powerful integrations: authenticate, scope tools narrowly, and log usage.

Worked example: a Dubai real-estate listing assistant

Goal: agents submit property details by form; the scenario produces bilingual listing copy and social posts, checks compliance language, and prepares drafts for approval.

Form trigger (Typeform or webhook).
Set variables: normalize price (AED), area (sq ft), community name.
AI module (Claude or GPT): system prompt with brand voice, banned claims (no guaranteed returns, no misleading "best price"), required fields; output JSON: {title_en, title_ar, description_en, description_ar, instagram_caption, hashtags, compliance_flags}.
Parse JSON with a data structure.
Router: if compliance_flags not empty -> Slack to the compliance lead; else -> create drafts in Google Docs and a Notion content calendar item.
A human publishes after review. (Arabic copy reviewed by a native speaker.)

Hands-on: the prompt and data structure

System: You write property listing copy for a Dubai agency. Output ONLY valid JSON matching the schema.
Rules: no guaranteed returns or yields; no "best price"; include permit number field if provided;
Arabic must be natural Gulf-friendly Modern Standard Arabic; max 120 words per description.
Schema: {"title_en": str, "title_ar": str, "description_en": str, "description_ar": str,
         "instagram_caption": str, "hashtags": [str], "compliance_flags": [str]}
User: {{toString(3.property)}}

In JSON > Parse JSON, create a data structure with those keys so later modules can map title_en, hashtags[] and so on. Add an error handler on the AI module: on failure, Break with automatic retry (the provider may rate-limit); on parse failure, route to a human.

Costs and limits

AI module runs cost Make credits; tokens cost provider fees (or Make credits if using Make's AI provider).
Set max output tokens; avoid sending huge text blobs; summarize first if needed.
Watch rate limits; use sequential processing or sleep modules for bursts.

Pitfalls

Routing on free-text AI output instead of parsed JSON fields.
Letting an agent write directly to production systems without approvals.
Forgetting native-speaker review for Arabic or Urdu marketing copy.

Measuring success

Measure parse-failure rate (target near zero), routing accuracy on a labeled sample, share of AI drafts approved without edits, and cost per processed item (Make credits plus provider tokens).

Use AI in Make via provider modules (your API key), Make's built-in AI (credits), or Make AI Agents with tools; Maia helps build scenarios.
Reliable pattern: clean data, AI step with a JSON schema, Parse JSON with a data structure, route on parsed fields, deterministic actions, approvals.
Make MCP Server exposes scenarios as tools; Make agents can call external MCP tools; authenticate and scope narrowly.
Control cost with token caps and trimmed inputs, handle rate limits and parse failures with error handlers, and review AR/UR copy with native speakers.

Build the email categorizer: AI module returning JSON, Parse JSON with a data structure, router on category and urgency. Test on ten real emails, then add an error handler to the AI module.

Enrol for free to save your progress

Reading is always free. Enrol to keep your place, take the final assessment and earn a verifiable certificate.

AI in Make: AI modules, Make AI Agents and MCP