Real-world agent applications in Agentic AI - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding Agent Roles in Real-World Applications

Which of the following best describes the primary role of an agent in a real-world AI application?

A An agent only processes data offline without any decision-making

B An agent passively stores data without interacting with the environment

C An agent actively perceives its environment and takes actions to achieve goals

D An agent is a static model that never updates or learns from new data

💡 Hint

Think about how a self-driving car senses and reacts to its surroundings.

Agents in real-world AI applications sense their environment and take actions to reach specific goals, making them active and interactive.

❓ Model Choice

intermediate

Choosing the Right Agent Model for a Delivery Robot

You are designing an AI agent for a delivery robot that must navigate city streets, avoid obstacles, and deliver packages on time. Which agent architecture is most suitable?

A Simple reflex agent that acts only on current sensor input

B Model-based reflex agent that maintains internal state about the environment

C Static lookup table agent with fixed responses

D Random agent that chooses actions randomly

💡 Hint

Consider the need to remember past information to make better decisions.

A model-based reflex agent keeps track of the environment state, which helps in complex navigation and decision-making tasks like delivery.

❓ Metrics

advanced

Evaluating Agent Performance in a Dynamic Environment

An AI agent is deployed in a warehouse to pick and place items. Which metric best measures how efficiently the agent completes its tasks over time?

A Average task completion time and success rate combined

B Accuracy of item classification only

C Number of sensor readings collected

D Memory usage of the agent's software

💡 Hint

Think about both speed and correctness of task completion.

Efficiency in task completion involves how fast and how successfully the agent finishes tasks, so combining time and success rate is best.

🔧 Debug

advanced

Identifying the Cause of Agent Failure in Navigation

An autonomous agent in a smart home fails to reach the kitchen reliably. The code snippet below shows the decision logic. What is the most likely cause of failure?

Agentic AI

def decide_action(sensor_data):
    if sensor_data['obstacle'] == True:
        return 'stop'
    elif sensor_data['destination'] == 'kitchen':
        return 'move_forward'
    else:
        return 'turn_left'

A The sensor_data dictionary is missing the 'obstacle' key

B The agent never moves forward because the condition is always false

C The agent turns left only when the destination is the kitchen

D The agent stops whenever it detects any obstacle, even if it can navigate around it

💡 Hint

Consider how the agent reacts to obstacles and if it can continue moving.

The agent stops immediately on detecting any obstacle without trying to navigate around it, causing failure to reach the kitchen.

❓ Predict Output

expert

Output of Multi-Agent Interaction Simulation

Consider two agents interacting in a simulation. Agent A shares a message, and Agent B responds based on the message content. What is the output of the following code?

Agentic AI

class Agent:
    def __init__(self, name):
        self.name = name
    def send_message(self, other, message):
        return other.receive_message(message)
    def receive_message(self, message):
        if 'help' in message:
            return f'{self.name} received help request'
        else:
            return f'{self.name} received unknown message'

agent_a = Agent('A')
agent_b = Agent('B')
output = agent_a.send_message(agent_b, 'I need help with task')
print(output)

A B received help request

B A received help request

C B received unknown message

D A received unknown message

💡 Hint

Trace which agent receives the message and how it processes it.

Agent A sends a message to Agent B. Agent B checks if 'help' is in the message and responds accordingly.

Practice

1. What is the main role of a real-world agent in AI applications?

easy

A. To only observe without making decisions

B. To store large amounts of data without interaction

C. To sense the environment and act to achieve goals

D. To randomly perform actions without purpose

Solution

1. Step 1: Understand agent behavior

   Real-world agents sense their surroundings and make decisions based on what they observe.

2. Step 2: Connect sensing and acting

   Agents act to reach specific goals, not randomly or passively.

3. Final Answer:

   To sense the environment and act to achieve goals -> Option C

4. Quick Check:

   Agent role = sensing + acting [OK]

Hint: Agents always sense and act to reach goals [OK]

Common Mistakes:

• Thinking agents only observe without acting
• Believing agents act randomly
• Confusing data storage with agent action

2. Which code snippet correctly represents the agent loop in Python?

easy

A. while False:
decide()
observe()
act()

B. for i in range(3):
act()
decide()
observe()

C. if observe():
act()
decide()

D. while True:
observe()
decide()
act()

Solution

1. Step 1: Identify the correct loop structure

   The agent loop runs continuously, so a while True loop is appropriate.

2. Step 2: Check the order of actions

   The correct order is observe, then decide, then act.

3. Final Answer:

   while True:\n observe()\n decide()\n act() -> Option D

4. Quick Check:

   Loop + observe-decide-act order = while True: observe() decide() act() [OK]

Hint: Agent loop is infinite with observe, decide, then act [OK]

Common Mistakes:

• Using for loop instead of infinite loop
• Wrong order of observe, decide, act
• Loop condition that never runs

3. Given this agent code snippet, what will be printed?

def observe():
    return 'rainy'
def decide(weather):
    return 'take umbrella' if weather == 'rainy' else 'no umbrella'
def act(action):
    print(f'Action: {action}')

weather = observe()
action = decide(weather)
act(action)

medium

A. Action: no umbrella

B. Action: take umbrella

C. Action: sunny

D. No output

Solution

1. Step 1: Trace the observe function

   observe() returns 'rainy'.

2. Step 2: Trace the decide function

   decide('rainy') returns 'take umbrella' because weather is 'rainy'.

3. Step 3: Trace the act function

   act('take umbrella') prints 'Action: take umbrella'.

4. Final Answer:

   Action: take umbrella -> Option B

5. Quick Check:

   observe='rainy' -> decide='take umbrella' -> print output [OK]

Hint: Follow data flow: observe -> decide -> act output [OK]

Common Mistakes:

• Ignoring the condition in decide()
• Confusing output text
• Assuming no print happens

4. Find the error in this agent loop code:

while True:
    action = decide(observe)
    act(action)

medium

A. observe should be called as observe()

B. act() should return a value

C. decide() should not take any arguments

D. while True should be replaced with for loop

Solution

1. Step 1: Check function calls

   observe is passed without parentheses, so it's a function object, not its result.

2. Step 2: Correct function call

   observe() should be called to get the observed data before passing to decide.

3. Final Answer:

   observe should be called as observe() -> Option A

4. Quick Check:

   Function call missing parentheses = observe should be called as observe() [OK]

Hint: Call functions with () to get results [OK]

Common Mistakes:

• Passing function object instead of calling it
• Expecting act() to return value
• Changing loop type unnecessarily

5. You want to build an agent that automatically trades stocks based on price trends. Which sequence best describes the agent's real-world loop?

hard

A. Observe stock prices -> Decide buy/sell -> Act by placing orders

B. Act by placing orders -> Observe stock prices -> Decide buy/sell

C. Decide buy/sell -> Act by placing orders -> Observe stock prices

D. Observe stock prices -> Act by placing orders -> Decide buy/sell

Solution

1. Step 1: Understand agent loop order

   The agent must first observe the environment (stock prices) before deciding.

2. Step 2: Confirm correct action order

   After deciding buy or sell, the agent acts by placing orders.

3. Final Answer:

   Observe stock prices -> Decide buy/sell -> Act by placing orders -> Option A

4. Quick Check:

   Observe -> Decide -> Act is standard agent loop [OK]

Hint: Agent loop always: observe, then decide, then act [OK]

Common Mistakes:

• Mixing up the order of observe, decide, act
• Thinking action happens before decision
• Ignoring environment sensing step