Ethics and responsible AI

AI agents inherit biases from their training data, their developers, and their deployment context. Bias is not a bug that you fix once. It is a continuous challenge that requires ongoing attention.

Types of bias to watch for

1. Selection bias. Training data does not represent the population the agent will serve

2. Confirmation bias. The agent reinforces the user's existing beliefs

3. Automation bias. Users over-trust agent outputs without verification

4. Anchoring bias. First pieces of information disproportionately influence outputs

Practical mitigation

The EU AI Act and emerging global regulations share a common principle. Humans must remain in control of consequential decisions. AI agents should augment human judgement, not replace it.

When human oversight is required

| Action Type | Risk Level | Required Oversight | |-------------|------------|-------------------| | Information retrieval | Low | None required | | Content generation | Medium | Periodic review | | Sending communications | High | Pre-approval | | Financial transactions | Critical | Dual approval | | System modifications | Critical | Admin + confirmation |

"""
Human-in-the-Loop Implementation
=================================
Approval workflows for high-risk agent actions.
"""

from enum import Enum
from typing import Callable, Optional
from dataclasses import dataclass, field
from datetime import datetime, timezone
import uuid


class ApprovalStatus(Enum):
    """Status of an approval request."""
    PENDING = "pending"
    APPROVED = "approved"
    REJECTED = "rejected"
    EXPIRED = "expired"
    AUTO_APPROVED = "auto_approved"


class RiskLevel(Enum):
    """Risk levels for agent actions."""
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"
    CRITICAL = "critical"


@dataclass
class ApprovalRequest:
    """A request for human approval."""
    id: str
    action_type: str
    description: str
    parameters: dict
    risk_level: RiskLevel
    requested_by: str  # User or agent ID
    requested_at: str
    expires_at: Optional[str] = None
    status: ApprovalStatus = ApprovalStatus.PENDING
    reviewed_by: Optional[str] = None
    reviewed_at: Optional[str] = None
    review_notes: Optional[str] = None


class HumanOversightManager:
    """
    Manages human-in-the-loop approval workflows.
    
    Actions above a certain risk threshold require human approval
    before the agent can proceed.
    """
    
    # Default approval requirements by risk level
    APPROVAL_REQUIREMENTS = {
        RiskLevel.LOW: False,        # Auto-approved
        RiskLevel.MEDIUM: False,     # Auto-approved but logged
        RiskLevel.HIGH: True,        # Requires approval
        RiskLevel.CRITICAL: True,    # Requires dual approval
    }
    
    def __init__(
        self, 
        notify_callback: Optional[Callable[[ApprovalRequest], None]] = None
    ):
        """
        Initialise oversight manager.
        
        Args:
            notify_callback: Function to notify approvers of pending requests
        """
        self.pending_requests: dict[str, ApprovalRequest] = {}
        self.notify_callback = notify_callback
    
    def request_approval(
        self,
        action_type: str,
        description: str,
        parameters: dict,
        risk_level: RiskLevel,
        requested_by: str,
        timeout_seconds: int = 3600,
    ) -> ApprovalRequest:
        """
        Request human approval for an action.
        
        Args:
            action_type: Type of action (e.g., "send_email")
            description: Human-readable description
            parameters: Action parameters for review
            risk_level: Risk level of the action
            requested_by: ID of requesting user/agent
            timeout_seconds: How long approval is valid
            
        Returns:
            ApprovalRequest that can be checked for status
        """
        now = datetime.now(timezone.utc)
        
        request = ApprovalRequest(
            id=str(uuid.uuid4()),
            action_type=action_type,
            description=description,
            parameters=parameters,
            risk_level=risk_level,
            requested_by=requested_by,
            requested_at=now.isoformat(),
            expires_at=(now.timestamp() + timeout_seconds).__str__(),
        )
        
        # Check if approval is required
        if not self.APPROVAL_REQUIREMENTS.get(risk_level, True):
            request.status = ApprovalStatus.AUTO_APPROVED
            request.review_notes = "Auto-approved due to low risk level"
            return request
        
        # Store pending request
        self.pending_requests[request.id] = request
        
        # Notify approvers
        if self.notify_callback:
            self.notify_callback(request)
        
        return request
    
    def approve(
        self,
        request_id: str,
        approver_id: str,
        notes: Optional[str] = None,
    ) -> bool:
        """
        Approve a pending request.
        
        Args:
            request_id: ID of the request to approve
            approver_id: ID of the approving user
            notes: Optional approval notes
            
        Returns:
            True if approval was recorded
        """
        if request_id not in self.pending_requests:
            return False
        
        request = self.pending_requests[request_id]
        
        if request.status != ApprovalStatus.PENDING:
            return False
        
        request.status = ApprovalStatus.APPROVED
        request.reviewed_by = approver_id
        request.reviewed_at = datetime.now(timezone.utc).isoformat()
        request.review_notes = notes
        
        return True
    
    def reject(
        self,
        request_id: str,
        approver_id: str,
        reason: str,
    ) -> bool:
        """
        Reject a pending request.
        
        Args:
            request_id: ID of the request to reject
            approver_id: ID of the rejecting user
            reason: Reason for rejection
            
        Returns:
            True if rejection was recorded
        """
        if request_id not in self.pending_requests:
            return False
        
        request = self.pending_requests[request_id]
        
        if request.status != ApprovalStatus.PENDING:
            return False
        
        request.status = ApprovalStatus.REJECTED
        request.reviewed_by = approver_id
        request.reviewed_at = datetime.now(timezone.utc).isoformat()
        request.review_notes = reason
        
        return True
    
    def check_status(self, request_id: str) -> Optional[ApprovalRequest]:
        """Check the current status of an approval request."""
        return self.pending_requests.get(request_id)
    
    def is_approved(self, request_id: str) -> bool:
        """Check if a request has been approved."""
        request = self.pending_requests.get(request_id)
        if not request:
            return False
        return request.status in (ApprovalStatus.APPROVED, ApprovalStatus.AUTO_APPROVED)

AI regulation is evolving rapidly. Several major frameworks affect how AI agents should be built and deployed.

EU AI Act. What you actually need to know

The EU AI Act is the strongest current regulatory anchor for teams building systems that touch EU users or markets. Use the European Commission timeline as the source of truth, because summaries get simplified fast ^[Source].

Other frameworks worth knowing

Beyond the EU AI Act, a few other references matter because they shape how responsible teams build and deploy agents.

This is a practical checklist I use before I ship an agent into a real organisation. It is not legal advice. It is a way to avoid the most common self inflicted problems.

This assessment closes the security and ethics stage. It checks whether you can identify realistic threat paths, justify layered controls, and keep human accountability clear when automation is involved.

In this stage, you have learned:

1. The threat landscape for AI agents, including prompt injection, supply chain vulnerabilities, and risk-based deployment classification

2. Secure implementation practices including input/output validation, authentication and authorisation, and comprehensive audit logging

3. Ethical considerations including bias detection, human oversight requirements, and regulatory compliance