4.1: Understanding Action Sequences
You've built a chatbot. You've added knowledge. You've customized its personality. Now let's talk about how all these pieces work together — and most importantly, how they happen automatically without you lifting a finger!
The big idea: Your agent follows a sequence of actions, just like following a recipe. Each step happens automatically when it's ready, in the right order, every single time.
💡 What You'll Learn
By the end of this section, you'll understand:
- ✅ Why action sequence matters (hint: you can't frost a cake before baking it!)
- ✅ How your agent processes each message step-by-step
- ✅ What "waiting" really means (and why it's a good thing)
- ✅ How automatic execution saves you time and prevents errors
4.1.1: The Cooking Analogy
Let's start with something familiar: baking a cake.
When you bake a cake, you can't just do things in any random order. Try adding frosting before baking, and you'll have a melted mess! Some steps must happen in sequence:
Baking a Cake: Steps Must Happen in Order
Just like following a recipe, your automation needs to do things in the right order. You can't frost a cake before it's baked!
Mix ingredients
Combine flour, sugar, eggs, butter
Pour into pan
Transfer batter to baking pan
Bake at 350°F for 30 minutes
Wait for it to cook through
Let cool completely
Must cool before frosting!
Add frosting
Only possible after cooling! ✨
❌ Can't skip steps: If you try to add frosting before baking, it will melt! Each step depends on the previous one finishing.
✅ Right order = success: When you follow the sequence, you get a perfect cake!
The same is true for your AI agent. It follows a sequence of actions:
- Receive the customer's question
- Search your knowledge base (if needed)
- Generate a helpful response
- Send it back to the customer
Just like with baking, you can't skip ahead. The agent can't generate a response before it knows what the question is!
💡 💡 Think of It Like This
Your automation is like an assembly line.
Each column is a workstation. Each row is an item moving through the line. The item can't move to the next workstation until the current one finishes its work.
Example:
- Station 1: Receive customer question → ✅ Done
- Station 2: Search knowledge → Waiting for Station 1 to finish...
- Station 3: Generate response → Waiting for Station 2 to finish...
- Station 4: Send to customer → Waiting for Station 3 to finish...
Everything flows smoothly, one step at a time!
4.1.2: How Your Agent Processes Messages
Let's watch your chatbot in action and see exactly what happens, step by step:
How Your Agent Processes Messages
Here's the sequence your chatbot follows for every customer message:
📥 Receive Message
Customer question arrives in your table
🔍 Search Knowledge (if needed)
AI looks through your documents for relevant information
✨ Generate Response
AI crafts a helpful answer using the knowledge it found
📤 Send to Customer
Response goes back to the customer instantly
The key insight: Each step waits for the previous one to complete. You can't generate a response before receiving the message, and you can't send a response before generating it!
What's happening here?
Each step waits for the previous step to complete:
- Step 2 can't start until Step 1 delivers the message
- Step 3 can't start until Step 2 finds the information
- Step 4 can't start until Step 3 creates the response
This is called a dependency chain. Each action depends on the previous one finishing.
💡 Why This Is Powerful
Automatic ordering means you never have to worry about:
- Running steps out of sequence
- Forgetting to run a step
- Using data before it's ready
- Manually clicking "run" for each action
It just works — every single time!
4.1.3: Understanding "Waiting"
When you look at your table, you might see cells with different statuses. Let's understand what each means:
Watching Actions Progress
Each cell shows its current status. Watch as it progresses automatically:
| Customer Question | AI Response | Send to Customer |
|---|---|---|
What are your business hours? Completed | — Ready | Waiting... Ready |
Waiting for input data
Scheduled to run
Processing now
Finished successfully
Automatic execution: Once all requirements are met, the action happens automatically. You don't need to click "run" or manually trigger anything!
What do these statuses mean?
Ready
The cell is waiting for its input data. Once the data arrives (from a previous column or from you), it automatically moves to the next state.
Think of it like: A chef standing by, ready to cook as soon as the ingredients arrive.
Queued
The cell has everything it needs and is scheduled to run. It's in line, waiting its turn.
Think of it like: Your order at a coffee shop — it's been placed, now waiting for the barista to make it.
Running
The action is actively processing right now! This might take a few seconds (for a quick lookup) or longer (for an AI-generated response).
Think of it like: The barista is actively making your coffee.
Completed
All done! The result is ready. The next column can now use this data.
Think of it like: Your coffee is ready — time to enjoy!
💡 Important: 'Waiting' Is Good!
Seeing "Ready" or "Queued" doesn't mean something is broken. It means the system is correctly waiting for what it needs.
Example:
- Your "AI Response" column shows "Ready" → Perfect! It's waiting for the customer question to arrive
- Customer types a question → "AI Response" changes to "Queued" → Then "Running" → Then "Completed"
This is exactly how it should work!
4.1.4: The Magic of Automatic Execution
Here's where TAIBLES really shines. You don't have to click "run" for each step.
Let's compare:
Automatic Execution: No Clicking Required!
❌ Other Tools (Manual)
✅ Uniki (Automatic)
Why Automatic Execution Matters:
Faster
No waiting for you to click buttons
Reliable
Never forget to run a step
Works 24/7
Runs even when you're asleep
Scalable
Handle hundreds of requests automatically
The difference is huge:
Other tools: You set up your automation, but then you have to manually trigger each step. Every. Single. Time.
- New lead comes in → Click "Run Step 1"
- Step 1 finishes → Click "Run Step 2"
- Step 2 finishes → Click "Run Step 3"
- And so on...
TAIBLES: You set up your automation once. Then it runs automatically forever.
- New lead comes in → Everything happens automatically
- You just check back later to see the results
- Or don't check at all — it's working 24/7 without you!
💡 Real-World Impact
Imagine you get 100 customer questions per day.
Without automatic execution:
- 100 questions × 4 steps each = 400 manual clicks
- At 5 seconds per click = 33 minutes of repetitive clicking
- Every. Single. Day.
With automatic execution:
- 100 questions × 0 clicks = 0 minutes
- You set it up once, it runs forever
- You can focus on important work while automation handles the repetitive stuff!
4.1.5: Putting It All Together
Let's review what you've learned:
1. Actions happen in sequence
- Just like following a recipe, each step happens in order
- You can't skip ahead or do things out of sequence
- This prevents errors and ensures reliable results
2. Each action waits for what it needs
- Columns wait for their input data to be ready
- "Waiting" statuses (Ready, Queued) are normal and good
- Once requirements are met, execution happens automatically
3. Automatic execution is the secret sauce
- No clicking "run" for each step
- Works 24/7, even when you're asleep
- Scales effortlessly to hundreds or thousands of items
- Saves hours of repetitive work
4. You stay in control
- See exactly what's happening with status indicators
- Understand why something is waiting
- Troubleshoot easily when needed
💡 🎯 Try This!
Test automatic execution yourself:
- Open your chatbot table from earlier tutorials
- Add a new row with a customer question
- Watch the status badges change automatically:
- Customer Question: Completed (you typed it)
- AI Response: Ready → Queued → Running → Completed
- (If you have a send column): Ready → Queued → Running → Completed
You didn't click anything! The system knew what to do and when to do it.
That's the power of action sequences!
What You've Learned
🎉 Congratulations! You now understand how your automations actually work under the hood.
Key takeaways:
- Sequence matters — just like baking a cake, you need to do things in the right order
- Dependencies create flow — each action waits for what it needs, then runs automatically
- Statuses tell the story — Ready, Queued, Running, Completed show you exactly what's happening
- Automation runs itself — once set up, it works 24/7 without manual clicking
What's next? In the next section, we'll learn about Required vs. Optional steps — how to make your automations flexible when some data might not always be available.
Previous: 3.6 Telegram IntegrationNext: 4.2 Required vs Optional Steps