Make_AI_agents.md

In your first Make scenario, you decided everything in advance: every article went through the router, into the sheet, through the LLM and into Notion. Every article took the same path.

Today you rebuild that scenario with an AI agent. You don't draw the paths anymore. You describe the goal, hand the agent some tools, and it decides what to do with each article:

• Is this article new, or did I already log it?
• Is it relevant for the blog, or not?
• Is it worth a blog idea in Notion?

Before:  RSS -> Router -+-> Google Sheets (every article)
                        +-> LLM -> Notion (every article)

After:   RSS -> AI agent ··· tools it can choose from:
                          ├─ Check if article is already logged (Google Sheets)
                          ├─ Log article (Google Sheets)
                          └─ Save blog idea (Notion)

• New parts use things you haven't seen yet. They come step by step.
• Known parts use things you did in your first scenario. You get the goal and a few hints.
• Checkpoint: what you should see before you move on.
• Stuck? Quick fixes for the usual problems.

Save your scenario often (Ctrl/Cmd + S).

Make's AI agents are still in beta and change regularly. If a button or label looks a bit different from what's described here, look for the closest match.

1. Prepare your sheet and scenario (Known)
2. Add the agent and write its instructions (New)
3. First test: an agent without tools (New)
4. Give the agent its tools (New)
5. Test in the chat (New)
6. Run it on the real feed (Known + New)
7. Experiments: see how the agent reacts
8. Choose your path
9. Reflection

Parts 1–6 are the core. Parts 7 and 8 are for exploring and going further. Take the time you need.

This table sums up what today is about.

	Your first scenario	With an agent
Who decides what happens	You, while building it	The AI, while it runs, for each article
How you tell it what to do	Modules, router, mapping	Instructions in plain language, plus tools
Every article…	takes the same path	can take a different path
Module fields	You map every field	You fix some fields, the AI fills the others
Testing	Run once, look at the bubbles	Chat with the agent, Run once, read the Reasoning
Same input twice	Always the same path (only the AI text may vary)	The path itself can change too
Good for	Fixed rules that never change	Decisions that need judgment

Word	What it means
Instructions	The agent's job description: role, steps, rules. Same for every run.
Input	The task for this run, e.g. one article.
Tool	A module the agent is allowed to use. It decides if and when.
Tool description	Tells the agent what a tool does and when to use it. The agent reads it to make its decisions, so write it clearly.
Let AI agent decide	A field the agent fills in itself while it runs.
Reasoning	The agent's log: what it thought, which tools it called, and why.

• On the free plan, agents only run on Make's AI Provider . You can't use your Gemini or Groq key here.

• Every agent run costs credits: 1 per operation, 1 per tool call, plus credits for the AI's tokens.

• Testing in the chat costs credits as well. And the agent uses its tools for real there: if it calls "Log article", a new row appears in your sheet.

• Keep runs small: 1 article while building, 3 at most when testing.

• You can see how many credits you have left on your organization's dashboard (left sidebar > Organization ).

• Logged in to Make

• Your first scenario still exists, but it's switched off in the scenario list. On the free plan, only 2 scenarios can be active at once.

• Your Google Sheet and Notion database still exist. The agent reuses your Google and Notion connections, so there's nothing new to connect.

• Your blog topic in one sentence, e.g. "Tech news explained for beginners", or anything that fits your RSS feed

Goal: a fresh place for the agent to log articles, and a copy of your scenario to rebuild.

The sheet

Hints:

• In your Blog inspiration spreadsheet, duplicate your tab: right-click the tab at the bottom >Duplicate . Rename the copyAgent log .
• In Agent log , delete all rows except the header row: select the rows by their numbers on the left, right-click >Delete rows .
• Add two new headers in the next free columns: Relevant andReason .

Your headers now look like this (plus Date, if you had it): Title | Description | Link | Relevant | Reason

Why a fresh tab? The agent will check the log for duplicates. Old rows from your first scenario would make every article look "already logged".

The scenario

Hints:

• In the Scenarios list, open the three-dot menu next to your first scenario andClone it. Name the copyContent curator (agent) .
• Open the clone and delete everything after the RSS module: router, Google Sheets, LLM, Notion. Right-click each one >Delete module . Only RSS stays.
• In the RSS module, set Maximum number of returned items to1 .

Checkpoint: a scenario with just the RSS module, and a sheet tab Agent log with 5 headers and no data.

Goal: an agent that knows what its job is. It can't do anything yet. That comes in Part 4.

Add the agent

1. Click the + on the right of the RSS module.
2. Search Make AI Agent . ChooseMake AI Agent (New) >Run an agent .

