Personal assistant agent patterns in Agentic AI

Introduction

Personal assistant agent patterns help design smart helpers that understand and assist with daily tasks easily.

When building a chatbot that schedules meetings for you.

When creating a voice assistant that answers questions and controls smart devices.

When automating reminders and to-do lists based on your habits.

When designing an app that helps manage emails and messages automatically.

When developing a system that learns your preferences to suggest actions.

Syntax

Agentic AI

class PersonalAssistantAgent:
    def __init__(self, skills):
        self.skills = skills

    def listen(self, user_input):
        # Understand user request
        pass

    def decide(self, parsed_input):
        # Choose the right skill to use
        pass

    def act(self, decision):
        # Perform the action
        pass

    def run(self, user_input):
        parsed = self.listen(user_input)
        decision = self.decide(parsed)
        return self.act(decision)

This pattern splits the assistant's work into listening, deciding, and acting steps.

Skills are small modules that handle specific tasks like setting reminders or answering questions.

Examples

Create an assistant with skills to manage calendar, check weather, and handle emails.

Agentic AI

skills = ['calendar', 'weather', 'email']
agent = PersonalAssistantAgent(skills)

A simple listen method that breaks user input into words for easier understanding.

Agentic AI

def listen(self, user_input):
    return user_input.lower().split()

Decide which skill to use based on keywords in the user's request.

Agentic AI

def decide(self, parsed_input):
    if 'meeting' in parsed_input:
        return 'calendar'
    elif 'weather' in parsed_input:
        return 'weather'
    else:
        return 'default'

Perform the action based on the chosen skill.

Agentic AI

def act(self, decision):
    if decision == 'calendar':
        return 'Scheduling your meeting.'
    elif decision == 'weather':
        return 'Fetching weather info.'
    else:
        return 'Sorry, I cannot help with that.'

Sample Model

This program creates a simple personal assistant that listens to user input, decides which skill to use, and acts accordingly.

Agentic AI

class PersonalAssistantAgent:
    def __init__(self, skills):
        self.skills = skills

    def listen(self, user_input):
        return user_input.lower().split()

    def decide(self, parsed_input):
        if 'meeting' in parsed_input:
            return 'calendar'
        elif 'weather' in parsed_input:
            return 'weather'
        else:
            return 'default'

    def act(self, decision):
        if decision == 'calendar':
            return 'Scheduling your meeting.'
        elif decision == 'weather':
            return 'Fetching weather info.'
        else:
            return 'Sorry, I cannot help with that.'

    def run(self, user_input):
        parsed = self.listen(user_input)
        decision = self.decide(parsed)
        return self.act(decision)

agent = PersonalAssistantAgent(['calendar', 'weather'])

print(agent.run('Can you set a meeting for tomorrow?'))
print(agent.run('What is the weather today?'))
print(agent.run('Play some music'))

Important Notes

Start simple: build small skills and add more as you go.

Use clear keywords to decide which skill to activate.

Keep the listening, deciding, and acting steps separate for easier debugging.

Summary

Personal assistant agents work by listening, deciding, and acting.

Skills are small task helpers inside the assistant.

This pattern helps build smart helpers for daily tasks.

Practice

1. What is the main role of a personal assistant agent in AI?

easy

A. To listen, decide, and act on user requests

B. To store large amounts of data

C. To create new programming languages

D. To replace human emotions

Solution

1. Step 1: Understand the agent's purpose

   Personal assistant agents are designed to help users by understanding their needs.

2. Step 2: Identify key functions

   They listen to commands, decide what to do, and then act accordingly.

3. Final Answer:

   To listen, decide, and act on user requests -> Option A

4. Quick Check:

   Agent role = Listen, decide, act [OK]

Hint: Remember: assistant agents always listen and act [OK]

Common Mistakes:

• Thinking agents only store data
• Confusing agents with programming tools
• Assuming agents replace emotions

2. Which of the following is the correct way to define a skill in a personal assistant agent?

easy

A. skill = (name = 'weather', action = get_weather)

B. skill = {'name': 'weather', 'action': get_weather}

C. skill = [name: 'weather', action: get_weather]

D. skill = 'weather' -> get_weather

Solution

1. Step 1: Recognize correct data structure

   Skills are usually defined as dictionaries with keys and values.

2. Step 2: Check syntax correctness

   skill = {'name': 'weather', 'action': get_weather} uses correct dictionary syntax with keys 'name' and 'action'.

3. Final Answer:

   skill = {'name': 'weather', 'action': get_weather} -> Option B

4. Quick Check:

   Skill syntax = dictionary format [OK]

Hint: Skills use key-value pairs in curly braces [OK]

Common Mistakes:

• Using list or tuple syntax for skills
• Using arrows or invalid separators
• Missing quotes for keys

3. Given this code snippet for a personal assistant agent, what will be the output?

skills = {'greet': lambda: 'Hello!'}
response = skills['greet']()
print(response)

medium

A. Error: skills is not callable

B. greet

C. lambda

D. Hello!

Solution

1. Step 1: Understand the skills dictionary

   It stores a key 'greet' with a function that returns 'Hello!'.

2. Step 2: Call the function and print result

   Calling skills['greet']() runs the lambda and returns 'Hello!'.

3. Final Answer:

   Hello! -> Option D

4. Quick Check:

   Function call returns greeting [OK]

Hint: Calling skills[key]() runs the stored function [OK]

Common Mistakes:

• Printing the key instead of function result
• Confusing function object with its output
• Assuming skills is callable directly

4. Identify the error in this personal assistant agent code snippet:

skills = {'time': lambda: '12:00 PM'}
response = skills.time()
print(response)

medium

A. Dictionary keys cannot be strings

B. Lambda function syntax is incorrect

C. skills.time() should be skills['time']()

D. Missing parentheses in print statement

Solution

1. Step 1: Check dictionary access method

   Dictionary keys must be accessed with brackets and quotes, not dot notation.

2. Step 2: Correct the function call

   Use skills['time']() to call the lambda function properly.

3. Final Answer:

   skills.time() should be skills['time']() -> Option C

4. Quick Check:

   Access dict keys with brackets [OK]

Hint: Use brackets to access dictionary keys, not dot [OK]

Common Mistakes:

• Using dot notation for dict keys
• Misunderstanding lambda syntax
• Forgetting parentheses in print

5. You want to build a personal assistant agent that can handle multiple skills and choose the right one based on user input. Which pattern best helps organize this behavior?

hard

A. Use a skill registry dictionary mapping commands to functions

B. Write one big function handling all tasks sequentially

C. Store all skills as separate files without linking

D. Use random choice to pick a skill regardless of input

Solution

1. Step 1: Understand the need for organized skill management

   Handling multiple skills requires mapping user commands to specific functions.

2. Step 2: Choose the pattern that supports this mapping

   A skill registry dictionary allows quick lookup and execution of the right skill.

3. Final Answer:

   Use a skill registry dictionary mapping commands to functions -> Option A

4. Quick Check:

   Skill registry = organized command handling [OK]

Hint: Map commands to functions in a dictionary for clarity [OK]

Common Mistakes:

• Trying to handle all tasks in one function
• Not linking skills to commands
• Using random selection ignoring input