Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Agent multi-étapes avec boucle de raisonnement

Les 15 van 25 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Agent multi-étapes avec boucle de raisonnement
  2. Le motif planifier-exécuter
  3. Agent auto-correctif
  4. Motif : chaîne d’agents spécialisés
  5. Contrôle de la profondeur de raisonnement
  6. Belangrijkste punten

Agent multi-étapes avec boucle de raisonnement

Les agents les plus puissants ne s’arrêtent pas après un seul appel d’outil. Ils enchaînent plusieurs étapes de raisonnement, ajustent leur stratégie en fonction des résultats et itèrent jusqu’à atteindre leur objectif. Dans cette leçon, vous apprendrez à construire ces agents multi-étapes. Les exemples utilisent la famille GPT-5.6 : là où la génération précédente nécessitait de changer de modèle pour activer le raisonnement, vous contrôlez désormais ce comportement via le paramètre d’effort sur le modèle de votre choix.

Le motif planifier-exécuter

Un agent multi-étapes commence par créer un plan, puis exécute chaque étape. Cette séparation est délibérée : le planificateur ne dispose d’aucun outil et produit une structure typée, tandis que l’exécuteur reçoit ce plan comme une feuille de route et se contente de le suivre. Une demande vague comme « préparer la revue trimestrielle pour les comptes clés » devient une séquence concrète d’actions — interroger le CRM, générer le rapport, envoyer l’e-mail — avant toute tentative d’action.

from agents import Agent, Runner, function_tool
from pydantic import BaseModel
import json

class PlanAction(BaseModel):
    steps: list[str]
    objective: str

planner_agent = Agent(
    name="Planner",
    instructions="""You receive a complex task. Break it down into simple, ordered steps.
    Each step must be a concrete, actionable item.""",
    model="gpt-5.6-sol",  # Advanced reasoning for planning
    output_type=PlanAction,
)

@function_tool
def search_crm(query: str) -> str:
    """Searches the CRM for customer information."""
    return json.dumps({"customers": [
        {"name": "Acme Corp", "revenue": 500000, "contract": "Enterprise"},
        {"name": "TechStart", "revenue": 50000, "contract": "Starter"},
    ]})

@function_tool
def generate_report(title: str, content: str) -> str:
    """Generates a formatted report."""
    return f"Report '{title}' generated successfully ({len(content)} characters)"

@function_tool
def send_email(recipient: str, subject: str, body: str) -> str:
    """Sends an email."""
    return f"Email sent to {recipient}: {subject}"

executor_agent = Agent(
    name="Executor",
    instructions="""You execute tasks step by step.
    Use available tools to complete each step.
    If a step fails, try an alternative approach.""",
    tools=[search_crm, generate_report, send_email],
    model="gpt-5.6-terra",
)

async def process_complex_task(task: str):
    # Step 1: Plan
    plan = await Runner.run(planner_agent, task)
    print(f"Plan: {plan.final_output.steps}")

    # Step 2: Execute with the plan as context
    execution_instructions = f"""Execute the following steps in order:
    {chr(10).join(f'{i+1}. {e}' for i, e in enumerate(plan.final_output.steps))}
    Objective: {plan.final_output.objective}"""

    result = await Runner.run(executor_agent, execution_instructions)
    return result.final_output

Agent auto-correctif

La planification ne suffit pas : dans le monde réel, les outils échouent. La seconde forme de boucle permet à l’agent de détecter ses propres erreurs et de les corriger. Tout repose sur un détail souvent négligé : l’outil ne lève pas d’exception ; il renvoie un message d’erreur lisible. L’agent le lit, réalise qu’il a oublié la clause FROM, réécrit sa requête et réessaie, dans la limite de trois tentatives définie par ses instructions.

from agents import Agent, Runner, function_tool

@function_tool
def execute_sql_query(sql: str) -> str:
    """Executes an SQL query on the database."""
    # Simulation: some queries fail
    if "DROP" in sql.upper():
        return "ERROR: Destructive queries are forbidden."
    if "SELECT" in sql.upper() and "FROM" not in sql.upper():
        return "ERROR: Invalid SQL syntax - missing FROM."
    return json.dumps({
        "columns": ["name", "monthly_revenue", "region"],
        "rows": [
            ["Acme Corp", 45000, "Île-de-France"],
            ["TechStart", 12000, "Rhône-Alpes"],
        ],
        "result_count": 2
    })

