How to build an AI agent with Make

Most automation breaks the moment reality stops behaving. A scenario that syncs rows between two apps works fine until someone types an address into the name field. Then it fails, and you fix it by hand.

AI agents fill that gap. They handle the parts of a workflow that need judgment instead of rules.

This guide walks through building one in Make from scratch: planning, scenario setup, configuration, tools, knowledge, and testing. Everything here comes from Make's own documentation for the Make AI Agent (New) app.

One note before you start. The new version of the app launched on February 2nd, 2026 and is in open beta, so functionality and pricing may still change. It works on all plans using Make's AI provider, with custom AI provider connections available on paid plans.

What an AI agent actually is in Make

An AI agent is an AI system that independently performs tasks for you based on your instructions. In Make, that means a specific module you drop into a scenario, not a separate product.

Seven concepts do most of the work:

Large language model (LLM). The brain the agent uses to think and make decisions. Without it, the agent can't understand or respond to requests.

AI provider. The connection between your agent and an LLM. Common providers include OpenAI, Gemini, and Anthropic Claude. Make's own AI provider connects to LLMs without needing an account with any provider.

Reasoning. The agent's step by step thinking, so you can understand each decision and debug when something goes wrong.

Instructions. Guidelines that define the agent's role and behavior, including goals, steps, and rules that apply across all tasks.

Knowledge. Reference information stored in the agent's memory, such as FAQs, brand guidelines, company policies, and internal documentation.

Input. Variable information the agent processes each time it runs, including specific requests and data from third party services.

Tools. Connections to third party services like email, databases, and CRMs. In Make, tools are modules, scenarios, MCP server tools, and other agents.

When to use an agent, and when not to

This is the part people skip, and it costs them. Make draws a clear three way split.

Use an agent for tasks needing flexible reasoning, judgment calls, and variable inputs and outputs. Categorising support tickets, screening candidates, analysing market data.

Use a scenario with an AI app for tasks that combine predefined logic with AI generated content, where both inputs and outputs follow specific parameters. Translating, transcribing, summarising.

Use a standard scenario for predefined logic that always produces the same output for a given input. Syncing data, processing orders, updating customer records.

The best heuristic in the whole doc set is this one: since AI systems provide unpredictable results, choose tasks for your agent that you trust an intern to handle. Avoid tasks involving sensitive data, high stakes financial or strategic decisions, or strict legal requirements.

If you wouldn't hand it to a smart new hire on day three, don't hand it to an agent.

Step 1: Plan the agent

Write down four things before you touch the builder. Make's own example:

What the agent does: a content marketing specialist who creates blogs for social media based on trending industry topics. Tools: Google Drive, Airtable, LinkedIn, and Facebook modules. Knowledge: the company style guide and product glossary. Trigger: a Google Sheets document with trending topics.

That's the whole framework. Job, tools, knowledge, trigger.

Step 2: Build the scenario

Your agent lives inside a scenario. Sign in to Make and click Create scenario at the top.

Add a trigger

A trigger is the module that starts the scenario and determines how the agent receives new requests or information.

Click the giant plus in the builder. Search for the service you need, such as Gmail or Google Sheets, and click its app. Select the module matching the action you want, for example Watch changes or Search rows. Configure it and save. Then click the clock icon on the module to set schedule settings.

The option to start the scenario immediately when new data arrives is only available for instant triggers, marked with an instant tag.

Add extra modules if you need them

Some use cases need extra modules before the agent, particularly to supply information that changes frequently. Download file, web search, and chat message modules are common examples.

Add the agent module

Click the plus icon to the right of your last module, search for Make AI Agents (New), and select the Run an agent (New) module.

Step 3: Configure the agent

Pick a provider and model

In the Connection field, click Add to create a new AI provider connection or select an existing one. On a free plan, select Make's AI provider. On a paid plan, select Make's AI provider or a custom connection such as OpenAI or Anthropic Claude. If the connection needs an API or access key, get it from your provider account. Then pick a model from the Model dropdown.

Models vary in processing speed, reasoning ability, token cost, and effectiveness at specific tasks.

Make's recommended approach is worth following: start with a large, advanced LLM, such as Make AI provider's large model. Test the agent multiple times to see how well the model works. Once you know what good performance looks like, scale down gradually.

Benchmark high, then cut cost. Not the reverse.

Write the instructions

Instructions tell the agent what its job is and how to do it. The agent follows these rules across all tasks and requests.

Think of instructions as a briefing document. A vague or incomplete briefing creates more opportunities for unpredictable results.

Make lists six things to include:

• All steps the agent takes to complete its tasks.
• Tools the agent calls at each step, including their names and what they do.
• Knowledge files to reference at each step and what they contain.
• Guardrails defining expected and undesirable behaviour.
• Examples of inputs and outputs, including expected formatting.
• Examples of exceptional situations and how to respond.

