Agents avec raisonnement (GPT-5.6 Sol, effort high à max) — Construire des Agents OpenAI

Agents avec raisonnement (GPT-5.6, effort high à max)

Avec la famille GPT-5.6 (disponible depuis juillet 2026), le raisonnement n’est plus porté par des modèles séparés comme dans la génération précédente (o3-pro, o4-mini) : c’est un réglage par requête (none, low, medium, high, xhigh, max) applicable à chaque modèle. Un agent qui doit vraiment réfléchir — explorer plusieurs pistes avant de répondre — utilisera typiquement GPT-5.6 Sol avec un effort high ou xhigh. Intégré dans vos agents, ce raisonnement ouvre la porte à des tâches qui demandent une véritable réflexion.

Quand activer le raisonnement dans un agent

Le raisonnement approfondi brille dans des situations précises, et l’expérience montre qu’elles se ressemblent toutes : il s’agit chaque fois de comparer des chemins possibles avant de trancher. C’est le cas de la planification complexe, où l’on décompose une tâche en étapes optimales, et de l’analyse mathématique — calculs, statistiques, optimisation — où une étape fausse invalide tout le reste. C’est aussi le cas du debugging, qui consiste à remonter d’un symptôme vers la cause racine, et de la prise de décision, où il faut évaluer plusieurs options et choisir la meilleure. La code review relève de la même famille : trouver un bug subtil suppose de simuler mentalement des exécutions que la lecture linéaire ne révèle pas.

Pour les tâches simples (répondre à une question, formater du texte), GPT-5.6 Terra ou Luna avec un effort faible (voire none) est plus rapide et moins cher. Payer du raisonnement pour reformuler un paragraphe revient à faire tourner un moteur de course au ralenti dans un embouteillage.

Sol + effort high/xhigh : le raisonnement profond

GPT-5.6 Sol avec un effort de raisonnement élevé remplace ce que faisait o3-pro. L’agent prend plus de temps mais produit des analyses plus profondes. Le cas ci-dessous est typique : une question stratégique à trois options, où la bonne réponse dépend d’arbitrages entre risque, coût et horizon. Notez que les instructions imposent explicitement les dimensions à considérer — le raisonnement gagne toujours à être cadré.

from agents import Agent, Runner, ModelSettings
from openai.types.shared import Reasoning

agent_strategique = Agent(
    name="Conseiller stratégique",
    instructions="""Vous êtes un conseiller en stratégie d'entreprise.
    Analysez en profondeur avant de recommander.
    Considérez toujours : les risques, les opportunités,
    les coûts et les alternatives.""",
    model="gpt-5.6-sol",
    model_settings=ModelSettings(reasoning=Reasoning(effort="high")),
)

result = Runner.run_sync(
    agent_strategique,
    """Notre startup SaaS a 500 clients, 2M€ de MRR, et croît de 15% par mois.
    Nous hésitons entre :
    A) Lever des fonds Serie B (20M€) et accélérer aux US
    B) Rester bootstrappé et consolider l'Europe
    C) Chercher un acquéreur stratégique
    Quelle stratégie recommandez-vous et pourquoi ?"""
)
print(result.final_output)

Pour les analyses les plus critiques, montez à xhigh ou max. Il existe aussi un réglage ultra (annoncé en juillet 2026) qui coordonne 4 agents en parallèle par défaut (jusqu’à 16 sur certaines évaluations) pour les tâches les plus lourdes — puissant, mais avec une consommation de tokens nettement supérieure : réservez-le aux problèmes qui le justifient.

Terra + effort medium : le raisonnement rapide

Entre l’absence de réflexion et l’analyse fouillée, il existe un juste milieu très utilisé en production. GPT-5.6 Terra avec un effort medium offre un bon compromis entre capacité de raisonnement et vitesse — l’équivalent de l’ancien o4-mini. Idéal pour les agents qui doivent raisonner vite, comme cet agent de diagnostic qui lit des métriques serveur et doit relier une saturation mémoire à une hausse des erreurs 5xx en quelques secondes, pendant que le site est en incident.

from agents import Agent, Runner, ModelSettings, function_tool
from openai.types.shared import Reasoning

@function_tool
def obtenir_metriques_serveur(serveur: str) -> str:
    """Récupère les métriques d'un serveur."""
    import json
    metriques = {
        "cpu": 87.5,
        "ram": 92.1,
        "disque": 65.3,
        "requetes_par_seconde": 1250,
        "temps_reponse_p99": 450,
        "erreurs_5xx": 23,
    }
    return json.dumps(metriques)

agent_diagnostic = Agent(
    name="Agent diagnostic",
    instructions="""Vous diagnostiquez des problèmes d'infrastructure.
    Analysez les métriques et identifiez la cause probable.
    Proposez des actions correctives immédiates et à long terme.""",
    model="gpt-5.6-terra",
    model_settings=ModelSettings(reasoning=Reasoning(effort="medium")),
    tools=[obtenir_metriques_serveur],
)

result = Runner.run_sync(
    agent_diagnostic,
    "Le site est lent depuis 30 minutes. Diagnostiquez le serveur web-prod-01."
)