• You might also see an older app called Make AI Agents (plural). Don't use that one.

3. You might also see an older app called
4. Connection: chooseMake's AI Provider . If you have to create a connection first, clickAdd and pick Make's AI Provider. No API key needed.
5. Model: the model names start with Small, Medium or Large. Pick one that starts withMedium .

• Large models are smarter but use about 5 times more credits per token. Start with Medium, and only switch to a larger model if the agent doesn't do what you expect.

Write the instructions

Instructions are the agent's job description. They're the same for every article. Good instructions have five parts: role, input, tools, workflow and rules.

1. Copy this into Instructions . Replace[YOUR BLOG TOPIC] with your topic:

You are the content curator for a blog about [YOUR BLOG TOPIC].
You get one article from a news feed at a time and decide what to do with it.

Each task contains an article's title, summary and URL.

- Check if article is already logged: searches the article log by URL.
- Log article: adds one article to the article log.
- Save blog idea: saves a blog post idea to the Notion idea database.

1. Use "Check if article is already logged" with the article's URL.
2. If a row comes back, the article was already processed. Stop and reply: "Duplicate, skipped."
3. Decide if the article is relevant for the blog. Relevant means: our readers would want a blog post inspired by it.
4. Use "Log article" to log it. Set Relevant to "yes" or "no", and give a one-sentence reason.
5. Only if it's relevant: write ONE blog post idea (a catchy headline plus a 2-sentence outline) and use "Save blog idea".
6. End with one short line that says what you did.

- Never save an idea for an article that isn't relevant.
- Never log the same URL twice.
- If the summary is too short to judge, decide based on the title and say so in the reason.
- Plain text only, no markdown.

Note: the tool names in the instructions must match the tool names you'll create in Part 4 exactly. That's how the agent connects "use Log article" to the right tool.

Map the input

The input is the task for this one run: the article.

1. In Input , type the labels and map the RSS fields, like you did in your first scenario:

Article title: [RSS Title]
Article summary: [stripHTML(RSS Description)]
Article URL: [RSS URL]

UsestripHTML() from the text functions, just like before. 2. Leave Conversation ID empty. The agent then starts fresh for every article, without memory of earlier ones. That's what we want here, and it also saves credits. 3. Leave all other settings as they are. 4. Click Save in the module, then save the scenario.

Checkpoint: the agent module is on the canvas after RSS, with instructions and an input.

Goal: see what an agent does when it knows its job but can't act.

1. Click Run once .
2. Click the agent's bubble and open the output. Find Response .
3. Click the agent module. After a run, you'll find a Reasoning tab there. Open it.

What you'll probably see: the agent explains what it would do, maybe even writes a blog idea. It might even claim it logged the article. But check your sheet and Notion: nothing's there.

This is worth remembering: an agent can say it did something without having done it. Always check the actual result, and the Reasoning.

Why: without tools, an agent is basically a chatbot. It can think and write, but it can't change anything outside itself. The tools are what let it actually do things.

Checkpoint: a response in the output, nothing in the sheet, and you've looked at the Reasoning tab once.

Goal: three tools the agent can choose from.

How tools work:

• A tool is a normal Make module, like the ones you already know. The difference: the agent decides if andwhen to run it.
• Name and description: the agent reads these to decide which tool to use, so make them clear and specific.
• Fixed fields vs. AI fields: some fields are always the same, like which spreadsheet. You set those yourself. Others depend on the article, like the title. For those, you chooseLet AI agent decide , and the agent fills them in while it runs.

How to add a tool: hover over the agent module and click the + that appears, then Add tool. Or open the agent and click Add tool. Then choose the app and module.

1. Add tool >Google Sheets >Search Rows .
2. Name:Check if article is already logged
3. Description:

Searches the article log for a URL. Use it first for every article. If it returns a row, the article was already processed. If it returns nothing, the article is new.

4. Connection: your existing Google connection.
5. Spreadsheet:Blog inspiration .** Sheet Name:Agent log . Table contains headers:** Yes.
6. Filter: columnLink (it may be shown by its letter, e.g.C ), operatorEqual to , value:Let AI agent decide .
7. Limit:1
8. Save the tool.

Fixed vs. AI here: the spreadsheet, sheet and column never change, so you set them yourself. Only the URL to search for comes from the agent.

1. Add tool >Google Sheets >Add a Row .
2. Name:Log article
3. Description:

Adds one article to the article log. Use it once per new article, after you have decided if it is relevant.

