Agents avec raisonnement (o3-pro, o4-mini)

Les modèles de raisonnement d’OpenAI (o3-pro, o4-mini) ne se contentent pas de prédire le prochain token. Ils réfléchissent avant de répondre, en explorant plusieurs pistes de raisonnement. Intégrés dans vos agents, ils ouvrent la porte à des tâches qui demandent une véritable réflexion.

Quand utiliser un modèle de raisonnement

Les modèles de raisonnement brillent dans des situations précises :

Planification complexe : décomposer une tâche en étapes optimales
Analyse mathématique : calculs, statistiques, optimisation
Debugging : identifier la cause racine d’un problème
Prise de décision : évaluer plusieurs options et choisir la meilleure
Code review : analyser du code pour trouver des bugs subtils

Pour les tâches simples (répondre à une question, formater du texte), GPT-5.3 est plus rapide et moins cher.

o3-pro : le raisonnement profond

o3-pro est le modèle de raisonnement le plus avancé. Il prend plus de temps mais produit des analyses plus profondes :

from agents import Agent, Runner

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="o3-pro",
)

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)

o4-mini : le raisonnement rapide

o4-mini offre un bon compromis entre capacité de raisonnement et vitesse. Idéal pour les agents qui doivent raisonner vite :

from agents import Agent, Runner, function_tool

@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="o4-mini",  # Raisonnement rapide pour le diagnostic
    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 modèles

Utilisez o4-mini pour le routage et le modèle approprié pour l’exécution :

from pydantic import BaseModel
from typing import Literal

class DecisionModele(BaseModel):
    modele: Literal["gpt-5.3", "o3-pro", "o4-mini"]
    raison: str

agent_routeur = Agent(
    name="Routeur intelligent",
    instructions="""Analysez la tâche et décidez quel modèle utiliser :
    - gpt-5.3 : tâches simples (résumés, reformulation, réponses factuelles)
    - o4-mini : tâches nécessitant un raisonnement rapide (classification, diagnostic)
    - o3-pro : tâches complexes (planification stratégique, analyse approfondie, maths)""",
    model="o4-mini",
    output_type=DecisionModele,
)

async def traiter_avec_modele_optimal(tache: str):
    # Étape 1 : choisir le modèle
    decision = await Runner.run(agent_routeur, tache)
    modele_choisi = decision.final_output.modele
    print(f"Modèle sélectionné : {modele_choisi} ({decision.final_output.raison})")

    # Étape 2 : exécuter avec le bon modèle
    agent_execution = Agent(
        name="Agent exécution",
        instructions="Accomplissez la tâche demandée avec précision.",
        model=modele_choisi,
    )
    result = await Runner.run(agent_execution, tache)
    return result.final_output

Différences de comportement avec les modèles de raisonnement

Les modèles de raisonnement ont des spécificités dans le SDK :

# Les modèles de raisonnement ne supportent pas le system prompt classique
# Le SDK gère cela automatiquement via le paramètre instructions
agent = Agent(
    name="Analyste",
    instructions="Analysez les données en profondeur.",
    model="o3-pro",
    # Le SDK convertit les instructions en format compatible
)

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

Optimiser les coûts

Les modèles de raisonnement consomment plus de tokens (le raisonnement interne compte) :

# Pattern : raisonnement hybride
# o4-mini pour la décision rapide, gpt-5.3 pour l'exécution

agent_decideur = Agent(
    name="Décideur",
    instructions="Décidez de l'approche optimale.",
    model="o4-mini",
)

agent_executeur = Agent(
    name="Exécuteur",
    instructions="Exécutez le plan décidé.",
    model="gpt-5.3",  # 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

o3-pro excelle en planification stratégique, analyse complexe et mathématiques
o4-mini offre un raisonnement rapide pour le diagnostic et le routage
GPT-5.3 reste le meilleur choix pour les tâches simples (coût et vitesse)
Le pattern routeur de modèles optimise automatiquement les coûts
Le SDK gère les différences de format entre modèles GPT et modèles o-series
Utilisez o4-mini pour décider, gpt-5.3 pour exécuter : le meilleur rapport qualité-prix