from datetime import datetime, timedelta
class AgenticBot:
 def __init__(self):
 self.reminders = {}
 def set_reminder(self, user_id, task, deadline):
 self.reminders[user_id] = {
 'task': task,
 'deadline': deadline,
 'status': 'pending'
}
 return f"Agentic reminder: '{task}', deadline is {deadline}."
 def update_status(self, user_id, status):
 if user_id in self.reminders:
 self.reminders[user_id]['status'] = status
 if status == 'missed':
self.suggest_reschedule(user_id)
 def suggest_reschedule(self, user_id):
 task = self.reminders[user_id]['task']
 deadline_str = self.reminders[user_id]['deadline']
try:
 # For demo, pretend "Friday" is 3 days later
 deadline_date = datetime.now() + timedelta(days=3)
 new_deadline = deadline_date.strftime("%A")
 except Exception:
 new_deadline = "Next Monday"
 print(f"Task '{task}' was missed. Suggested new deadline: {new_deadline}")
 def proactive_check(self, user_id):
 if user_id in self.reminders:
 status = self.reminders[user_id]['status']
 if status == 'pending':
 print(f"Proactive check: '{self.reminders[user_id]['task']}' still needs attention by {self.reminders[user_id]['deadline']}.")
# Usage
if __name__ == "__main__":
 bot = AgenticBot()
 print(bot.set_reminder("user1", "Finish report", "Friday"))
 # Simulate a missed deadline
 bot.update_status("user1", "missed")
 # Proactive check before deadline
bot.proactive_check("user1")

from datetime import datetime, timedelta
class TrulyAgenticBot:
 def __init__(self):
 self.tasks = {} # user_id -> task info
 def decompose_goal(self, goal):
"""
 Simulated reasoning that decomposes a goal into subtasks.
 This mimics the thinking/planning of an agentic AI.
"""
 print(f"Decomposing goal: '{goal}' into subtasks.")
 if "report" in goal.lower():
 return [
 "Research topic",
 "Outline report",
 "Write draft",
 "Review draft",
 "Finalize and submit"
]
else:
 return ["Step 1", "Step 2", "Step 3"]
 def set_goal(self, user_id, goal, deadline_days):
 subtasks = self.decompose_goal(goal)
 deadline_date = datetime.now() + timedelta(days=deadline_days)
 self.tasks[user_id] = {
 "goal": goal,
 "subtasks": subtasks,
 "completed": [],
 "deadline": deadline_date,
 "status": "pending"
}
 print(f"Goal set for user '{user_id}': '{goal}' with {len(subtasks)} subtasks, deadline {deadline_date.strftime('%Y-%m-%d')}")
 def complete_subtask(self, user_id, subtask):
 if user_id not in self.tasks:
 print(f"No active tasks for user '{user_id}'.")
return
 task_info = self.tasks[user_id]
 if subtask in task_info["subtasks"]:
task_info["subtasks"].remove(subtask)
task_info["completed"].append(subtask)
 print(f"Subtask '{subtask}' completed.")
self.reflect_and_adapt(user_id)
else:
 print(f"Subtask '{subtask}' not in pending subtasks.")
 def reflect_and_adapt(self, user_id):
"""
 Agentic self-reflection: check subtasks and adjust plans.
 For example, add an extra review if the draft is completed.
"""
 task = self.tasks[user_id]
 if len(task["subtasks"]) == 0:
 task["status"] = "completed"
 print(f"Goal '{task['goal']}' completed successfully.")
else:
 # Example adaptation: if draft done but no review, add "Extra review" subtask
 if "Write draft" in task["completed"] and "Review draft" not in task["subtasks"] + task["completed"]:
 print("Reflecting: adding 'Extra review' subtask for better quality.")
 task["subtasks"].append("Extra review")
 print(f"{len(task['subtasks'])} subtasks remain for goal '{task['goal']}'.")
 def proactive_reminder(self, user_id):
 if user_id not in self.tasks:
 print("No tasks found.")
return
 task = self.tasks[user_id]
 if task["status"] == "completed":
 print(f"User '{user_id}' task is complete, no reminders needed.")
return
 days_left = (task["deadline"] - datetime.now()).days
 print(f"Reminder for user '{user_id}': {days_left} day(s) left to complete the goal '{task['goal']}'")
 print(f"Pending subtasks: {task['subtasks']}")
 if days_left <= 1:
 print("?? Urgent: Deadline approaching!")
 def suggest_reschedule(self, user_id, extra_days=3):
"""
 Automatically suggests rescheduling if the task is overdue or needs more time.
"""
 task = self.tasks.get(user_id)
 if not task:
 print("No task found to reschedule.")
return
 new_deadline = task["deadline"] + timedelta(days=extra_days)
 print(f"Suggesting new deadline for '{task['goal']}': {new_deadline.strftime('%Y-%m-%d')}")
 task["deadline"] = new_deadline
# Demo usage to compare in your blog:
if __name__ == "__main__":
 agentic_bot = TrulyAgenticBot()
 # Step 1: Set user goal with deadline in 5 days
 agentic_bot.set_goal("user1", "Finish quarterly report", 5)
 # Step 2: Complete subtasks iteratively
 agentic_bot.complete_subtask("user1", "Research topic")
 agentic_bot.complete_subtask("user1", "Outline report")
 # Step 3: Proactive reminder before deadline
agentic_bot.proactive_reminder("user1")
 # Step 4: Complete more subtasks
 agentic_bot.complete_subtask("user1", "Write draft")
 # Step 5: Reflect adds an extra review subtask
 agentic_bot.complete_subtask("user1", "Review draft")
 # Step 6: Complete added subtask
 agentic_bot.complete_subtask("user1", "Extra review")
 agentic_bot.complete_subtask("user1", "Finalize and submit")
 # Step 7: Final proactive reminder (task should be completed)
agentic_bot.proactive_reminder("user1")
 # Bonus: Suggest rescheduling if user needed extra time
agentic_bot.suggest_reschedule("user1", extra_days=2)