Latency monitoring per step in Agentic AI - ML Experiment: Train & Evaluate

Experiment - Latency monitoring per step

Problem:You have an AI agent that performs multiple steps sequentially. Each step takes some time to complete. Currently, you do not know how long each step takes, which makes it hard to optimize or debug the agent's performance.

Current Metrics:No latency data per step is collected. Total execution time is known but step-wise timing is unknown.

Issue:Without step-level latency monitoring, it is difficult to identify slow steps or bottlenecks in the agent's workflow.

Your Task

Add latency monitoring to measure and report the time taken by each step of the AI agent's process.

Do not change the logic or output of the agent's steps.

Use simple timing methods available in Python.

Ensure the latency data is printed or logged clearly after the agent finishes.

Hint 1

Hint 2

Hint 3

Hint 4

Solution

Agentic AI

import time

def step1():
    time.sleep(0.5)  # Simulate work
    return "Step 1 done"

def step2():
    time.sleep(0.7)  # Simulate work
    return "Step 2 done"

def step3():
    time.sleep(0.3)  # Simulate work
    return "Step 3 done"

def run_agent_with_latency_monitoring():
    latencies = {}

    start = time.time()
    result1 = step1()
    latencies['step1'] = time.time() - start

    start = time.time()
    result2 = step2()
    latencies['step2'] = time.time() - start

    start = time.time()
    result3 = step3()
    latencies['step3'] = time.time() - start

    print(result1)
    print(result2)
    print(result3)

    print("Latency per step (seconds):")
    for step, latency in latencies.items():
        print(f"{step}: {latency:.3f}s")

if __name__ == "__main__":
    run_agent_with_latency_monitoring()

Added timing code around each step using time.time() to measure start and end times.

Stored each step's latency in a dictionary.

Printed latency summary after all steps complete.

Results Interpretation

Before: No timing data per step, only total time known.

After: Each step's latency is measured and printed, allowing identification of slow steps.

Measuring latency per step helps find bottlenecks and optimize AI agent workflows by showing exactly where time is spent.

Bonus Experiment

Modify the code to log latency data to a CSV file instead of printing it.

💡 Hint

Use Python's csv module to write step names and latencies to a file for later analysis.

Practice

1. What is the main purpose of latency monitoring per step in a process?

easy

A. To reduce the total number of users

B. To increase the number of steps in the process

C. To find slow parts in the process and improve speed

D. To add more features to the system

Solution

1. Step 1: Understand latency monitoring

   Latency monitoring measures how long each step in a process takes.

2. Step 2: Identify the goal of monitoring

   The goal is to find slow steps to improve overall speed and user experience.

3. Final Answer:

   To find slow parts in the process and improve speed -> Option C

4. Quick Check:

   Latency monitoring = Find slow parts [OK]

Hint: Latency monitoring finds slow steps to speed up process [OK]

Common Mistakes:

• Thinking it adds more steps
• Confusing with user count
• Assuming it adds features

2. Which code snippet correctly measures latency for a step using start and end time calls?

easy

A. start_time = get_time()
// step code
end_time = get_time()
latency = end_time - start_time

B. start_time = get_time()
latency = start_time
end_time = get_time()

C. latency = get_time()
// step code
latency = latency - get_time()

D. end_time = get_time()
// step code
start_time = get_time()
latency = end_time - start_time

Solution

1. Step 1: Identify correct order of time calls

   Start time must be recorded before the step, end time after the step.

2. Step 2: Calculate latency as difference

   Latency is end_time minus start_time to get duration.

3. Final Answer:

   start_time = get_time()\n// step code\nend_time = get_time()\nlatency = end_time - start_time -> Option A

4. Quick Check:

   Latency = end - start [OK]

Hint: Latency = end time minus start time [OK]

Common Mistakes:

• Subtracting start from end incorrectly
• Assigning latency before step runs
• Swapping start and end times

3. Given this code snippet measuring latency per step, what is the output of print(latencies)?

latencies = []
for step in range(3):
    start = get_time()
    do_work(step)
    end = get_time()
    latencies.append(end - start)
print(latencies)

Assume do_work(step) takes 1, 2, and 3 seconds respectively.

medium

A. [1, 2, 3]

B. [3, 2, 1]

C. [0, 0, 0]

D. Error: get_time() undefined

Solution

1. Step 1: Understand loop and timing

   Each loop iteration measures time before and after do_work(step).

2. Step 2: Calculate latencies per step

   Since do_work takes 1, 2, and 3 seconds, latencies list will be [1, 2, 3].

3. Final Answer:

   [1, 2, 3] -> Option A

4. Quick Check:

   Latencies match step durations [OK]

Hint: Latency list matches step durations in order [OK]

Common Mistakes:

• Reversing latency order
• Assuming zero latency
• Ignoring step durations

4. You wrote this code to measure latency per step but get wrong results:

start = get_time()
do_step1()
end = get_time()
latency1 = end - start

start = get_time()
do_step2()
latency2 = end - start

What is the error causing wrong latency2?

medium

A. start time is recorded after do_step2

B. end time is not updated before calculating latency2

C. latency1 calculation is incorrect

D. do_step1 and do_step2 are swapped

Solution

1. Step 1: Check timing for latency2

   For latency2, end time is not updated after do_step2, so it uses old end value.

2. Step 2: Identify missing end time update

   Must call end = get_time() after do_step2 before calculating latency2.

3. Final Answer:

   end time is not updated before calculating latency2 -> Option B

4. Quick Check:

   Update end time after step [OK]

Hint: Always update end time after each step [OK]

Common Mistakes:

• Forgetting to update end time
• Calculating latency before step ends
• Mixing start and end times

5. You want to monitor latency per step in a multi-step process and alert if any step exceeds 2 seconds. Which approach correctly implements this?

hard

A. Ignore timing and alert randomly to check system

B. Measure total process time only and alert if total > 2 seconds

C. Only measure first step latency and alert if > 2 seconds

D. Measure start and end time per step, calculate latency, and trigger alert if latency > 2

Solution

1. Step 1: Understand requirement for per-step latency

   We must measure each step's latency individually to detect slow steps.

2. Step 2: Implement alert condition per step

   Calculate latency per step and trigger alert if latency exceeds 2 seconds.

3. Final Answer:

   Measure start and end time per step, calculate latency, and trigger alert if latency > 2 -> Option D

4. Quick Check:

   Alert on per-step latency > 2 seconds [OK]

Hint: Alert when any step latency exceeds threshold [OK]

Common Mistakes:

• Measuring only total time
• Checking only first step
• Ignoring timing data