analyst_agent = Agent(
    name="Data Analyst",
    instructions="""You analyze data by executing SQL queries.
    If a query fails:
    1. Analyze the error message
    2. Correct the query
    3. Retry
    Maximum 3 attempts per query.
    Never use DROP, DELETE, or TRUNCATE.""",
    tools=[execute_sql_query],
    model="gpt-5.6-terra",
    max_turns=10,  # Enough turns for corrections
)

result = Runner.run_sync(
    analyst_agent,
    "What is the total revenue by region?"
)

Notez que l’interdiction des requêtes destructrices apparaît à deux endroits : dans les instructions et dans le code de l’outil. L’instruction guide le modèle, mais seule la vérification côté serveur dans l’outil garantit qu’un DROP TABLE ne passe jamais inaperçu.

Motif : chaîne d’agents spécialisés

Pour les flux de travail complexes, enchaînez plusieurs agents spécialisés au lieu de charger un seul agent de toutes les responsabilités. Chaque maillon a un rôle clair : le collecteur rassemble la matière première, l’analyste — équipé d’un modèle de raisonnement — identifie les tendances, et le rédacteur met en forme la sortie. L’avantage est à la fois pédagogique et opérationnel : lorsque le rapport final déçoit, vous savez immédiatement lequel des trois agents corriger.

from agents import Agent, Runner

collection_agent = Agent(
    name="Data Collector",
    instructions="Collect all data necessary for the analysis.",
    tools=[search_crm, execute_sql_query],
    model="gpt-5.6-terra",
)

analysis_agent = Agent(
    name="Analyst",
    instructions="Analyze the collected data and identify trends.",
    model="gpt-5.6-sol",  # Advanced reasoning for analysis
)

writing_agent = Agent(
    name="Writer",
    instructions="""Write a clear, structured report in English
    based on the provided analysis. Format: introduction, key points, recommendations.""",
    model="gpt-5.6-terra",
)

async def analysis_pipeline(question: str):
    # Step 1: Collect data
    data = await Runner.run(collection_agent, question)

    # Step 2: Analyze
    analysis = await Runner.run(
        analysis_agent,
        f"Analyze this data: {data.final_output}"
    )

    # Step 3: Write the report
    report = await Runner.run(
        writing_agent,
        f"Write a report based on this analysis: {analysis.final_output}"
    )

    return report.final_output

Contrôle de la profondeur de raisonnement

Toutes ces boucles partagent une caractéristique : elles pourraient ne jamais s’arrêter. Le paramètre max_turns est votre principale sauvegarde, et vous l’ajustez en fonction de l’ambition de la tâche. Trois tours suffisent pour un agent censé répondre du premier coup ; vingt-cinq sont nécessaires pour une exploration qui interroge plusieurs sources avant de conclure.

# Conservative agent: few turns
simple_agent = Agent(
    name="Simple Agent",
    instructions="Answer in a single turn if possible.",
    model="gpt-5.6-terra",
)
result = await Runner.run(simple_agent, "Simple question", max_turns=3)

# Complex agent: many turns
research_agent = Agent(
    name="Deep Researcher",
    instructions="Explore all angles before concluding.",
    tools=[search_crm, execute_sql_query],
    model="gpt-5.6-terra",
)
result = await Runner.run(research_agent, "Complete Q1 analysis", max_turns=25)

Définissez cette valeur en observant vos traces plutôt qu’en devinant : si vos exécutions réelles se terminent en six tours, une limite de vingt-cinq ne protège contre rien.

Belangrijkste punten

  • Le motif planifier-exécuter sépare la planification (modèle de raisonnement) de l’exécution
  • Un agent auto-correctif analyse ses erreurs et ajuste sa stratégie
  • Les chaînes d’agents spécialisés permettent des flux de travail complexes et maintenables
  • max_turns contrôle la profondeur de raisonnement et protège contre les boucles infinies
  • Réservez les capacités de raisonnement avancé à la planification et à l’analyse