On formatting: organise instructions with headers, bullet points, or numbered lists so the agent can easily understand them. Optionally, use an LLM to rewrite your instructions in markdown.

Add inputs and files

In the Input field, add specific one time requests or mapped data from previous modules. In Input files, add a file the agent receives from a previous module. Name it in File name, then click the Data text field and map the file from your download file module.

File requirements matter here:

To input files, you must select Make's AI provider, OpenAI, Anthropic Claude, or Gemini, and a model that supports files. Supported input formats include JPG, PNG, GIF, and PDF. Output files the agent generates support PDF, DOCX, TXT, and CSV.

For text files: add a separate HTML tag for each file in the Input field, mapping the output value from your download file module. This may consume significant space in the agent's memory, so uploading the file as a knowledge file instead lets the agent retrieve only relevant chunks.

For binary files: add an AI module before the agent, such as Make AI Content Extractor, to transform the data into a readable format.

Optional settings worth knowing

Conversation ID. Specify a custom ID so your agent remembers interactions in a single thread and can reply to them. You can also map a thread ID or timestamp from a previous module, such as an email or Slack message thread ID. Leave it blank and the agent has no memory of previous interactions, generating a new ID each run.

Maximum conversation history. If you added a conversation ID, set the maximum number of replies the agent remembers.

Step timeout. The maximum number of seconds an agent runs in each step before failing. Leave it blank and the default is 300 seconds.

Response format. Select Text to return text output, or Data structure to return responses in a custom structure you define.

Step 4: Add tools

Tools extend agent capabilities by connecting to apps. In Make, tools include modules, scenarios, and MCP tools. You can add as many as needed.

Modules

Add modules as agent tools for one step tasks, such as monitoring new customer contacts, sending emails, downloading files, or updating spreadsheets.

Hover over the plus icon of the Run an agent (New) module and click Add tool. Search for the service, select the module matching the action you need, configure it, and save.

Scenarios

Add scenarios as agent tools for more complex tasks involving several steps or third party services.

To use an existing scenario: click Add tool, search for Scenarios, and select the Call a scenario module. Pick your scenario from the dropdown. If you want the scenario to return data to the agent, it must end with a Return outputs module. Describe what the scenario does and when the agent should use it, then choose whether to wait for the scenario to finish before continuing.

To build a new one: from the Scenario dropdown, click Create scenario. Name it, describe what it does, then define scenario inputs and outputs. Inputs are data parameters the agent fills when calling the scenario; outputs are data the scenario returns to the agent.

Example inputs: customer email address, first name, last name, email body, and row ID from a spreadsheet. Example outputs: email timestamp and success status.

Don't forget the last step: toggle On demand on the toolbar to activate the scenario and allow the agent to call it when needed.

MCP server tools

Give your agent access to third party MCP server tools when the actions you want are unavailable through standard apps.

Hover over the plus icon and click Add MCP. Search for MCP client and select the Call a tool module. Name your tool and describe what it does so the agent knows when to call it. In Connection, add a connection to an MCP server, selecting the server from the dropdown and entering its connection URL from the MCP client documentation. Add an API key if required, then select the tool from the Tool name dropdown.

Naming tools properly

This is where most agents fail, and the fix is cheap.

Your agent chooses the right tool for a task based on its name and description. When adding a tool, clearly describe what it does and when to call it.

Make's example is a good template: tool name "add customer email to spreadsheet," tool description "adds a new customer email address to the customer contacts spreadsheet. Do not add if the email address is invalid or already exists."

Also specify the correct tool names and when to call them in the agent's instructions or inputs.

Adding a human approval step

If you want to approve a tool's output before the agent continues, add a tool that sends the output to you for review, and explain this extra step in the instructions. For example, instruct the agent to send a Gmail draft to you on Slack, then reply to confirm the draft or request changes.

Step 5: Add knowledge

Knowledge is reference information the agent uses to tailor its responses. Knowledge files are typically static, such as company guidelines or glossaries. The agent stores files in a RAG vector database, retrieving relevant parts based on your request.

Before adding a file, give it a name that clearly describes what it contains.

Option A: directly in the agent app

Hover over the plus icon of the Run an agent (New) module and click Knowledge. Click Upload files, then Choose file. Supported types include JSON, TXT, CSV, and PDF. File upload consumes tokens for converting content to vectors and generating descriptions, varying by file size. Save, then click the pencil icon next to your file to edit the AI generated description if needed.

Under advanced settings, you can specify a search query the agent uses to find information in your file, or let the agent decide (recommended). Same for the number of relevant chunks returned.

Option B: the Knowledge app

