Agent memory and state in Prompt Engineering / GenAI - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the primary role of agent memory in AI systems?

In AI agents, what does the agent memory mainly help with?

A Increasing the speed of the AI's calculations

B Reducing the size of the AI model

C Storing past interactions to improve future decisions

D Encrypting data for security purposes

💡 Hint

Think about how remembering past events can help an AI act better next time.

Agent memory stores past interactions or states so the AI can use that information to make better decisions in the future.

❓ Predict Output

intermediate

Output of agent state update code

What will be the value of state after running this code?

Prompt Engineering / GenAI

state = {'count': 0}

# Agent receives new input
input_signal = 3

# Update state by adding input_signal
state['count'] += input_signal

# Agent receives another input
input_signal = 2

# Update state again
state['count'] += input_signal

print(state)

A {'count': 5}

B {'count': 3}

C {'count': 2}

D {'count': 0}

💡 Hint

Remember the state updates add the input signals cumulatively.

The state starts at 0, then adds 3, then adds 2, resulting in 5.

❓ Hyperparameter

advanced

Choosing memory size for an AI agent

You want your AI agent to remember recent conversations but limit memory size to save resources. Which memory size hyperparameter is best?

A Store all interactions indefinitely

B Keep memory size to last 5 interactions

C Forget all past interactions after each step

D Store only the first interaction

💡 Hint

Think about balancing memory usefulness and resource limits.

Keeping recent 5 interactions balances useful context and resource use. Storing all or none is inefficient or useless.

❓ Metrics

advanced

Evaluating agent memory effectiveness

Which metric best measures how well an AI agent uses its memory to improve task success?

A Task completion accuracy over time with memory enabled

B CPU usage during agent execution

C Number of lines of code in the memory module

D Size of the training dataset

💡 Hint

Focus on measuring the agent's performance improvement due to memory.

Task completion accuracy over time shows if memory helps the agent perform better. CPU usage or code size do not measure effectiveness.

🔧 Debug

expert

Why does the agent state not update correctly?

Consider this code snippet for updating an agent's state. Why does the state not reflect the new input?

Prompt Engineering / GenAI

class Agent:
    def __init__(self):
        self.state = {'value': 0}

    def update(self, input_val):
        state = self.state.copy()
        state['value'] = input_val

agent = Agent()
agent.update(10)
print(agent.state)

A The print statement is called before the update method

B The state dictionary is immutable and cannot be changed

C The input_val is not passed correctly to the update method

D The update method modifies a local variable 'state' instead of the instance's state

💡 Hint

Check if the update method changes the actual agent's state or just a copy.

The update method assigns to a local variable 'state' but does not update the instance's state dictionary properly, so changes do not persist.

Practice

1. What is the main purpose of agent memory in AI systems?

easy

A. To hold the current situation or context

B. To store past information for future use

C. To process new input data instantly

D. To delete old data automatically

Solution

1. Step 1: Understand agent memory role

   Agent memory is designed to keep past information so the AI can remember what happened before.

2. Step 2: Differentiate from agent state

   Agent state holds current context, not past data. Memory is about storing history.

3. Final Answer:

   To store past information for future use -> Option B

4. Quick Check:

   Agent memory = store past info [OK]

Hint: Memory = past info storage, state = current context [OK]

Common Mistakes:

• Confusing memory with current state
• Thinking memory deletes old data automatically
• Assuming memory processes new input instantly

2. Which of the following is the correct way to update an agent's state in Python?

easy

A. agent_state = new_state

B. agent_state == new_state

C. agent_state := new_state

D. agent_state += new_state

Solution

1. Step 1: Identify assignment syntax

   In Python, to update a variable, use a single equals sign =.

2. Step 2: Check other options

   == is comparison, := is assignment expression but not typical for state update, += adds values, not replaces.

3. Final Answer:

   agent_state = new_state -> Option A

4. Quick Check:

   Use = for assignment [OK]

Hint: Use = to assign new state, not == or := [OK]

Common Mistakes:

• Using == instead of = for assignment
• Confusing := with = in simple updates
• Using += when replacement is needed

3. Given this Python code snippet for an agent:

agent_memory = []
agent_state = {'mood': 'neutral'}

# Agent receives new info
new_info = 'happy'

# Update memory and state
agent_memory.append(new_info)
agent_state['mood'] = new_info

print(agent_memory, agent_state)

What will be the output?

medium

A. [] {'mood': 'neutral'}

B. ["happy"] {'mood': 'neutral'}

C. ["neutral"] {'mood': 'happy'}

D. ["happy"] {'mood': 'happy'}

Solution

1. Step 1: Analyze memory update

   The code appends new_info ('happy') to agent_memory, so memory becomes ['happy'].

2. Step 2: Analyze state update

   The agent's state key 'mood' is updated to 'happy'.

3. Final Answer:

   ["happy"] {'mood': 'happy'} -> Option D

4. Quick Check:

   Memory and state updated with 'happy' [OK]

Hint: Memory appends, state key updates with new info [OK]

Common Mistakes:

• Forgetting append adds to list
• Confusing state key value with memory content
• Assuming memory or state unchanged

4. Consider this code snippet meant to update agent memory and state:

agent_memory = []
agent_state = {'status': 'idle'}

new_data = 'active'

# Intended to update memory and state
agent_memory = agent_memory.append(new_data)
agent_state['status'] == new_data

print(agent_memory, agent_state)

What is the main error causing unexpected output?

medium

A. Not initializing agent_memory as a list

B. Using == instead of = to update state

C. Using append() return value to assign memory

D. Forgetting to print agent_state

Solution

1. Step 1: Check memory update line

   append() modifies list in place and returns None. Assigning it back sets agent_memory to None.

2. Step 2: Check state update line

   The line uses == which compares but does not assign, so state remains unchanged.

3. Final Answer:

   Using append() return value to assign memory -> Option C

4. Quick Check:

   append() returns None, don't assign it [OK]

Hint: append() returns None; assign only new values [OK]

Common Mistakes:

• Assigning append() result to list variable
• Using == instead of = for assignment
• Ignoring that append modifies list in place

5. You want an AI agent to remember user preferences over multiple sessions and adjust its behavior accordingly. Which combination best supports this goal?

hard

A. Use agent memory to store preferences and agent state to track current session context

B. Use only agent state to store all information permanently

C. Use agent memory only for current session and ignore state

D. Reset both memory and state after each session

Solution

1. Step 1: Understand memory role for long-term data

   Agent memory stores past info like user preferences across sessions.

2. Step 2: Understand state role for current context

   Agent state holds current session details to adjust behavior immediately.

3. Final Answer:

   Use agent memory to store preferences and agent state to track current session context -> Option A

4. Quick Check:

   Memory = long-term, state = current context [OK]

Hint: Memory for long-term, state for current session [OK]

Common Mistakes:

• Using state for permanent storage
• Ignoring memory for preferences
• Resetting memory loses past info