Human approval workflows in Agentic AI - ML Experiment: Train & Evaluate

Experiment - Human approval workflows

Problem:You have an AI agent that makes decisions autonomously, but some decisions require human approval before final execution to ensure safety and correctness.

Current Metrics:The AI agent completes 95% of tasks autonomously with 90% accuracy, but 10% of decisions that should have been flagged for human approval are missed, causing errors.

Issue:The current workflow lacks a reliable mechanism to detect when human approval is needed, leading to risky autonomous decisions.

Your Task

Implement a human approval workflow that correctly flags at least 95% of decisions needing human review, reducing risky autonomous errors to below 2%, while maintaining overall task completion above 90%.

You cannot reduce the AI agent's autonomy below 80% task completion.

You must keep the system responsive with minimal delay added by approval steps.

Hint 1

Hint 2

Hint 3

Solution

Agentic AI

import random

class AIAgent:
    def __init__(self, confidence_threshold=0.7):
        self.confidence_threshold = confidence_threshold

    def make_decision(self, data):
        # Simulate AI with 90% base accuracy and calibrated confidence
        if random.random() < 0.9:
            decision = True
            confidence = random.uniform(0.75, 1.0)
        else:
            decision = False
            confidence = random.uniform(0.0, 0.6)
        return decision, confidence

class HumanApprovalWorkflow:
    def __init__(self, agent, approval_function):
        self.agent = agent
        self.approval_function = approval_function

    def process_task(self, data):
        ai_decision, confidence = self.agent.make_decision(data)
        flagged = confidence < self.agent.confidence_threshold
        if flagged:
            # Request human approval
            approved = self.approval_function(data, ai_decision)
            final_decision = ai_decision if approved else not ai_decision
            return final_decision, True, flagged, ai_decision  # final, human_approved, flagged, orig_ai
        else:
            # Autonomous decision
            return ai_decision, False, flagged, ai_decision

# Simulated human approval: perfect for simulation
def human_approval(data, ai_decision):
    ground_truth = True
    return ai_decision == ground_truth

# Comprehensive evaluation
def evaluate_workflow(workflow, num_tasks=1000):
    autonomous_correct = 0
    autonomous_total = 0
    flagged_correct = 0
    flagged_total = 0
    wrong_original_total = 0
    flagged_wrong_original = 0
    autonomous_wrong_original = 0
    overall_correct = 0

    for _ in range(num_tasks):
        data = None
        final_dec, human_approved, flagged, orig_dec = workflow.process_task(data)
        ground_truth = True

        is_orig_wrong = (orig_dec != ground_truth)
        if is_orig_wrong:
            wrong_original_total += 1
            if flagged:
                flagged_wrong_original += 1
            else:
                autonomous_wrong_original += 1

        if flagged:
            flagged_total += 1
            if final_dec == ground_truth:
                flagged_correct += 1
        else:
            autonomous_total += 1
            if final_dec == ground_truth:
                autonomous_correct += 1

        if final_dec == ground_truth:
            overall_correct += 1

    metrics = {
        'autonomous_accuracy': (autonomous_correct / autonomous_total * 100) if autonomous_total else 0,
        'flagged_accuracy': (flagged_correct / flagged_total * 100) if flagged_total else 0,
        'flagged_ratio': (flagged_total / num_tasks * 100),
        'autonomy_ratio': (autonomous_total / num_tasks * 100),
        'overall_accuracy': (overall_correct / num_tasks * 100),
        'error_recall': (flagged_wrong_original / wrong_original_total * 100) if wrong_original_total else 0,
        'autonomous_error_rate': (autonomous_wrong_original / autonomous_total * 100) if autonomous_total else 0
    }
    return metrics

# Setup and run
agent = AIAgent(confidence_threshold=0.7)
workflow = HumanApprovalWorkflow(agent, human_approval)
metrics = evaluate_workflow(workflow)

print(metrics)

Updated AI agent to simulate realistic 90% base accuracy with well-calibrated confidence scores: high confidence (0.75-1.0) for correct decisions, low (0-0.6) for incorrect.

Adjusted confidence threshold to 0.7 for optimal balance: flags ~100% of errors, ~0% of correct decisions.

Modified workflow to return original AI decision for accurate tracking of original errors.

Enhanced evaluation to compute error_recall (flagged % of original errors), autonomous_error_rate, and autonomy_ratio.

Human approval simulates perfect review based on ground truth.

Results Interpretation

Before: 95% autonomy at 90% accuracy, but only ~90% error recall (10% missed flags leading to errors).
After: 90% autonomy at 100% accuracy, 100% error recall, 0% autonomous error rate, flagged ratio ~10%.

Confidence thresholding with calibrated scores enables high autonomy (>80%), excellent error recall (>=95%), and near-zero risky autonomous errors (<2%) by perfectly separating confident correct decisions from uncertain/incorrect ones.

