AI Engineering Academy · Leçon

Escalade avec intervention humaine

Définissez des déclencheurs d’escalade qui mettent l’agent en pause et demandent l’aide d’un humain lorsque la confiance est faible, qu’une action destructive est imminente ou que le budget de nouvelles tentatives est épuisé.

Leçon 4 sur 413 étapes

Escalade avec intervention humaine est une leçon AI Engineering Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Engineering Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Engineering Academy comprend 4 leçons au total.

Quand les agents ont besoin de conseils humains

Les agents entièrement autonomes conviennent aux tâches bien définies et peu risquées. Cependant, certaines situations exigent un jugement humain : instructions ambiguës, faible confiance du modèle, actions destructrices impossibles à annuler ou tâches dont l’échec aurait de graves conséquences. L’escalade avec intervention humaine (HITL) interrompt l’agent à ces points de décision et demande l’avis d’une personne avant de poursuivre, combinant l’efficacité de l’automatisation avec le jugement humain.

Définir les déclencheurs d’escalade

L’escalade doit être déclenchée par des conditions précises et mesurables, plutôt que par une intuition vague. Définissez des déclencheurs d’escalade explicites pour votre application. Parmi les déclencheurs courants figurent : une confiance du modèle inférieure à un seuil, une action destructrice sur le point d’être exécutée, l’approche d’une limite de politique, l’épuisement du budget de nouvelles tentatives ou le dépassement de la limite de temps de la tâche. Documentez les déclencheurs dans le code sous forme de constantes nommées afin de pouvoir les ajuster sans modifier la logique du flux de contrôle.

from enum import Enum

class EscalationReason(Enum):
    LOW_CONFIDENCE = 'low_confidence'           # model uncertainty
    DESTRUCTIVE_ACTION = 'destructive_action'   # irreversible change
    AMBIGUOUS_TASK = 'ambiguous_task'           # unclear instructions
    RETRY_BUDGET_EXHAUSTED = 'retry_exhausted'  # too many failures
    POLICY_BOUNDARY = 'policy_boundary'         # approaching limit
    HUMAN_REQUESTED = 'human_requested'         # explicit request
    TIMEOUT = 'timeout'                         # took too long

ESCALATION_THRESHOLDS = {
    'min_confidence': 0.6,
    'max_retries': 5,
    'max_runtime_minutes': 30,
}

Détecter une faible confiance

Demandez au modèle d’exprimer sa confiance dans une action proposée avant de l’exécuter. Un score de confiance inférieur à votre seuil déclenche une escalade. Utilisez une vérification structurée de la confiance comprenant à la fois un score numérique et une brève justification, afin que la personne chargée de l’examen comprenne précisément pourquoi l’agent était incertain. Cette justification permet de fournir des conseils ciblés sans devoir examiner l’intégralité de l’historique de la tâche.

from pydantic import BaseModel

class ConfidenceCheck(BaseModel):
    proposed_action: str
    confidence: float  # 0.0 to 1.0
    uncertainty_reason: str | None
    proceed: bool

async def check_confidence(context: str, proposed_action: str) -> ConfidenceCheck:
    return await judge_client.chat.completions.create(
        model='gpt-4o',
        response_model=ConfidenceCheck,
        messages=[{
            'role': 'user',
            'content': f'Context: {context}\n\nI am about to: {proposed_action}\n\nHow confident am I that this is correct? Be honest about uncertainty.'
        }]
    )

Détecter les actions destructrices

Marquez les outils qui exécutent des actions irréversibles avec un indicateur destructive=True et exigez une confirmation humaine avant leur exécution. Exemples : supprimer des fichiers, envoyer des courriels à de vrais utilisateurs, effectuer des modifications de base de données impossibles à annuler, facturer un client ou publier du contenu publiquement. L’agent doit s’arrêter au niveau de ces actions et attendre une approbation humaine explicite, même s’il fonctionne par ailleurs de manière autonome.

from dataclasses import dataclass
from typing import Callable

@dataclass
class Tool:
    name: str
    func: Callable
    destructive: bool = False
    description: str = ''

tools = [
    Tool('search_web',     search_web,      destructive=False),
    Tool('read_file',      read_file,       destructive=False),
    Tool('write_file',     write_file,      destructive=True,  description='Overwrites existing file'),
    Tool('send_email',     send_email,      destructive=True,  description='Sends real email to user'),
    Tool('delete_records', delete_records,  destructive=True,  description='Permanent DB deletion'),
]

def requires_approval(tool: Tool) -> bool:
    return tool.destructive

Mettre l’agent en pause et attendre une réponse

