How to Build Next-Gen Make AI Agents in the Scenario Builder
Introduction
Make spent years perfecting deterministic automation: you draw the scenario, and it follows your drawing exactly. The problem is that real work rarely matches the drawing. A customer writes a paragraph instead of picking a dropdown option, a ticket arrives half finished, and the whole flow needs a judgment call nobody programmed. Next-gen Make AI Agents, announced on October 8, 2026 and demoed at Waves ‘25, fill that gap by placing an agent directly inside the scenario builder canvas, with visual execution, a reasoning panel, and one-click sharing. This tutorial walks you through building your first one, from access to a working, debuggable agent.
Quick answer
Join the next-gen AI Agents waitlist, then build in the scenario builder: create the agent, connect an AI provider, write a concise system prompt, attach Module Tools, add dynamic routing, and test in the in-canvas chat with the reasoning panel.
Evidence
The launch is fresh and well documented. Make published the official announcement on October 8, 2026, followed by a deep dive on October 16, 2026 after the Waves ‘25 reveal. The scale is serious: the announcement positions next-gen agents as orchestrating work “across 3000+ apps” as of October 2026, combining adaptive AI decision-making with the visual platform Make users already know.
Make’s own framing of the change is worth quoting directly. On transparency, the announcement states: “Nothing runs behind the scenes.” On what the generation leap means, the deep dive says: “This is AI that infuses automation with intelligent actions that can reason and adapt.” And on why the canvas placement matters, Make writes: “We listened to your feedback to deliver what we believe is a major step change”, referring to agents that are built, run, and debugged inside the same canvas as scenarios.
For setup mechanics, the Make how-to guide for building AI agents documents the creation flow (AI Agents section, Create agent, name and description, connect a language model), while the Make help center’s agent management page documents provider options and context file limits. The two launch posts themselves are the primary source for everything next-gen: the October 8 announcement and the October 16 deep dive.
Prerequisites
- A Make account (any plan; Module Tools work on all plans, custom AI providers need a paid plan).
- Access to the next-gen AI Agents closed beta, or the first-generation AI Agents beta as a fallback. As of October 20, 2026, next-gen access requires the early access waitlist.
- An AI provider: Make’s built-in AI provider works on every plan; for OpenAI or Anthropic Claude you need a paid Make plan plus your own API key.
- Basic familiarity with Make scenarios: modules, routes, and mapping fields between modules. If routers are new to you, read our Make error handler and execution flow guide first.
Step-by-step guide
Step 1. Get access to the next-gen agents
As of October 20, 2026, next-gen Make AI Agents are in closed beta. Sign up through the early access waitlist linked from Make’s announcement. Waves ‘25 attendees get priority, but waitlist spots are limited, so join even if you attended nothing.
While you wait, everything below still applies to the first-generation AI Agents beta, which Make switched on for users progressively. The setup concepts (provider connection, system prompt, tools) carry over; the next-gen difference is where agents live (inside the scenario builder canvas) and how transparent their execution is (reasoning panel, visual traces).
Step 2. Create the agent
In Make, open the AI Agents section from the navigation panel and click Create agent. Give the agent a descriptive name such as “Support Triage Agent” and write a clear description of its role. Make’s own guide uses an inventory example: “You help manage store inventory. You can check stock levels or place restock orders using the tools provided. Only respond based on tool outputs and available data.”
Add explicit limits in the description. Two patterns that prevent expensive mistakes:
- “Do not order more than 100 units without asking.”
- “Ask for clarification if the request is ambiguous instead of guessing.”
In the next-gen canvas, you create the agent directly on the scenario builder instead of a separate management screen. The agent becomes a first-class module on the canvas, sitting alongside your deterministic modules.
Step 3. Connect the AI provider and model
In the Connection dropdown, choose your AI provider. Per the Make help center, users on all plans can select Make’s AI Provider, while paid plans can add a custom provider connection such as OpenAI or Anthropic Claude. If you do not have a connection yet, click Add, pick the connection type, enter the API key, and save.
Then pick the Model the agent will use for reasoning. Practical rule: start with a mid-tier model for triage and classification work, and only move to the flagship model for tasks where reasoning quality visibly matters (multi-step research, nuanced drafting). You can change the model later without rebuilding the agent.
Step 4. Write the system prompt
In the System prompt field, define the agent’s purpose and constraints. The help center recommends keeping it concise and tailoring behavior per task later. A good system prompt has three parts:
- Role: “You are a support ticket triage specialist for an online store.”
- Available data: “You receive the ticket subject, body, and customer tier.”
- Hard rules: “Always set priority before drafting a reply. Never promise refunds; escalate those to billing.”
Avoid stuffing the system prompt with procedures the tools already encode. If a tool is “Create Zendesk ticket with priority field”, the prompt should say when to use it, not how Zendesk works.
Step 5. Attach tools with Module Tools
An agent without tools is a chatbot. In the next-gen model, you equip the agent “in seconds by selecting any Make app and module”, in Make’s words. The companion feature is Module Tools: turn any module into a callable tool instantly, with no full scenario needed. Module Tools are available now on all plans, so you can build your toolset before your beta invite arrives.
For a support triage agent, attach:
- A ticket search module (find similar past tickets).
- A priority setter or tag module.
- A draft reply module (writes, but does not send, the response).
- A knowledge base lookup (docs or FAQ search).
Keep full control over which inputs are AI-decided and which you set yourself. Make’s announcement explicitly calls this out as a design principle: deterministic fields (which mailbox, which priority values exist) should be fixed by you, while the agent decides the judgment calls (which priority fits this ticket). If you connect external AI services through Make’s platform instead, see our Make MCP server tutorial for the complementary direction.
Step 6. Add dynamic routing
This is the flagship next-gen capability. Dynamic routing lets you “empower routers with adaptive logic in a single step, letting AI decide the right way to tackle a task”, per Make’s deep dive. In practice: instead of building five filter branches for ticket categories you can enumerate, you add one AI-driven routing step that classifies the ticket and picks the route.
A concrete pattern that works well:
- Webhook or mail trigger receives the ticket.
- Deterministic modules normalize the data (strip signatures, extract the customer tier).
- The agent step classifies and drafts.
- A dynamic router sends billing issues to the billing queue, bugs to engineering, and everything else to general support.
- Each route ends with deterministic modules (create the ticket, notify Slack).
Keep the deterministic shell around the agentic core. The agent handles the fuzzy middle; Make’s visual modules handle the reliable edges. That is the “automation spectrum” Make describes: deterministic steps where outputs must be predictable, agentic steps where inputs are messy.
Step 7. Test in the in-canvas chat and read the reasoning panel
Next-gen agents include in-canvas chat: you talk to the agent directly inside the Make canvas to test and refine its behavior in real time, without leaving the workflow. Use it the way you would interrogate a new hire:
- “How would you prioritize this ticket: ‘My invoice is wrong and I need this fixed today’?”
- “Why did you choose the billing route for the last test?”
- “What would you do if the customer tier field is empty?”
Then check the reasoning panel. Make promises “a clear real-time view into how your agent thinks, which tools it calls, and why it takes each path”. When a test surprises you, the panel is where you find out whether the system prompt, the tool definitions, or the input data caused it. Iterate on the prompt, rerun the same test, and confirm the behavior changed. This loop replaces log-hunting, and it is the main debugging workflow Make designed for.
Step 8. Share, reuse, or start from the Library
Once the agent behaves, share it. Next-gen agents support one-click sharing across scenarios, teams, and clients, so a triage agent built for support can be cloned and fine-tuned by the sales team for lead qualification. Make is also shipping a Library of Agents with ready-made templates for real workflows: inventory management, research, triage, and reporting are the launch examples. Starting from a template beats starting from a blank canvas, because each template shows how deterministic automation and agentic reasoning combine in a working structure.
If you are comparing agent platforms before committing, our n8n vs Make for AI agents comparison breaks down where each platform’s agent story is strongest.
Troubleshooting
Problem 1: “I don’t see AI Agents in my account”
Cause: Next-gen agents are in closed beta as of October 2026; the first-gen beta also rolled out progressively rather than to everyone at once.
Fix: Join the early access waitlist from Make’s announcement page. Meanwhile, build your toolset with Module Tools (available on all plans now) and draft your system prompts, so you can assemble the agent the day access lands. Check the AI Agents section periodically; beta waves have been expanding.
Problem 2: “The agent calls tools with wrong or missing parameters”
Cause: Ambiguous tool input schemas. When every input is left for the AI to decide, the agent guesses formats (dates, IDs, enums) and guesses wrong.
Fix: For each tool, explicitly set the inputs that have a fixed format or a closed set of values (calendar IDs, status enums, date formats), and leave only the genuinely judgment-based inputs to the AI. This matches Make’s own guidance: full control over which inputs are AI-determined and which are set by you. Retest in the in-canvas chat after tightening the schema.
Problem 3: “The agent gives different answers on identical inputs”
Cause: Non-determinism is inherent to LLM-driven steps. Temperature, model updates, and phrasing variance all contribute.
Fix: Shrink the agent’s surface area. Move everything deterministic out of the agent into visual modules (normalization, validation, final formatting), and keep the agent step narrow (classification only, or drafting only). For billing or compliance paths, bypass the agent entirely with filter branches. If variance persists on the narrow step, try a more capable model or a stricter system prompt before blaming the platform.
Problem 4: “Context file upload fails or the agent ignores my documents”
Cause: Hitting the documented limits, or uploading unsupported formats.
Fix: The help center limits are specific: TXT, PDF, DOCX, CSV, MD, and JSON only; 20 MB maximum per file; 20 files maximum per agent. Files land in a RAG vector database for long-term memory. If uploads fail, check format and size first. If the agent ignores a document, the file may be too large to retrieve well; split long documents into focused chunks (one policy per file beats one 300-page manual).
Problem 5: “Costs are unpredictable”
Cause: Every agent run consumes AI provider credits per reasoning step and tool call, and long in-canvas chat debugging sessions add up.
Fix: During development, use Make’s built-in AI provider or the cheapest adequate model, and keep test inputs small. Watch which steps trigger the most tool calls in the reasoning panel; a tool that gets called three times per run usually has an unclear description. Tighten the tool description (“use only when the ticket mentions an invoice number”) to cut redundant calls before you scale up.
FAQ
Are next-gen Make AI Agents generally available? As of October 20, 2026, they are in closed beta behind an early access waitlist, with Waves ‘25 attendees getting priority. The first-generation AI Agents beta remains the fallback for existing users.
What is dynamic routing in Make AI Agents? Dynamic routing adds adaptive, AI-driven decision logic to a router in a single step, so the agent picks the right path per task instead of you enumerating every branch condition with filters.
Which AI providers can power a Make AI Agent? All plans can use Make’s built-in AI provider. Paid plans can also connect a custom provider such as OpenAI or Anthropic Claude, according to the Make help center.
Can next-gen agents handle files, not just text? Yes. Make’s October 2026 announcement confirms multi-modal support: agents accept, analyse, and produce PDFs, images, CSVs, and more directly on the canvas.
How do I share an agent with my team? One-click sharing works across scenarios, teams, and clients. Make’s upcoming public Library of Agents will add curated templates for inventory management, research, triage, and reporting.
What are Module Tools? Module Tools turn any Make module into a callable agent tool instantly, without a full scenario. Available now on all plans, they are the fastest way to equip an agent.
Conclusion
Next-gen Make AI Agents move agents from a side panel into the scenario builder canvas, add a reasoning panel that shows every decision, and introduce dynamic routing so one AI step can replace a thicket of filter branches. Join the early access waitlist, build your toolset with Module Tools today, and keep deterministic modules around the agentic core. For the mirror-image integration (exposing Make to external AI assistants), read our Make MCP server tutorial next. If your Make agents run on Claude models, watch for the extended-thinking error covered in our Make Claude Sonnet 5.5 extended thinking fix.