Tree-of-thought for complex decisions in Agentic AI - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the main advantage of using a tree-of-thought approach in AI decision-making?

Consider an AI agent facing a complex problem with many possible steps. What is the main advantage of using a tree-of-thought approach compared to a simple linear reasoning process?

A It allows the AI to explore multiple possible reasoning paths before choosing the best one.

B It guarantees the AI will find the perfect solution every time without any errors.

C It reduces the number of possible decisions by ignoring less important options.

D It forces the AI to follow a fixed sequence of steps without deviation.

💡 Hint

Think about how exploring different paths helps in complex problems.

The tree-of-thought approach lets the AI consider many possible reasoning paths, helping it find better solutions by comparing options rather than following just one path.

❓ Predict Output

intermediate

What is the output of this tree-of-thought simulation code?

Given the following Python code simulating a simple tree-of-thought search, what will be printed?

Agentic AI

def tree_search(node, depth):
    if depth == 0 or not node['children']:
        return node['value']
    results = []
    for child in node['children']:
        results.append(tree_search(child, depth - 1))
    return max(results)

root = {
    'value': 0,
    'children': [
        {'value': 3, 'children': []},
        {'value': 5, 'children': [
            {'value': 2, 'children': []},
            {'value': 7, 'children': []}
        ]},
        {'value': 1, 'children': []}
    ]
}

print(tree_search(root, 2))

A 0

B 7

C 3

D 5

💡 Hint

The function returns the maximum value found up to the given depth.

The search explores children up to depth 2. The maximum value among children and grandchildren is 7, so the output is 7.

❓ Hyperparameter

advanced

Which hyperparameter most directly controls the breadth of exploration in a tree-of-thought search?

In a tree-of-thought AI system, which hyperparameter controls how many different reasoning paths the system explores at each step?

A Depth limit

B Batch size

C Learning rate

D Branching factor

💡 Hint

Think about how many child nodes are considered at each decision point.

The branching factor sets how many child nodes (paths) are explored from each node, controlling the breadth of the search tree.

❓ Metrics

advanced

Which metric best evaluates the quality of decisions made by a tree-of-thought AI agent?

When assessing a tree-of-thought AI agent solving complex problems, which metric best measures how good the final decisions are?

A Time taken to run the search

B Number of nodes expanded during search

C Accuracy of final solution compared to ground truth

D Memory usage during computation

💡 Hint

Focus on the quality of the solution, not the resource usage.

Accuracy of the final solution shows how well the AI's decisions match the correct or desired answers, which is the key quality metric.

🔧 Debug

expert

Why does this tree-of-thought search code get stuck in an infinite loop?

Examine the code below. Why does the tree-of-thought search get stuck and never finish?

Agentic AI

def search(node, visited=None):
    if visited is None:
        visited = set()
    if node['id'] in visited:
        return None
    visited.add(node['id'])
    if not node['children']:
        return node['value']
    results = []
    for child in node['children']:
        results.append(search(child, visited))
    return max(filter(None, results))

node_a = {'id': 'A', 'value': 1, 'children': []}
node_b = {'id': 'B', 'value': 2, 'children': [node_a]}
node_a['children'] = [node_b]

print(search(node_a))

A The code does not handle cycles properly because the visited set is shared and nodes are revisited.

B The visited set is shared across recursive calls, causing incorrect skipping of nodes.

C The max function fails because results list is empty due to filtering None values.

D The recursion depth is too shallow, so the search stops prematurely.

💡 Hint

Consider how cycles in the graph affect recursion and visited nodes.

The visited set is shared across all recursive calls, so when a cycle exists, nodes are revisited causing infinite recursion. Proper cycle detection requires careful handling of visited nodes per path.