Explotación de la confianza humano-agente

Descripción

Los agentes presentan recomendaciones dañinas, incorrectas o manipuladoras con una autoridad injustificada, explotando la tendencia humana a confiar en la salida de la IA y a aprobar automáticamente las decisiones del agente sin una revisión crítica.

Mitigaciones

Indicadores de confianza

Obligar a los agentes a comunicar su incertidumbre de forma explícita:

• Exigir que los agentes proporcionen una puntuación de confianza (con su metodología) junto con cada recomendación
• Mostrar la incertidumbre de forma visual (banners con código de colores, rangos de probabilidad) para que los usuarios puedan identificar rápidamente las salidas de baja confianza
• Entrenar a los agentes para distinguir entre conclusiones 'verificadas' (procedentes de datos autorizados), 'inferidas' (derivadas mediante razonamiento) e 'inciertas' (con poca evidencia)
• Nunca permitir que los agentes presenten afirmaciones sin fuente como hechos — todas las afirmaciones deben etiquetarse con su base de evidencia

Puntos de revisión obligatorios

Estructurar los flujos de trabajo para evitar aprobaciones automáticas sin verdadero escrutinio:

• Implementar demoras de tiempo antes de que las recomendaciones de agentes de alto impacto puedan aprobarse (período de enfriamiento obligatorio)
• Exigir que los revisores respondan preguntas de verificación específicas sobre la recomendación antes de aprobarla (no solo 'Aprobar/Rechazar')
• Rotar a los revisores para evitar la complacencia basada en la familiaridad
• Implementar auditorías aleatorias: un porcentaje de las recomendaciones 'aprobadas' se vuelve a revisar de forma independiente por un segundo humano o un agente adversario

Fricción para acciones de alto riesgo

Aumentar la fricción de forma proporcional a la severidad de la acción:

• Clasificar las acciones del agente en niveles de riesgo (bajo/medio/alto/crítico) con los requisitos de aprobación correspondientes
• Riesgo bajo: el agente actúa de forma autónoma con auditoría posterior
• Riesgo medio: el agente actúa con notificación simultánea al revisor
• Riesgo alto: el agente recomienda, el humano debe aprobar explícitamente con una justificación
• Riesgo crítico: se requiere doble aprobación humana, el agente no puede actuar solo
• Exigir autenticación adicional (reingreso de contraseña, desafío MFA) para las aprobaciones críticas

Capa de revisión adversaria

Utilizar un segundo agente para cuestionar al primero:

• Desplegar un agente de 'red team' cuyo rol sea encontrar fallas en las recomendaciones del agente principal
• Presentar la recomendación principal y la crítica adversaria en paralelo al revisor humano
• Exigir que el humano aborde explícitamente las objeciones adversarias antes de aprobar
• Rotar entre diferentes modelos adversarios para prevenir la colusión

Verificación de fuentes

Validar las afirmaciones del agente antes de presentarlas a los usuarios:

• Verificar automáticamente las citas, URL y referencias de datos en las salidas del agente
• Marcar las salidas que hagan referencia a fuentes inexistentes, citen erróneamente las fuentes o extrapolen más allá del material fuente
• Proporcionar enlaces directos al material fuente para que los revisores puedan verificar puntualmente sin necesidad de una búsqueda manual

Ejemplos de código

Puerta de confirmación basada en riesgo

import time
import hashlib
from enum import Enum
from dataclasses import dataclass, field
from typing import Optional, Callable


class NivelRiesgo(Enum):
    BAJO = 1       # El agente actúa y registra para auditoría
    MEDIO = 2      # El agente actúa y notifica al revisor
    ALTO = 3       # El agente recomienda, el humano aprueba
    CRITICO = 4    # Se requiere doble aprobación


@dataclass
class RecomendacionAgente:
    accion: str
    justificacion: str
    confianza: float  # 0.0 a 1.0
    fuentes_evidencia: list[str]
    nivel_riesgo: NivelRiesgo
    id_agente: str
    timestamp: float = field(default_factory=time.time)
    id_recomendacion: str = ""

    def __post_init__(self):
        if not self.id_recomendacion:
            carga = f"{self.id_agente}:{self.accion}:{self.timestamp}"
            self.id_recomendacion = hashlib.sha256(carga.encode()).hexdigest()[:12]


@dataclass
class DecisionAprobacion:
    id_recomendacion: str
    aprobado: bool
    id_revisor: str
    justificacion: str  # El revisor debe explicar su decisión
    respuestas_preguntas: dict[str, str]  # Respuestas a las preguntas de verificación
    timestamp: float = field(default_factory=time.time)