4. Same spreadsheet and Agent log sheet as tool 1.Table contains headers: Yes.
5. For all five columns (Title ,Description ,Link ,Relevant ,Reason ):Let AI agent decide . Have aDate column too? Let the agent decide that one as well, or leave it empty.
6. Optional: for Relevant , clickAdd details (if available) and typeOnly "yes" or "no".
7. Save the tool.

Why "Let AI agent decide" for everything? Only the agent knows Relevant and Reason. And it already has the title, summary and URL from the input.

1. Add tool >Notion >Create a Data Source Item .
2. Name:Save blog idea
3. Description:

Saves a blog post idea to the Notion idea database. Only use it for relevant articles, after logging them.

4. Connection: your existing Notion connection.
5. Data Source ID: clickID Finder and pick yourBlog ideas database. It's the same for every article, so you set it yourself.
6. For Name ,Blog post idea ,Source URL andSource summary :Let AI agent decide .
7. Save the tool.

Checkpoint: three tools connected to the agent, with exactly the names from the instructions. Save the scenario.

Stuck?

• Tool names don't match: compare them letter by letter with the# Tools section of your instructions.
• Notion database not in the ID Finder: same fix as in your first scenario. The database must be shared with your Notion connection.
• Error about the active scenarios limit: the free plan allows 2 active scenarios. Switch off all other scenarios in your scenario list.
• No "Let AI agent decide" option for the filter value in tool 1: remove the filter and setLimit to100 instead. Change the description to:Returns all logged articles. Check if the article's URL is among them. Use it first for every article. The agent then checks the list itself.

Goal: check the agent's decisions before running it on the real feed.

The chat lets you send the agent a task by hand, without running the scenario. Keep in mind that the agent uses its tools for real here, so your tests create actual rows in your sheet and items in Notion.

1. Right-click the agent module > Chat with agent . Or hover >+ >Chat .
2. Get a real article to test with:

• Set the RSS module to 5 items, right-click it > Run this module only . This doesn't start the agent.
• Click the RSS bubble and pick an article that fits your blog. Copy its title, description and URL into a note.
• Set the RSS module back to 1 item.

3. Set the RSS module to 5 items, right-click it >
4. Test 1, a relevant article: send

Article title: [paste the title]
Article summary: [paste the summary]
Article URL: [paste the URL]

Watch which tools it calls. Check your sheet and Notion. 5. Test 2, a duplicate: start a new chat if there's a button for it, then sendexactly the same message again. The agent should find the URL in the sheet and skip it.

• Why a new chat? In the same chat, the agent might just remember the article instead of checking the sheet. Then you're not really testing the tool.

6. Test 3, an irrelevant article: send a made-up one that doesn't fit your blog at all, e.g.:

Article title: Local bakery wins award for the biggest pretzel
Article summary: A bakery in Hannover baked a 3-meter pretzel for the city festival.
Article URL: https://example.com/pretzel

It should be logged withRelevant: no , and nothing should go to Notion.

Checkpoint:

Test	Sheet	Notion
1. Relevant	new row, yes	new idea
2. Duplicate	nothing new	nothing new
3. Irrelevant	new row, no	nothing new

Stuck?

• The agent skips a tool: make the tool description clearer, and check that the workflow in the instructions names it exactly.
• It logs duplicates anyway: check the filter in tool 1. The column must beLink , and the value must be set toLet AI agent decide .
• It saves ideas for irrelevant articles: make your blog topic more specific in the instructions.

Goal: let the agent work on real articles from your feed, just like your old scenario did.

1. Delete the test rows in Agent log (keep the header) and the test ideas in Notion.
2. Click Run once . With 1 RSS item, the agent runs once.
3. Open the Reasoning tab and read through it step by step:

• Which tool did it call first?
• Why did it decide the article is relevant or not?

4. Set RSS to 3 items.Run once again.

• Like any other module, the agent runs once per bundle, so this means 3 separate agent runs.

5. Run once one more time, without changing anything.

Checkpoint: on the last run, all articles are skipped as duplicates. Your old scenario couldn't do that: it added the same articles again on every run.

If your feed published a new article in the meantime, that one gets processed. That's correct.

Compare old and new. Fill this in for yourself:

Question	Old scenario	Agent
How many articles ended up in Notion?
Did duplicates get caught?
How many credits did one run use? (open each scenario > History )
How easy was it to see why something happened?

Agents behave differently from normal modules. The best way to understand them is to change one thing and watch what happens.

• Use RSS with 1 item for these.
• Before each experiment, delete the rows in Agent log . Otherwise the agent skips the article as a duplicate.

