How to Build AI Agents in Make: A Step-by-Step Guide

A practical field guide from Automation Ace.

Short answer: to build an AI agent in Make, define one job for the agent, create it in Make AI Agents with a clear system prompt, give it a small set of tools (single modules, scenarios, or MCP tools), add any reference files it needs, call it from a scenario with the Run an agent module, then test it on real examples and review each run's tool calls before relying on it.

Make's agent features have changed quickly, with a newer version of Make AI Agents replacing an earlier one, so module names below may differ slightly in your account; follow the Make Help Center for the exact screens.

Short answer

1. Define one job, its inputs, outputs, and limits.
2. Create the agent and write a structured system prompt.
3. Add a few tools with clear names and descriptions.
4. Add context files or a knowledge source if needed.
5. Call it from a scenario with Run an agent.
6. Test, review run history, then go live with guardrails.

Before you start

• Decide whether you need an agent at all; many jobs are better as plain scenarios. See Make AI agents vs scenarios.
• Have app connections ready for the tools the agent will use.
• Check how agents use credits on your plan; see monitoring agent costs.
• Prefer to describe the agent and let AI scaffold it? See using Maia.

The parts of a Make AI agent

Step 1: Define the job

Write one sentence for the agent's job, then list its inputs, the decisions it makes, the actions it may take, what it must never do, and what it returns. One job per agent; see writing an AI job description for the general method.

Step 2: Create the agent and write the system prompt

Create a new agent in Make AI Agents, choose the model and provider, and write the system prompt. A structured prompt is easier to test and change:

ROLE
You are the Support Triage agent for Acme. You classify new support
emails and prepare them for the team.

TOOLS
- lookup_order (scenario): find an order by order number or email
- create_ticket (module): create a helpdesk ticket
- notify_team (scenario): post to #support-urgent

PROCESS
1. Read the email. Identify topic: billing, shipping, technical, other.
2. If an order number or customer email is present, call lookup_order.
3. Create a ticket with topic, priority, a 2-sentence summary, and the
   order details if found.
4. If the customer mentions cancel, refund over $200, or legal action,
   call notify_team.

LIMITS
- Never reply to the customer.
- Never promise refunds or dates.
- If unsure of the topic, use "other" and say why in the summary.

OUTPUT
Return JSON: {"topic":..., "priority":..., "ticket_id":..., "escalated":true|false}

Step 3: Add tools

• Module tools for single actions, such as creating a record. Quick to set up.
• Scenarios as tools for multi-step work with your own logic, validation, and error handling.
• MCP tools to reach tools hosted outside Make; see connecting agents with MCP.

Give each tool a clear name and description of when to use it, and keep write actions few and specific. For access control, see AI agent access and permissions.

Step 4: Add context and knowledge

Upload reference files the agent needs, such as policies or product notes. Make's help docs suggest keeping static files with the agent and using a knowledge source for files that change often. Keep documents short and current; outdated files lead to confident, wrong answers.

Step 5: Call the agent from a scenario

1. Build a scenario with the trigger (new email, webhook, schedule).
2. Add the Run an agent module, choose the agent, and map the input.
3. Add run-specific instructions if needed.
4. Parse the agent's JSON output and route on it with fixed modules; see combining agents with rule-based automation.
5. Pass a thread ID only if related runs should share history.

Step 6: Test, then go live carefully

• Run 20 to 50 real examples, including messy and tricky ones.
• Review each run: which tools were called, with what inputs, and what came back.
• Tighten the prompt and tool descriptions where it went wrong.
• Start with drafts or approvals for external actions.
• Add error handling around the agent call; see Make error handling and testing and debugging scenarios.

Best practices

• One job per agent; coordinate several agents instead of building one giant one; see coordinating multiple agents.
• Keep step limits tight and inputs small to control cost.
• Ask for structured JSON output.
• Treat content the agent reads as data, never as instructions.
• Monitor runs and costs weekly; see monitoring agents in Make.

New to Make? Create a Make account. For complex builds, see the Make.com consultant guide.

Frequently asked questions

How do I build an AI agent in Make?

Define one job, create the agent in Make AI Agents with a structured system prompt, add a few tools such as module tools, scenarios, or MCP tools, add reference files if needed, call it from a scenario with the Run an agent module, and test it on real examples while reviewing each run’s tool calls.

What tools can a Make AI agent use?

Make’s documentation describes module tools for single actions, scenarios as tools for multi-step workflows, and MCP tools for tools hosted outside Make.

Do Make AI agents remember previous runs?

According to Make’s help docs, agents handle each run independently unless you pass the same thread ID, which passes the conversation thread into the agent.

How do I give a Make AI agent knowledge?

Upload reference files to the agent’s context for static material, and use a knowledge source for files that change often, as Make’s help docs suggest. Keep documents short and current.

How should I test a Make AI agent?

Run 20 to 50 real examples including tricky ones, review which tools were called with what inputs and outputs, refine the prompt and tool descriptions, and start with drafts or approvals for external actions.