Agent API design patterns in Agentic AI - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding the role of the 'Planner' in Agent API design

In an agent API design pattern, what is the primary role of the 'Planner' component?

A It executes the actions decided by the agent without modification.

B It decides the sequence of actions the agent should take to achieve its goal.

C It stores the agent's memory and past interactions for future reference.

D It handles the user interface and visual representation of the agent.

💡 Hint

Think about which part of the agent figures out what to do next.

The 'Planner' is responsible for deciding the sequence of steps or actions the agent should take to reach its goal. It plans the path forward.

❓ Predict Output

intermediate

Output of agent action execution with error handling

What will be the output of the following agent API code snippet when the action 'fetch_data' fails?

Agentic AI

class Agent:
    def __init__(self):
        self.actions = {'fetch_data': self.fetch_data}
    def fetch_data(self):
        raise Exception('Network error')
    def execute(self, action_name):
        try:
            return self.actions[action_name]()
        except Exception as e:
            return f'Error: {e}'
agent = Agent()
result = agent.execute('fetch_data')
print(result)

A Network error

B Exception: Network error

C None

D Error: Network error

💡 Hint

Look at the except block and what it returns.

The execute method catches the exception and returns a string starting with 'Error:' followed by the exception message.

❓ Model Choice

advanced

Choosing the best agent API pattern for dynamic task switching

Which agent API design pattern best supports dynamic switching between multiple tasks based on real-time input?

A Hierarchical pattern with layered decision-making and task delegation.

B Reactive pattern that immediately responds to inputs without internal state.

C Batch processing pattern that queues tasks and processes them sequentially.

D Static pipeline pattern with fixed sequence of operations.

💡 Hint

Consider which pattern allows flexible control and task management.

The hierarchical pattern allows the agent to delegate tasks and switch dynamically based on input, supporting complex decision-making.

❓ Hyperparameter

advanced

Impact of 'timeout' hyperparameter in agent API calls

In an agent API design, setting a 'timeout' hyperparameter controls:

A The maximum time the agent waits for an action to complete before aborting.

B The number of retries the agent makes after a failed action.

C The priority level of the agent's tasks in the queue.

D The size of the memory buffer storing past interactions.

💡 Hint

Think about what 'timeout' usually means in computing.

The 'timeout' sets how long the agent waits for an action to finish before stopping it to avoid hanging.

🔧 Debug

expert

Debugging unexpected agent response in API design

An agent API is designed to return a JSON response with keys 'status' and 'result'. The following code snippet returns {'status': 'success'} but misses 'result'. What is the likely cause?

def agent_response(data):
    if data:
        return {'status': 'success'}
    else:
        return {'status': 'fail', 'result': None}
response = agent_response({'task': 'run'})
print(response)

A The print statement is missing the 'result' key access.

B The input data is empty, so the else branch is not executed.

C The function does not include 'result' in the success case, causing incomplete response.

D The function should return a string, not a dictionary.

💡 Hint

Check what keys are returned in each branch of the function.

The success branch returns only 'status' without 'result', so the response is missing that key.