Better for files that change often. To avoid uploading files each time the main scenario runs, create a separate scenario. Add a download file module such as Google Drive or Gmail, configure and save it, then click Run once to get mappable data. Add the Knowledge app's Upload knowledge module, mapping the file name and file content from the download module. Run once to upload.

What belongs in knowledge

Good: company guidelines, internal knowledge bases such as Confluence pages, support tickets, community posts, Slack conversations, style guides, brand guidelines. Upload files that reflect what you want the agent to reproduce.

Avoid: vague information the agent can interpret in different ways, sensitive data such as customer information and billing details, information that changes frequently such as client directories, and unrepresentative or poor quality examples.

Consider the garbage in, garbage out principle. Lower quality inputs lead to similarly flawed outputs.

Step 6: Test the agent

Expect this to take longer than the build. Agents rarely perform as you expect when you first run them, so you'll need to test them multiple times.

Chat with the agent

Chat is an interface where you send sample requests to test performance. Hover over the plus icon of the Run an agent app and click Chat, or right click the module and select Chat with agent. Enter a request. The agent calls the relevant tools and returns a response. If called tools show a red error symbol, expand the tool and view its output.

Then adjust, resend, repeat.

Run the scenario with past data

Click the downward arrow next to Run once, select a previous scenario run to use as test data, and click Run once.

Read the run details

Click the back arrow next to the scenario name, click History, then click Details next to a run with an error status. Click the output bubble to view outputs and expand an operation in the Output tab. Key fields include response and metadata, then execution steps. To see the agent's thought process, go to the Reasoning tab.

Fix instructions with an LLM, not by hand

Most errors or unexpected results come from unclear or misleading instructions. Improve prompts using LLMs like ChatGPT and Claude instead of editing manually. Request an update based on your current instructions, the execution steps in the agent's output, and what the agent was thinking at each step from the Reasoning tab. Add the new prompt to Instructions and run again.

Fix tools by renaming them

If tools return errors, or the agent doesn't call them when expected, click the handle next to the tool and edit the tool name and tool description fields. Then update the agent prompt wherever the tool is mentioned so the names match.

Managing your agent

Clone duplicates only the agent module. Right click the Run an agent (New) module, click Clone, link the cloned module to the scenario, and adjust its settings.

Copy duplicates the agent and its tools. Hold Shift while clicking the canvas, drag over the agent module and its tools, then use Ctrl+C and Ctrl+V on Windows or Command+C and Command+V on Mac.

Delete works two ways. Right click the module and click Delete module, or delete the whole scenario from the Scenarios list using the three dot menu.

Data security

Read this section twice.

The LLMs behind your agent are evolving systems vulnerable to risks such as personally identifiable information disclosure in outputs and prompt hacking. Assume that anyone could access the information you share with your agent, including its tool data and knowledge.

Only give your agent the data it needs to do its job. For example, allow it to export the free/busy slots of your calendar rather than the entire calendar. You can also map data into the agent's tools instead of exposing it to the agent directly.

Set guardrails in your instructions: limit engagement with off topic queries, avoid sharing sensitive information in outputs, flag harmful or unsafe inputs, prioritise internal knowledge bases as references, and prompt a human to validate outputs.

But keep expectations honest: agents could still behave unpredictably and ignore or misinterpret your explicit guardrails. Choose your data with this assumption in mind.

Keeping token costs down

Agents use tokens to process inputs and return outputs. Reduce token usage by limiting the amount of data they handle.

Three levers:

Filter inputs, such as narrowing a database search to a specific date or field, mapping a specific value instead of an entire file, or adding a filter in the route before the agent.

Upload reference files as knowledge so the agent only retrieves relevant information.

Limit conversations in memory. When the agent uses the same conversation ID, the conversation history grows with each exchange and requires more tokens. Leaving the conversation ID blank significantly lowers token usage.

That last one is the single biggest cost lever in the product. If your agent doesn't genuinely need to remember previous exchanges, leave the field empty.

Agent ideas to steal

Make's own list of common builds:

• Customer support ticket triage: categorises, prioritises, and assigns tickets to team members.
• Sales outreach: identifies leads, researches them, schedules meetings, and sends email invitations.
• Content marketing: creates blogs and social content and posts them automatically.
• Market research analyst: gathers company information online, saves it to a database, and analyses it.
• Candidate screening: analyses resumes against job requirements and creates a qualification form for recruiters.
• SEO optimisation: analyses content and creates a report with recommendations.

Pre-built templates are available in the Make AI agents library.

The short version

Plan the job before you open the builder. Trigger the scenario, drop in the Run an agent module, and write instructions like a briefing document rather than a wish. Name every tool so precisely that the agent can't guess wrong. Put static reference material in knowledge and variable data in input. Start with a big model, prove it works, then scale down. Leave the conversation ID blank unless memory earns its cost.

And give the agent work you'd hand an intern. Not work you'd hand a lawyer.