Retry and fallback logic in Agentic AI - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding Retry Logic Purpose

Why is retry logic important in agentic AI systems when calling external APIs?

A To increase the number of API calls regardless of errors

B To permanently stop the process after the first failure

C To ignore errors and continue without any checks

D To handle temporary failures by trying the request again automatically

💡 Hint

Think about what happens if a network glitch causes a temporary failure.

Retry logic helps the system recover from temporary issues by trying again, improving reliability.

❓ Predict Output

intermediate

Output of Retry Loop with Limited Attempts

What will be the printed output of this retry logic code snippet?

Agentic AI

attempts = 0
max_attempts = 3
while attempts < max_attempts:
    attempts += 1
    if attempts < 3:
        print(f"Attempt {attempts}: Failed")
    else:
        print(f"Attempt {attempts}: Success")
        break

A

Attempt 1: Failed
Attempt 2: Failed
Attempt 3: Success

B

Attempt 1: Failed
Attempt 2: Success

C Attempt 1: Success

D

Attempt 1: Failed
Attempt 2: Failed
Attempt 3: Failed

💡 Hint

Check how many times the loop runs and when it breaks.

The loop tries 3 times. The first two attempts print 'Failed'. The third prints 'Success' and stops.

❓ Model Choice

advanced

Choosing Fallback Strategy for Agentic AI

If an agentic AI fails to get a response from a primary model after retries, which fallback strategy is best to maintain user experience?

A Stop all processing and show an error message immediately

B Switch to a simpler, faster model that provides approximate answers

C Keep retrying indefinitely without fallback

D Return empty or null responses without explanation

💡 Hint

Consider user experience and response time.

Using a simpler model as fallback keeps the system responsive and provides useful answers even if less precise.

❓ Metrics

advanced

Evaluating Retry Logic Impact on Latency

Which metric best measures the impact of retry logic on system latency?

A Average response time including retries

B Model accuracy on successful calls

C Number of retries attempted

D Memory usage during retries

💡 Hint

Think about how retries affect how long users wait.

Average response time including retries shows how retries increase total wait time for responses.

🔧 Debug

expert

Identifying Bug in Retry with Fallback Code

What error will this retry and fallback code raise when the primary model always fails?

Agentic AI

def get_response():
    for _ in range(2):
        try:
            result = primary_model_call()
            return result
        except Exception:
            continue
    return fallback_model_call()

response = get_response()

A No error, returns fallback model response

B TypeError because fallback_model_call returns wrong type

C NameError because primary_model_call is not defined

D RuntimeError due to infinite loop

💡 Hint

Check if the functions called are defined in the code snippet.

primary_model_call and fallback_model_call are not defined anywhere, causing a NameError on first call.