class PuertaConfirmacion:
    """Exige una revisión humana proporcional al riesgo para las recomendaciones de los agentes."""

    def __init__(self):
        self._pendientes: dict[str, RecomendacionAgente] = {}
        self._decisiones: list[DecisionAprobacion] = []
        self._preguntas_verificacion: dict[NivelRiesgo, list[str]] = {
            NivelRiesgo.ALTO: [
                "¿Qué podría salir mal si esta recomendación es incorrecta?",
                "¿Ha verificado de forma independiente las afirmaciones clave?",
            ],
            NivelRiesgo.CRITICO: [
                "¿Qué podría salir mal si esta recomendación es incorrecta?",
                "¿Ha verificado de forma independiente las afirmaciones clave?",
                "¿Cuál es el plan de reversión si esta acción falla?",
                "¿Ha consultado al experto de dominio correspondiente?",
            ],
        }
        self._segundos_enfriamiento: dict[NivelRiesgo, int] = {
            NivelRiesgo.BAJO: 0,
            NivelRiesgo.MEDIO: 0,
            NivelRiesgo.ALTO: 300,     # 5 minutos de enfriamiento
            NivelRiesgo.CRITICO: 900,  # 15 minutos de enfriamiento
        }

    def enviar_recomendacion(self, rec: RecomendacionAgente) -> dict:
        """Envía una recomendación del agente para su revisión."""
        # Riesgo bajo: aprobación automática con registro de auditoría
        if rec.nivel_riesgo == NivelRiesgo.BAJO:
            return {
                "estado": "aprobado_automaticamente",
                "id_recomendacion": rec.id_recomendacion,
                "auditoria": True,
            }

        # Riesgo medio: aprobación con notificación
        if rec.nivel_riesgo == NivelRiesgo.MEDIO:
            return {
                "estado": "aprobado_con_notificacion",
                "id_recomendacion": rec.id_recomendacion,
                "notificar": True,
            }

        # Alto y crítico: se requiere aprobación humana explícita
        self._pendientes[rec.id_recomendacion] = rec
        preguntas = self._preguntas_verificacion.get(rec.nivel_riesgo, [])
        enfriamiento = self._segundos_enfriamiento.get(rec.nivel_riesgo, 0)

        return {
            "estado": "aprobacion_pendiente",
            "id_recomendacion": rec.id_recomendacion,
            "nivel_riesgo": rec.nivel_riesgo.name,
            "confianza": rec.confianza,
            "preguntas_verificacion": preguntas,
            "enfriamiento_hasta": time.time() + enfriamiento,
            "requiere_doble_aprobacion": rec.nivel_riesgo == NivelRiesgo.CRITICO,
        }

    def procesar_aprobacion(
        self, decision: DecisionAprobacion
    ) -> dict:
        """Procesa la decisión de aprobación de un revisor humano."""
        rec = self._pendientes.get(decision.id_recomendacion)
        if not rec:
            return {"error": "Recomendación no encontrada o ya procesada"}

        # Aplicar el período de enfriamiento
        enfriamiento = self._segundos_enfriamiento.get(rec.nivel_riesgo, 0)
        transcurrido = decision.timestamp - rec.timestamp
        if transcurrido < enfriamiento:
            return {
                "error": f"El período de enfriamiento no ha transcurrido ({transcurrido:.0f}s / {enfriamiento}s)",
            }

        # Verificar que las preguntas de verificación estén respondidas
        preguntas_requeridas = self._preguntas_verificacion.get(rec.nivel_riesgo, [])
        for pregunta in preguntas_requeridas:
            if pregunta not in decision.respuestas_preguntas:
                return {"error": f"Pregunta de verificación sin responder: {pregunta}"}
            if len(decision.respuestas_preguntas[pregunta].strip()) < 10:
                return {"error": f"Respuesta insuficiente para: {pregunta}"}

        # Exigir justificación
        if len(decision.justificacion.strip()) < 20:
            return {"error": "La justificación de la aprobación es demasiado breve — explique su razonamiento"}

        self._decisiones.append(decision)

        if decision.aprobado:
            del self._pendientes[decision.id_recomendacion]
            return {"estado": "aprobado", "id_recomendacion": decision.id_recomendacion}
        else:
            del self._pendientes[decision.id_recomendacion]
            return {"estado": "rechazado", "id_recomendacion": decision.id_recomendacion}

Requisitos de evidencia

• Rastro de auditoría de recomendaciones con puntuaciones de confianza, fuentes de evidencia y decisiones de los revisores
• Registros de respuestas a las preguntas de verificación que demuestran una revisión humana sustantiva
• Analítica de tiempos de aprobación que muestra el cumplimiento de los períodos de enfriamiento
• Resultados de auditorías de re-revisión aleatoria que miden las tasas de aprobación automática sin escrutinio
• Informes de verificación de fuentes que muestran los porcentajes de exactitud de las citas
• Métricas de calidad de decisiones que comparan los resultados recomendados por el agente frente a los anulados por humanos