AI Workflow With Make: Connect Inputs, Models, and Checks

Make (formerly Integromat) is a visual automation platform where you connect apps in a scenario: a trigger fires, data passes through a series of modules, and the result lands in a destination. Adding an AI step — a call to an AI model that transforms or classifies the data — follows the same pattern. The challenge is making that AI step reliable: clear inputs, predictable outputs, and a way to catch errors before they reach a live system.

The workflow itself lives in Make, but the requirements that define what the workflow should do belong somewhere people can read and change them. Tools like fenbs hold the shared requirements and the work history outside the scenario so any team member or AI app knows the current intention rather than reverse-engineering it from the modules.

Structure the trigger and inputs clearly

A Make scenario starts with a trigger: a new row in a spreadsheet, a form submission, a webhook, an email arrival, a new item in a project tool. The trigger determines what data is available to the rest of the scenario. Before adding an AI module, map what the trigger provides and what the AI step actually needs.

Mismatched inputs are the most common source of AI workflow failures. If the AI module expects a product description but the trigger provides only a product ID, the AI receives an ID and produces irrelevant output. Confirm the input shape before you build the AI step.

• Name every field the AI module will use. Avoid passing the entire trigger payload if only two fields matter.
• Add a text formatter or transformer before the AI module to normalize inconsistent inputs (trim whitespace, handle empty fields).
• Set explicit fallback values for optional fields rather than letting the AI receive an empty string or null.

Write the prompt as a module parameter

Make's AI modules (including the OpenAI and Anthropic modules) accept a prompt you write in the module configuration. Treat that prompt the same way you treat any system instruction: write it clearly, test it with representative inputs, and record the version you are using along with the reason for any change.

A prompt that mixes the task description with data often produces worse results than one that separates them. Put the task instruction in a fixed part of the prompt and the variable data in a clearly labeled slot. For example: "Classify the following support message as billing, technical, or general. Message: {{message_text}}".

Make does not version your prompts. If you change the prompt in a live scenario and the output gets worse, you will want the previous version. Keep the prompt text in your project notes alongside the reason for the change.

Choose the right model for the task

Different AI tasks need different models. A short classification task (billing or not billing?) needs a faster, cheaper model. A task that summarizes a long document, generates a structured report, or requires reasoning across multiple inputs may need a more capable one. Check the documentation for the AI provider you are using in Make for current model options and their tradeoffs.

Choosing a more capable model for every step increases cost and latency without improving reliability if the task does not need it. Start with the smallest model that handles the task correctly in testing, and move up only when the output quality is insufficient.

Add error handling and fallback paths

An AI API call can fail: the service is temporarily unavailable, the input exceeds the model's context window, or the response is malformed. Make supports error handling at the module level. Add an error route to your AI module so a failure produces a known outcome rather than silently dropping the item.

Useful fallback paths include: writing the failed item to an error log, sending a notification to a team channel, or queuing the item for manual review. Do not let a failed AI step update a live record with partial data. Add a conditional check after the AI module that confirms the output has the expected shape before passing it forward.

Make's built-in error handling uses the Break, Resume, Rollback and Ignore directives. Check Make's own documentation↗ (opens in a new tab) for how each one behaves before you choose. The right choice depends on whether later modules depend on the AI output.

Add a review step before live updates

For any AI output that updates a live system — sends an email, updates a CRM record, posts to a channel — add a review step in the scenario until you have enough confidence in the output quality to remove it. A review step can be a Make filter that only passes outputs matching a confidence threshold, or a module that writes to a staging table for a person to approve.

Record when and why you removed a review step. "We removed manual review after 200 consecutive correct classifications over two weeks" is a defensible decision. "We removed it because the scenario was working" is not.

How to do this with fenbs

1. Create a free account. Add a project for the automation work with a description of the workflow's purpose and the systems it connects.
2. Add tasks for each workflow component: trigger design, AI step, error handling, and review process.
3. Record the prompt text and model choice as a decision in Decisions and rules each time they change.
4. Connect your AI app over MCP from Integrations. Ask it to read the project context and requirements before each build session.
5. After each test run, save progress: what is working, what failed, what was changed, and the next step.

When to keep a human in the loop

Automation removes manual steps. That is its value. It also removes the moment when a person would have noticed that an output was wrong. For outputs that are hard to reverse — sent emails, closed tickets, updated customer records — keep a human check until you have measured the error rate and decided it is acceptable. Record that decision explicitly rather than letting the check slip out without discussion.

The AI agent approval workflow guide covers the broader question of when and how to build review steps into AI-driven processes.