How to Combine AI Agents With Rule-Based Automation in Make

A practical field guide from Automation Ace.

Short answer: combine AI agents with rule-based automation in Make by putting rules around the agent and the agent inside the flow: scenarios handle triggers, validation, deduplication, routing on known fields, writes, approvals, and logging; the agent (or an AI module) handles the judgment, such as understanding free text and choosing next steps, and returns structured output that the rules act on.

Short answer

• Rules before the agent: filter, validate, deduplicate.
• Agent in the middle: judge and return JSON.
• Rules after the agent: validate output, route, act, log, approve.

Why combine them

• Reliability: deterministic steps behave the same every time.
• Cost: AI runs only where judgment is needed.
• Safety: writes go through narrow, validated tools.
• Debuggability: you can see exactly where a decision was made.

For the decision of which to use, see Make AI agents vs scenarios.

Who does what

The core pattern: rules around, AI inside

1. Gate: rules decide whether the agent should run at all.
2. Prepare: rules gather and trim the data the agent needs.
3. Judge: the agent decides and returns structured output.
4. Check: rules validate the output and confidence.
5. Act: rules route and perform actions through tools.
6. Record: rules log, alert, and handle errors.

Example: inbound support email

Scenario: Inbound support email (rules + agent)

[Rules]  Trigger: new email in support@
[Rules]  Filter: skip auto-replies and known spam senders
[Rules]  Search data store: already processed this message ID? -> stop
[AI]     Run an agent "Support Triage" with: subject, body, sender
         -> returns JSON {topic, priority, order_id, summary, needs_human}
[Rules]  Validate JSON; if invalid -> send to review queue
[Rules]  Router:
           needs_human = true  -> create ticket in Escalations + Slack alert
           topic = shipping    -> lookup order, create ticket, draft reply
           topic = billing     -> create ticket for Billing team
           fallback            -> General queue
[Rules]  Log run: message ID, topic, outcome, credits
[Rules]  Error handler: log + alert, keep message in review queue

For the agent itself, see how to build AI agents in Make.

Techniques that make hybrids reliable

• Structured output: ask for JSON with fixed fields and allowed values.
• Confidence and “needs human” flags that routes can act on.
• Scenario tools with validation instead of raw write modules; see agent access and permissions.
• Idempotency: store processed IDs; see reprocessing without duplicates.
• Error handlers around the agent call; see Make error handling.
• Iterators and aggregators for lists the agent returns; see iterators and aggregators.

Approvals in the flow

Put a person between the agent's decision and any risky action: refunds, customer messages on sensitive topics, deletions. Make highlighted human-in-the-loop approvals at Waves '26; a scenario-based approval request also works. See approval workflow automation.

Evolve over time

• Start with the agent in “suggest” mode while rules and people act.
• Measure agreement; let high-confidence cases act automatically.
• Move patterns that become predictable back into rules: cheaper and more reliable.
• Monitor everything; see monitoring AI agents in Make.

The same principle applies on any platform; see where workflows and agents fit in an automation stack.

Frequently asked questions

How do I combine AI agents with rule-based automation in Make?

Put rules around the agent and the agent inside the flow: scenarios handle triggers, validation, deduplication, routing, writes, approvals, and logging, while the agent or an AI module handles judgment and returns structured output for the rules to act on.

What should an AI agent do versus a scenario module in Make?

Agents and AI modules should understand free text, choose among many next steps, and draft messages. Scenario modules should handle triggers, validation, deduplication, routing on known fields, writes through narrow tools, approvals, and logging.

How do I make hybrid AI automations reliable?

Request structured JSON with fixed fields, include confidence and needs-human flags, use scenario tools with validation, store processed IDs for idempotency, add error handlers around agent calls, and log every run.

Where should approvals go in a hybrid automation?

Between the agent’s decision and any risky action, such as refunds, sensitive customer messages, or deletions, using an approval step or a scenario-based approval request.

Should hybrid automations move more work to AI over time?

Sometimes, but also the reverse: let high-confidence cases act automatically once agreement is proven, and move patterns that become predictable back into rules, which are cheaper and more reliable.