FULLY HUMAN          HUMAN-IN-LOOP         SUPERVISED AUTO        FULLY AUTONOMOUS
     │                     │                      │                      │
     │                     │                      │                      │
Human does          Human approves          Human monitors,          Agent runs
everything          every action            alerts on anomaly         24/7 unmonitored
                    before execution        only

EXAMPLES:
Meeting notes       Sending client emails   Scheduling social       Log rotation scripts
Manual data entry   Making purchases        posts                   Simple data fetching
Creative decisions  Deleting data           Generating reports      Internal notifications

import anthropic
import json
import time
import os

client = anthropic.Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))

class HumanApprovalRequired(Exception):
    """Raised when an action requires human approval before proceeding"""
    def __init__(self, action_description: str, action_data: dict):
        self.action_description = action_description
        self.action_data = action_data

HIGH_RISK_ACTIONS = [
    "send_email",
    "send_whatsapp",
    "make_payment",
    "delete_record",
    "publish_content"
]

def execute_with_approval_gate(action_name: str, action_params: dict):
    """Execute action — pause for human approval if high-risk"""

    if action_name in HIGH_RISK_ACTIONS:
        # Present action for human review
        print(f"\n{'='*50}")
        print(f"[APPROVAL REQUIRED] Action: {action_name}")
        print(f"Parameters: {json.dumps(action_params, indent=2)}")
        print(f"{'='*50}")

        approval = input("Approve this action? (yes/no/edit): ").strip().lower()

        if approval == "yes":
            print(f"[APPROVED] Executing {action_name}...")
            return _execute_action(action_name, action_params)
        elif approval == "edit":
            # Allow human to modify parameters
            print("Enter modified parameters as JSON:")
            modified = json.loads(input())
            return _execute_action(action_name, modified)
        else:
            print(f"[REJECTED] Action {action_name} was rejected by human reviewer.")
            return {"status": "rejected", "reason": "human_rejection"}
    else:
        # Low-risk actions execute without approval
        return _execute_action(action_name, action_params)

def _execute_action(action_name: str, params: dict):
    """Actually execute the action"""
    print(f"[EXECUTING] {action_name}")
    # Real execution code would go here
    return {"status": "success", "action": action_name}

TASK                              RISK LEVEL    AUTONOMY MODE
────────────────────────────────────────────────────────────
Daily social media posts          Low           Fully autonomous
Generating reports                Low           Fully autonomous
Responding to common FAQ DMs      Low           Supervised auto
Scheduling meetings               Low           Supervised auto
Following up with leads           Medium        Human-in-loop
Sending client proposals          High          Human-in-loop
Making vendor payments            High          Human-in-loop
Responding to complaints          High          Human-in-loop
Deleting customer records         Critical      Human-in-loop
Publishing to official channels   High          Human-in-loop
Sending emails on behalf of CEO   Critical      Human-in-loop

def escalation_handler(agent_result: dict, confidence_score: float):
    """Route based on agent confidence and task risk"""

    if confidence_score >= 0.95 and agent_result.get("risk_level") == "low":
        # Auto-execute: high confidence, low risk
        return "AUTO_EXECUTE"

    elif confidence_score >= 0.80 and agent_result.get("risk_level") == "medium":
        # Notify and wait: good confidence, medium risk
        send_notification(f"Agent completed task with {confidence_score:.0%} confidence. Review within 2 hours or it will auto-approve.")
        return "PENDING_REVIEW"

    else:
        # Full stop: low confidence or high risk
        send_notification(f"Agent requires human review: {agent_result.get('explanation')}")
        return "MANUAL_REQUIRED"

AUTONOMY MATRIX FOR PAKISTAN OUTREACH:
┌─────────────────────────────────────────────────────┐
│  ACTION              │ RISK  │ AUTONOMY MODE        │
│  ───────────────────────────────────────────────── │
│  Google Maps scraping │ LOW   │ FULLY AUTO           │
│  PSI audit           │ LOW   │ FULLY AUTO            │
│  Draft email         │ LOW   │ FULLY AUTO + LOG      │
│  Send email (cold)   │ MED   │ NOTIFY → 30min timer  │
│  Draft WhatsApp msg  │ MED   │ NOTIFY + HUMAN REVIEW │
│  Send WhatsApp (cold)│ HIGH  │ MANUAL APPROVAL ONLY  │
│  Book appointment    │ HIGH  │ MANUAL APPROVAL ONLY  │
│  Post on social media│ CRIT  │ MANUAL APPROVAL ONLY  │
└─────────────────────────────────────────────────────┘

DECIDING AUTONOMY LEVEL FOR ANY ACTION:

Step 1: Is the action reversible?
  YES → Can consider higher automation
  NO  → Require human approval (minimum: timer + notification)

Step 2: What is the cost of error?
  <PKR 500 → LOW risk, auto-execute
  PKR 500-5,000 → MEDIUM risk, notify + timer
  >PKR 5,000 → HIGH risk, manual approval
  Reputational → CRITICAL, always manual

Step 3: How often does this action occur?
  >100/day → Justify higher automation (human can't review all)
  <10/day → Manual is feasible and recommended

Step 4: Has this exact action been tested 50+ times without error?
  YES → Can reduce autonomy constraint by one level
  NO  → Maintain current constraint level

Final Rule: When in doubt, add a human gate.
The 5 minutes of human review time costs less than one bad automated action.

# Minimal production monitoring pattern
import datetime
import json

class AgentMonitor:
    """Track agent actions, anomalies, and escalations"""

    def __init__(self, log_file="agent_actions.jsonl"):
        self.log_file = log_file
        self.action_counts = {}

    def log_action(self, action: str, result: str, confidence: float, autonomy_mode: str):
        """Log every agent action with metadata"""
        entry = {
            "timestamp": datetime.datetime.now().isoformat(),
            "action": action,
            "result": result,
            "confidence": confidence,
            "autonomy_mode": autonomy_mode,
            "flagged": confidence < 0.75 or autonomy_mode == "MANUAL_REQUIRED"
        }
        with open(self.log_file, "a") as f:
            f.write(json.dumps(entry) + "\n")

        # Alert on anomalies
        if entry["flagged"]:
            print(f"[ALERT] Low confidence action: {action} ({confidence:.0%})")

    def weekly_report(self):
        """Summarize agent performance for weekly review"""
        # Read log, count actions, calculate error rate
        # Return summary dict for human review
        pass