Tracing agent reasoning chains in Agentic AI - ML Experiment: Train & Evaluate

Experiment - Tracing agent reasoning chains

Problem:You have an AI agent that makes decisions by reasoning through multiple steps. Currently, you cannot see or understand the chain of thoughts the agent uses to reach its answers.

Current Metrics:Agent accuracy: 85%, Reasoning transparency: 0% (no visible reasoning steps)

Issue:The agent's decisions are accurate but opaque. You want to trace and display the reasoning chain to improve trust and debugging.

Your Task

Modify the agent to output its reasoning chain step-by-step along with the final answer, without reducing accuracy below 80%.

Do not change the agent's core decision model.

Only add tracing/logging of reasoning steps.

Maintain or improve current accuracy.

Hint 1

Hint 2

Hint 3

Solution

Agentic AI

class ReasoningAgent:
    def __init__(self):
        pass

    def reason(self, input_data):
        reasoning_chain = []
        # Step 1: Understand input
        step1 = f"Received input: {input_data}"
        reasoning_chain.append(step1)

        # Step 2: Process data (dummy example)
        processed = input_data.lower()
        step2 = f"Processed input to lowercase: {processed}"
        reasoning_chain.append(step2)

        # Step 3: Make decision (dummy logic)
        if 'hello' in processed:
            decision = 'Greet back'
        else:
            decision = 'No greeting'
        step3 = f"Decision based on processed input: {decision}"
        reasoning_chain.append(step3)

        # Return both reasoning chain and final decision
        return reasoning_chain, decision


# Example usage
agent = ReasoningAgent()
input_text = "Hello, how are you?"
chain, answer = agent.reason(input_text)

print("Reasoning chain:")
for step in chain:
    print(step)
print(f"Final answer: {answer}")

Added a list to store reasoning steps.

Inserted reasoning steps after each processing stage.

Returned both the reasoning chain and final decision.

Printed the reasoning chain clearly for user understanding.

Results Interpretation

Before: Accuracy 85%, Reasoning transparency 0% (no steps shown)

After: Accuracy 85%, Reasoning transparency 100% (all steps shown)

Tracing the agent's reasoning chain helps users understand how decisions are made without hurting accuracy. This builds trust and aids debugging.

Bonus Experiment

Try adding confidence scores to each reasoning step to show how sure the agent is at each stage.

💡 Hint

Modify the reasoning steps to include a confidence value between 0 and 1, and display it alongside each step.

Practice

1. What is the main purpose of tracing an AI agent's reasoning chain?

easy

A. To increase the randomness of the agent's output

B. To speed up the agent's processing time

C. To reduce the size of the AI model

D. To understand how the agent reaches its decisions step-by-step

Solution

1. Step 1: Understand the concept of tracing

   Tracing means following each step the AI agent takes to reach a conclusion.

2. Step 2: Identify the purpose of tracing

   Tracing helps us see the reasoning process clearly, which aids understanding and debugging.

3. Final Answer:

   To understand how the agent reaches its decisions step-by-step -> Option D

4. Quick Check:

   Tracing = step-by-step understanding [OK]

Hint: Tracing means following steps to understand decisions [OK]

Common Mistakes:

• Thinking tracing speeds up processing
• Confusing tracing with model size reduction
• Believing tracing adds randomness

2. Which of the following is the correct way to start tracing an agent's reasoning chain in code?

easy

A. trace = agent.start_trace()

B. trace = agent.stop_trace()

C. trace = agent.reset()

D. trace = agent.randomize()

Solution

1. Step 1: Identify the method to begin tracing

   Starting a trace usually involves a method like start_trace() to begin recording steps.

2. Step 2: Eliminate incorrect options

   stop_trace() ends tracing, reset() clears state, and randomize() changes behavior, so they are incorrect.

3. Final Answer:

   trace = agent.start_trace() -> Option A

4. Quick Check:

   Start tracing = start_trace() [OK]

Hint: Start tracing with a method named like start_trace() [OK]

Common Mistakes:

• Using stop_trace() to start tracing
• Confusing reset() with tracing
• Calling randomize() instead of tracing methods

3. Given this code snippet tracing an agent's reasoning:

trace = agent.start_trace()
result = agent.answer('What is 2 + 2?')
steps = trace.get_steps()

What will steps contain?

medium

A. An error because get_steps() is not defined

B. A list of reasoning steps the agent took to answer 'What is 2 + 2?'

C. The final answer only, e.g., 4

D. An empty list because tracing was not started

Solution

1. Step 1: Understand the tracing process

   Starting trace records the agent's reasoning steps during the answer process.

2. Step 2: Analyze what get_steps() returns

   get_steps() returns the list of recorded reasoning steps, not just the final answer or an error.

3. Final Answer:

   A list of reasoning steps the agent took to answer 'What is 2 + 2?' -> Option B

4. Quick Check:

   get_steps() = reasoning steps list [OK]

Hint: get_steps() returns all reasoning steps, not just final answer [OK]

Common Mistakes:

• Thinking get_steps() returns only the final answer
• Assuming get_steps() causes an error
• Forgetting to start tracing before calling get_steps()

4. You wrote this code to trace an agent's reasoning:

trace = agent.start_trace()
result = agent.answer('Is the sky blue?')
trace = agent.start_trace()
steps = trace.get_steps()

Why does steps return an empty list?

medium

A. Because start_trace() returns None

B. Because the agent cannot answer 'Is the sky blue?'

C. Because tracing was restarted after answering, clearing previous steps

D. Because get_steps() is called before starting trace

Solution

1. Step 1: Identify the tracing calls order

   Tracing started, then answer called, then tracing started again, which resets the trace.

2. Step 2: Understand effect of restarting trace

   Restarting trace clears previous steps, so get_steps() returns empty list.

3. Final Answer:

   Because tracing was restarted after answering, clearing previous steps -> Option C

4. Quick Check:

   Restarting trace clears steps [OK]

Hint: Restarting trace clears previous steps, so steps list is empty [OK]

Common Mistakes:

• Thinking agent can't answer the question
• Calling get_steps() before starting trace
• Assuming start_trace() returns None always

5. You want to trace an AI agent solving a math problem and then explain its reasoning to a beginner. Which approach best uses tracing to achieve this?

hard

A. Start tracing before asking the math question, collect all reasoning steps, then format them in simple language

B. Ask the math question without tracing, then guess the reasoning steps manually

C. Start tracing after getting the answer, then try to get reasoning steps

D. Only get the final answer and skip tracing to save time

Solution

1. Step 1: Plan to capture reasoning steps

   Starting tracing before asking the question ensures all reasoning is recorded.

2. Step 2: Use collected steps to explain simply

   Formatting the steps in simple language helps beginners understand the agent's thought process.

3. Final Answer:

   Start tracing before asking the math question, collect all reasoning steps, then format them in simple language -> Option A

4. Quick Check:

   Trace first, then explain simply [OK]

Hint: Trace before question, then explain steps simply [OK]

Common Mistakes:

• Starting trace after answering loses steps
• Guessing reasoning without tracing
• Skipping tracing to save time loses insight