Lorsqu’un déclencheur d’escalade s’active, enregistrez le point de contrôle (afin que la tâche puisse reprendre), créez un enregistrement de demande d’escalade et avertissez la personne chargée de l’examen. L’agent cesse son traitement et attend. Cette personne examine l’escalade via un tableau de bord ou une notification, fournit des instructions ou une approbation, puis l’agent reprend depuis le point de contrôle, ces instructions étant incluses comme nouveau message dans l’historique.

import asyncio

async def escalate_and_wait(task_id: str, reason: EscalationReason, context: str,
                             question: str, timeout_hours: int = 24) -> str:
    # Save checkpoint
    save_checkpoint(load_checkpoint(task_id))
    # Create escalation record
    escalation_id = create_escalation(task_id, reason, context, question)
    # Notify reviewer
    notify_reviewer(escalation_id, question)
    # Wait for response (polling with timeout)
    deadline = asyncio.get_event_loop().time() + timeout_hours * 3600
    while asyncio.get_event_loop().time() < deadline:
        response = get_escalation_response(escalation_id)
        if response:
            return response.guidance
        await asyncio.sleep(60)  # check every minute
    raise TimeoutError(f'Escalation {escalation_id} not answered within {timeout_hours}h')

Créer l’interface de la personne chargée de l’examen

Les réviseurs humains ont besoin d'une interface simple pour répondre aux escalades. Au minimum, affichez : la description de la tâche, la progression de l'agent jusqu'à présent, la question précise ou l'action proposée nécessitant une approbation, ainsi que des boutons pour approuver, rejeter et fournir des directives. Consignez chaque décision du réviseur avec son identité et l'horodatage à des fins d'audit. Un bot Slack ou un simple formulaire web conviennent tous deux très bien aux équipes internes.

# FastAPI escalation endpoint
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class EscalationResponse(BaseModel):
    escalation_id: str
    decision: str  # 'approve', 'reject', 'guide'
    guidance: str | None = None
    reviewer_id: str

@app.post('/escalations/{escalation_id}/respond')
async def respond_to_escalation(esc_id: str, response: EscalationResponse):
    escalation = get_escalation(esc_id)
    if not escalation or escalation.status != 'pending':
        return {'error': 'Escalation not found or already resolved'}
    save_escalation_response(esc_id, response)
    return {'status': 'response_recorded', 'task_will_resume': True}

Injecter les directives humaines dans le contexte de l'agent

Après la réponse de l'humain, injectez ses directives sous forme d'un nouveau message dans l'historique de conversation de l'agent avant de reprendre l'exécution. Présentez-les comme provenant d'un « superviseur » afin de les distinguer des propres observations de l'agent. Celui-ci pourra alors s'y référer à l'étape suivante. Si l'humain a rejeté l'action proposée, indiquez ce qu'il faut faire à la place.

def inject_human_guidance(messages: list, decision: str, guidance: str | None) -> list:
    if decision == 'approve':
        messages.append({
            'role': 'user',
            'content': 'Supervisor: Your proposed action has been approved. Proceed.'
        })
    elif decision == 'reject':
        messages.append({
            'role': 'user',
            'content': f'Supervisor: Your proposed action was rejected. Instead: {guidance}'
        })
    elif decision == 'guide':
        messages.append({
            'role': 'user',
            'content': f'Supervisor: Additional guidance: {guidance}'
        })
    return messages

Suivre les indicateurs d'escalade

Surveillez le volume des escalades, leurs motifs et les délais de réponse. Un volume élevé indique que l'agent n'est pas suffisamment sûr de lui : la tâche est peut-être trop ambiguë, le modèle a besoin de meilleures instructions ou les seuils de confiance sont trop bas. Des délais de réponse longs indiquent une surcharge de travail des réviseurs. Ces indicateurs vous aident à ajuster l'équilibre entre automatisation et intervention humaine afin de réduire les interruptions inutiles tout en maintenant l'intervention humaine pour les décisions réellement risquées.

def escalation_report(db_connection, days: int = 7) -> dict:
    # SQL query (pseudocode)
    rows = db_connection.execute('''
        SELECT
            reason,
            COUNT(*) as count,
            AVG(EXTRACT(EPOCH FROM (responded_at - created_at)) / 3600) as avg_response_hours,
            SUM(CASE WHEN decision = 'approve' THEN 1 ELSE 0 END) as approvals,
            SUM(CASE WHEN decision = 'reject' THEN 1 ELSE 0 END) as rejections
        FROM escalations
        WHERE created_at > NOW() - INTERVAL '%s days'
        GROUP BY reason
        ORDER BY count DESC
    ''' % days).fetchall()
    return [dict(r) for r in rows]

Étendre progressivement l'autonomie

