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.
