How to Build Conditional AI Chatbot Responses Based on CRM Properties
Learn how to configure your AI chatbot to only respond to specific customers based on CRM properties like product type, subscription tier, or custom fields.
Building Smart AI Chatbot Delay Logic: How to Wait Before Responding
Implement intelligent delay and interrupt logic in your AI chatbot so it waits for human responses before replying. Step-by-step Make automation guide.
TABLE OF CONTENTS
AI chatbots that respond instantly create a problem: they often reply before a human agent has a chance to jump in. This leads to duplicate responses, confused customers, and wasted AI costs.
The solution is wait-and-check logic that gives your team a window to respond manually before the AI takes over. (In this example, we use Make.)
The Problem with Instant AI Responses
When a customer texts your business number, most AI chatbot setups trigger immediately:
- Message arrives
- AI generates response
- Response sends automatically
But what if someone on your team is already typing a reply? Now the customer gets two responses, and your team member's effort is wasted.
The Wait-Before-Respond Pattern
A better approach introduces a delay with interrupt capability:
- Message arrives
- Wait 45 seconds (or your preferred window)
- Check if a human already replied
- If no human response, AI responds
- If human responded, AI skips its turn
This gives your team first dibs while maintaining AI backup coverage.
Building This in Make
Here's how to implement this using Make automation:
Module 1: Receive Incoming Message
Set up a webhook or watch trigger for new messages in your platform (SMS, Slack, WhatsApp, etc.).
Capture:
- Message content
- Sender identifier
- Conversation thread ID
- Timestamp
Module 2: Sleep Function
Add a Sleep module to pause execution:
Delay: 45 seconds
During this window, your team can respond manually.
Important: Whether Make's Sleep module counts as an operation depends on your plan — check your Make plan details, as billing models vary.
Module 3: Check for Human Response
After the sleep, query your messaging platform's API:
Get Messages Since: original.timestamp In Thread: original.thread_id From: [Your team member IDs]
You're looking for any reply sent by a human during the 45-second window.
Module 4: Router with Condition
Use a Router module to split logic:
Path A (Human responded):
- Condition: Message count > 0
- Action: End scenario (no AI response needed)
Path B (No human response):
- Condition: Message count = 0
- Action: Continue to AI response modules
Module 5: Generate and Send AI Response
Only executes if Path B triggered:
- Call OpenAI or your LLM API with the message and context
- Send the AI-generated response
- Log the interaction
Choosing the Right Wait Time
The 45-second window is a starting point. Consider:
- 15-30 seconds: High-urgency sales or support
- 45-60 seconds: Standard business inquiries
- 90+ seconds: Complex questions where human context matters
- Business hours vs. off-hours: Use different delays based on time of day
Advanced: Multi-Check Pattern
For even better coverage, implement multiple checks:
- Wait 15 seconds → check for human response
- If no response, wait another 30 seconds → check again
- If still no response, AI responds
This gives fast-responding agents priority while still covering slower periods.
Handling Edge Cases
What if a human starts typing but hasn't sent yet?
Some platforms expose "is typing" indicators via API. Add a check:
If typing_indicator = true: Wait additional 30 seconds
What if the customer sends multiple messages during the wait?
Reset the timer with each new message:
Latest message timestamp: most_recent.timestamp Wait from: Latest timestamp
What if two AI scenarios trigger simultaneously?
Implement a response lock:
- Before responding, write a flag to your database
- Check for existing flags before generating responses
- Clear flags after sending or timing out
Testing Your Delay Logic
Test 1: Human responds quickly (within 10 seconds)
- Expected: AI does not respond
Test 2: No human response during window
- Expected: AI responds after delay
Test 3: Human responds at 44 seconds (just before cutoff)
- Expected: AI does not respond
Test 4: Human responds at 46 seconds (just after cutoff)
- Expected: Both human and AI respond (acceptable edge case)
Beyond Simple Delays
Once your basic interrupt logic works, enhance it:
- Priority routing: VIP customers get longer wait times for human attention
- Category detection: Technical questions wait longer, simple FAQs respond faster
- Team availability check: Shorter delays during business hours, longer after hours
- Response complexity: Complex questions get flagged for human review instead of AI
Cost and Performance Considerations
This pattern adds minimal overhead:
- Sleep functions are free in most automation platforms
- One additional API call to check for responses
- Slight delay in response time (by design)
The tradeoff: Slightly slower AI responses in exchange for zero duplicate responses and better human takeover.
Get Help Building Chatbot Delay Logic
Setting up wait-before-respond logic in Make takes about an hour once you know the pattern — but the edge cases (typing indicators, simultaneous triggers, multi-message threads) can add up. Connex Digital builds these automations for businesses that need them done right the first time.
Book a free call to walk through your messaging platform and we'll show you how to implement delay and interrupt logic for your specific setup.
Related Posts
How to Track Investor Preferences in Commercial Real Estate: A Notion + CRM Solution
Learn how to build a Notion CRM for investor tracking in commercial real estate, capturing preferences and using AI-assisted deal matching with a simple four-table system.
How to Build a Notion Custom Agent for Daily Team Briefings
Learn how to build a Notion custom agent that delivers personalized daily briefings to your team — pulling calendar events, tasks, and meeting context automatically.