Pick at least three:

1. Change the topic. Change[YOUR BLOG TOPIC] to something very different. Run the same article. Does the decision flip?
2. Weaken a tool description. Change tool 1's description to justSearches the sheet. Delete the log rows and run twice. Does it still check for duplicates?
3. Remove a rule. Delete "Never save an idea for an article that isn't relevant." Test with the pretzel article in the chat. What happens?
4. Same input, three times. Delete the log rows between runs and run the same article 3 times. Is the decision always the same? Is the blog idea?
5. Count the steps. In the agent's output, openMetadata >Execution steps . How many steps did one article take? How many tokens?
6. Change the model. Try a Small and a Large model on the same article. Compare quality and tokens.

After each experiment, undo the change.

What to take away:

• With an agent, your instructions are the logic. The vaguer they are, the less predictable the agent becomes.
• Tool descriptions matter as much as the instructions.
• The same input doesn't always give exactly the same result.

Pick one or more.

Path A: Hybrid: the agent decides, the scenario acts

Agents are good at judging, and normal modules are good at doing the same thing reliably. Combine them:

• Clone your agent scenario.
• Remove the Save blog idea tool.
• In the agent, set Response format toData structure with two items:relevant (Boolean) andblogIdea (Text).
• Update the instructions:
  • Remove Save blog idea from the# Tools section.
  • Replace workflow step 5 with: Return relevant (true or false) and blogIdea (a catchy headline plus a 2-sentence outline, empty if not relevant).
• Remove
• After the agent, add a normal Notion module,Create a Data Source Item . MapName ,Source URL andSource summary from the RSS module, andBlog post idea from the agent'sblogIdea .
• Click the connection line between the agent and Notion and set up a filter :relevant ,Boolean operators >Equal to ,true .
• Think about it: what got more reliable? What got less flexible? How did the credits change?

Path B: Give the agent knowledge

• Write a short style guide: who your readers are, your tone, topics you never cover, examples of good headlines. Google Docs works fine: download it as PDF or .docx .
• Hover over the agent > + >Knowledge > upload the file. Up costs a few credits.
• Add to the instructions: "Follow the blog style guide in your knowledge when writing blog ideas."
• Compare blog ideas before and after.

Path C: Stricter guardrails

Add rules to the instructions and test whether the agent follows them:

• "Never save more than one idea per article."
• "Mark articles as not relevant if they are mainly advertising."
• "If you're unsure whether an article is relevant, log it as not relevant and start the reason with UNSURE."

Make up a test article for each rule and send it in the chat.

Path D: Second opinion

Write your instructions with AI's help. Give ChatGPT, Claude or Gemini your current instructions plus the Reasoning of a run that went wrong, and ask: "Improve these instructions so this doesn't happen again." Test the result. Make itself recommends this way of improving agents.

1. In your first scenario, where were the decisions made? And where are they made now?
2. Name one task where you would not use an agent. Why? Think of cost, predictability and rules that must never break.
3. The agent decided differently on the same article. Is that a problem or a feature? How can you make it more consistent?
4. In a normal scenario, you map fields. What's the agent's version of mapping?
5. Which was cheaper per article, the old scenario or the agent? Is the difference worth it?

Coming up: you'll meet agents again in n8n.

Problem	Fix
"Run an agent" not found	Search Make AI Agent and choose the app with**(New)**
No Gemini/Groq connection possible	Free plan: agents only run on Make's AI Provider
Agent answers but nothing happens	No tools yet, or the tool names don't match the instructions
Agent says it logged the article, but the sheet is empty	It didn't actually call the tool. Check the Reasoning, then the tool names and descriptions.
In the chat, the agent skips the sheet check	It remembers the article from the chat. Start a new chat.
Error about the active scenarios limit	Free plan: max. 2 active scenarios. Switch off the others.
Every article is "duplicate"	Old rows in Agent log . Delete them, keep the header.
Duplicates aren't caught	Tool 1's filter: column Link , value set toLet AI agent decide
Ideas saved for irrelevant articles	Make the blog topic and the "relevant" rule more specific
Sheet fields filled in strangely	Add more detail to the tool description, or use Add details on the field
Notion error	Check the property types: Source URL must be a URL, andName must not be empty
Credits going fast	1 RSS item while testing, Medium model, no unnecessary chat tests
A button looks different than described	Open beta: look for the closest match, or ask your instructor

source & further reading

gist.github.com — original article ML trading example Disabling FaceTime HD camera post-processing on macOS Hermes architecture: a 10-minute tour (as of 2026-10-17)