Pattern : routeur de configurations

Vous n’êtes pas obligé de choisir une configuration une fois pour toutes. Utilisez une configuration légère pour le routage et la configuration appropriée pour l’exécution : un premier agent lit la tâche, renvoie un objet typé indiquant le modèle et l’effort à employer, puis vous instanciez l’agent d’exécution avec cette décision. Le champ raison n’est pas décoratif — il vous permet, en relisant vos logs, de vérifier que le routeur ne surdimensionne pas systématiquement.

from pydantic import BaseModel
from typing import Literal

class DecisionConfig(BaseModel):
    modele: Literal["gpt-5.6-luna", "gpt-5.6-terra", "gpt-5.6-sol"]
    effort: Literal["none", "low", "medium", "high", "xhigh"]
    raison: str

agent_routeur = Agent(
    name="Routeur intelligent",
    instructions="""Analysez la tâche et décidez quelle configuration utiliser :
    - gpt-5.6-luna, effort none/low : tâches simples (résumés, reformulation, réponses factuelles)
    - gpt-5.6-terra, effort medium : raisonnement rapide (classification, diagnostic)
    - gpt-5.6-sol, effort high/xhigh : tâches complexes (planification stratégique, analyse approfondie, maths)""",
    model="gpt-5.6-terra",
    model_settings=ModelSettings(reasoning=Reasoning(effort="medium")),
    output_type=DecisionConfig,
)

async def traiter_avec_config_optimale(tache: str):
    # Étape 1 : choisir la configuration
    decision = await Runner.run(agent_routeur, tache)
    config = decision.final_output
    print(f"Configuration : {config.modele} / effort {config.effort} ({config.raison})")

    # Étape 2 : exécuter avec la bonne configuration
    agent_execution = Agent(
        name="Agent exécution",
        instructions="Accomplissez la tâche demandée avec précision.",
        model=config.modele,
        model_settings=ModelSettings(reasoning=Reasoning(effort=config.effort)),
    )
    result = await Runner.run(agent_execution, tache)
    return result.final_output

Comportement en streaming avec le raisonnement activé

Quand le raisonnement est activé, le streaming a une particularité : la réflexion interne du modèle n’est pas diffusée en clair. Votre interface reçoit donc les tokens de la réponse finale, mais rien pendant la phase de réflexion.

agent = Agent(
    name="Analyste",
    instructions="Analysez les données en profondeur.",
    model="gpt-5.6-sol",
    model_settings=ModelSettings(reasoning=Reasoning(effort="high")),
)

# Le streaming livre la réponse finale, pas le raisonnement intermédiaire
result = Runner.run_streamed(agent, "Analysez ce problème complexe.")
async for event in result.stream_events():
    if event.type == "raw_response_event":
        if hasattr(event.data, "delta") and event.data.delta:
            print(event.data.delta, end="", flush=True)

Prévoyez cette latence dans votre UX : avec un effort high ou plus, les premiers tokens peuvent arriver après un temps de réflexion significatif. Un indicateur d’attente explicite évite que l’utilisateur croie l’application figée et recharge la page au pire moment.

Optimiser les coûts

Le raisonnement consomme des tokens supplémentaires (la réflexion interne est facturée). Deux leviers permettent de contenir la facture : baisser l’effort par défaut et ne monter qu’en cas de besoin, puis séparer décision et exécution, c’est-à-dire raisonner pour décider mais exécuter sans raisonner. Le workflow hybride ci-dessous applique le second principe — Terra en medium établit l’approche, Luna la déroule avec les tools.

# Pattern : raisonnement hybride
# Terra + medium pour la décision, Luna sans raisonnement pour l'exécution

agent_decideur = Agent(
    name="Décideur",
    instructions="Décidez de l'approche optimale.",
    model="gpt-5.6-terra",
    model_settings=ModelSettings(reasoning=Reasoning(effort="medium")),
)

agent_executeur = Agent(
    name="Exécuteur",
    instructions="Exécutez le plan décidé.",
    model="gpt-5.6-luna",  # Moins cher pour l'exécution
    tools=[rechercher_dans_crm, generer_rapport],
)

async def workflow_hybride(tache: str):
    plan = await Runner.run(agent_decideur, f"Comment traiter : {tache}")
    result = await Runner.run(agent_executeur, plan.final_output)
    return result.final_output

Points clés à retenir

Le raisonnement est un réglage par requête sur chaque modèle GPT-5.6 (none → max), et non plus des modèles séparés comme o3-pro/o4-mini
GPT-5.6 Sol avec effort high/xhigh : planification stratégique, analyse complexe, mathématiques
GPT-5.6 Terra avec effort medium : raisonnement rapide pour le diagnostic et le routage
Le réglage ultra coordonne plusieurs agents en parallèle pour les tâches les plus lourdes — coût en tokens nettement supérieur
Le pattern routeur choisit dynamiquement la combinaison modèle + effort et optimise les coûts
Raisonnez pour décider, exécutez sans raisonner : le meilleur rapport qualité-prix