Commencez avec une forte sensibilité aux escalades (seuil de confiance bas et escalade pour toute action destructive), puis réduisez progressivement leur fréquence à mesure que vous gagnez confiance dans le comportement de l'agent. Suivez les escalades qui aboutissent à une approbation par rapport à celles qui entraînent des corrections réelles. Un taux d'approbation constamment élevé pour un type de déclencheur donné signifie que vous pouvez automatiser ce déclencheur en toute sécurité, ce qui réduit la charge de travail humaine tout en conservant une supervision là où elle est réellement nécessaire.

# Autonomy expansion strategy:
# Week 1: escalate for ALL destructive actions
# Week 2: auto-approve file writes to /tmp (low-risk), escalate others
# Week 4: auto-approve all file writes, escalate only email/DB changes
# Week 8: auto-approve emails under 10 recipients, escalate mass emails

# Track approval rates per trigger type:
# Tool: write_file    -> 98% approve -> safe to automate
# Tool: send_email    -> 89% approve -> near-automate with content check
# Tool: delete_records -> 43% approve -> always escalate

Remplacement d'urgence et annulation des tâches

Prévoyez toujours un mécanisme de remplacement d'urgence permettant à un humain d'annuler immédiatement une tâche d'agent en cours. Si un agent se comporte mal — en appelant des outils qu'il ne devrait pas utiliser ou en effectuant des actions hors de son périmètre prévu — un humain doit pouvoir l'arrêter en quelques secondes. Implémentez un signal d'annulation (un indicateur en base de données que l'agent vérifie à chaque étape) et assurez-vous que les résultats des appels d'outils sont ignorés si l'agent est annulé en cours d'étape.

async def run_agent_with_cancel(task_id: str, messages: list) -> str:
    for step in range(MAX_ITERATIONS):
        # Check cancel flag at start of every step
        if redis_client.get(f'agent:cancel:{task_id}'):
            save_final_status(task_id, 'cancelled')
            return 'Task cancelled by operator.'
        response = await get_next_action(messages)
        if response.is_final:
            return response.answer
        result = await execute_tool(response.tool, response.args)
        messages.append({'role': 'user', 'content': result})
        save_checkpoint_after_step(task_id, step, messages)
    return 'Max iterations reached'

Étalonner les seuils d'escalade

Les seuils d'escalade doivent être ajustés. Si le seuil de confiance est trop élevé, l'agent déclenche une escalade pour presque chaque action, ce qui submerge les réviseurs. S'il est trop bas, des actions risquées passent au travers. Commencez avec des seuils prudents pendant la première semaine, suivez le volume des escalades et le taux d'approbation des réviseurs, puis ajustez-les. Un système stable devrait déclencher une escalade pour 5 à 15 % des tâches en raison d'un problème de confiance et pour près de 100 % des actions destructives, avec un taux d'approbation global supérieur à 80 %.

# Threshold tuning guide:
# Escalation rate vs quality trade-off:
#
# confidence_threshold=0.8  -> 35% escalation rate (too many)
# confidence_threshold=0.6  -> 12% escalation rate (target)
# confidence_threshold=0.4  ->  4% escalation rate (too few)
#
# Weekly review of escalation decisions:
# - Approval rate > 90%: lower threshold (too conservative)
# - Approval rate < 70%: raise threshold (not catching real issues)
# - Target: 75-85% approval rate

Vérification rapide

Testez votre compréhension de la conception des escalades avec intervention humaine.

Récapitulatif de la leçon

Dans cette leçon, vous avez appris que les déclencheurs d'escalade définissent les conditions précises dans lesquelles l'agent doit se mettre en pause et demander des directives humaines, que les indicateurs d'action destructive sur les outils imposent des exigences d'approbation pour les opérations irréversibles, et que l'extension progressive de l'autonomie permet d'augmenter l'automatisation en toute sécurité à mesure que l'agent gagne la confiance. Nous allons maintenant concevoir l'architecture de production de notre projet de synthèse.

Gratuit pour commencer

Apprends Python avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours
30
Leçons
120

Questions Fréquemment Posées

La leçon « Escalade avec intervention humaine » est-elle gratuite ?

Oui — le texte complet de « Escalade avec intervention humaine » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Engineering Academy, passe à CoddyKit PRO. Le cours AI Engineering Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Escalade avec intervention humaine » ?

Définissez des déclencheurs d’escalade qui mettent l’agent en pause et demandent l’aide d’un humain lorsque la confiance est faible, qu’une action destructive est imminente ou que le budget de nouvel… Tu pratiques AI Engineering Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Engineering Academy ?

Aucune expérience préalable n'est requise. AI Engineering Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Escalade avec intervention humaine » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Engineering Academy ?

Oui. Chaque leçon AI Engineering Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Classer les modes de défaillance des agents
  2. Autocorrection et invites réflexives
  3. Points de contrôle et reprise des tâches
  4. Escalade avec intervention humaine
← Retour à AI Engineering Academy