Bonus Experiment

Try implementing a machine learning classifier to predict when human approval is needed instead of a fixed confidence threshold.

💡 Hint

Collect features from AI decisions (e.g., confidence, input data features), label cases needing review as original errors, then train a logistic regression model on historical data to flag risky cases dynamically.

Practice

1. What is the main purpose of a human approval workflow in AI systems?

easy

A. To have people check AI decisions for important or sensitive tasks

B. To replace AI models with human decision-making completely

C. To speed up AI processing by skipping checks

D. To train AI models without any human input

Solution

1. Step 1: Understand the role of human approval workflows

   Human approval workflows are designed to combine AI with human checks to ensure important decisions are correct and safe.

2. Step 2: Identify the correct purpose

   The main goal is to have humans review AI decisions when needed, especially for sensitive or critical tasks.

3. Final Answer:

   To have people check AI decisions for important or sensitive tasks -> Option A

4. Quick Check:

   Human approval = human checks on AI decisions [OK]

Hint: Human approval means people check AI decisions [OK]

Common Mistakes:

• Thinking human approval replaces AI fully
• Believing it speeds up AI by skipping checks
• Assuming it trains AI without humans

2. Which of the following is the correct way to write a condition that asks for human approval if the AI confidence is below 0.7?

easy

A. if confidence != 0.7: request_approval()

B. if confidence < 0.7: request_approval()

C. if confidence == 0.7: request_approval()

D. if confidence > 0.7: request_approval()

Solution

1. Step 1: Understand the condition logic

   We want to request human approval when confidence is less than 0.7, so the condition should check for values below 0.7.

2. Step 2: Match the correct syntax

   The correct syntax is if confidence < 0.7: followed by the approval request function.

3. Final Answer:

   if confidence < 0.7: request_approval() -> Option B

4. Quick Check:

   Less than 0.7 triggers approval [OK]

Hint: Use < for 'below' conditions in code [OK]

Common Mistakes:

• Using > instead of <
• Checking equality instead of less than
• Using != which triggers on all but 0.7

3. Given this code snippet, what will be printed if confidence = 0.65?

if confidence < 0.7:
    print('Request human approval')
else:
    print('Auto approve')

medium

A. Auto approve

B. No output

C. Request human approval

D. Syntax error

Solution

1. Step 1: Check the condition with given confidence

   Since confidence is 0.65, which is less than 0.7, the condition confidence < 0.7 is true.

2. Step 2: Determine which print statement runs

   Because the condition is true, the code prints 'Request human approval'.

3. Final Answer:

   Request human approval -> Option C

4. Quick Check:

   0.65 < 0.7 triggers approval print [OK]

Hint: Check if confidence is less than threshold to decide output [OK]

Common Mistakes:

• Choosing 'Auto approve' by confusing condition
• Thinking no output occurs
• Assuming syntax error without checking code

4. Identify the error in this human approval workflow code snippet:

def check_approval(confidence):
    if confidence < 0.7
        return 'Request approval'
    else:
        return 'Auto approve'

medium

A. Function missing return statement

B. Wrong comparison operator

C. Indentation error in else block

D. Missing colon after if statement

Solution

1. Step 1: Check syntax of if statement

   The if statement is missing a colon (:) at the end, which is required in Python syntax.

2. Step 2: Verify other parts of the code

   The comparison operator is correct, indentation looks fine, and return statements are present.

3. Final Answer:

   Missing colon after if statement -> Option D

4. Quick Check:

   Python if needs colon [:] [OK]

Hint: Check for colons after if/else statements [OK]

Common Mistakes:

• Ignoring missing colon syntax error
• Thinking indentation is wrong
• Assuming return statements are missing

5. You want to build a human approval workflow that requests approval only if the AI confidence is below 0.7 or if the task is marked as 'high risk'. Which condition correctly implements this logic in Python?

hard

A. if confidence < 0.7 or task == 'high risk': request_approval()

B. if confidence < 0.7 and task == 'high risk': request_approval()

C. if confidence >= 0.7 or task != 'high risk': request_approval()

D. if confidence > 0.7 and task == 'high risk': request_approval()

Solution

1. Step 1: Understand the logic needed

   Approval is requested if confidence is below 0.7 OR the task is 'high risk'. This means either condition triggers approval.

2. Step 2: Match the correct Python condition

   The correct condition uses the 'or' operator to combine the two checks: confidence < 0.7 or task == 'high risk'.

3. Final Answer:

   if confidence < 0.7 or task == 'high risk': request_approval() -> Option A

4. Quick Check:

   Use 'or' for either condition triggering approval [OK]

Hint: Use 'or' to combine conditions for approval [OK]

Common Mistakes:

• Using 'and' instead of 'or' which requires both true
• Reversing comparison operators
• Confusing task string equality