Accueil / Articles / Le coût de calcul des boucles d’agent par rapport aux chatbots

Le coût de calcul des boucles d’agent par rapport aux chatbots

Pourquoi la planification de type ReAct et les chaînes d’outils peuvent multiplier le coût d’inférence par 10 — et quels mécanismes de contrôle permettent de limiter les dépenses.

2169 mots

Pourquoi les agents consomment environ 10 fois plus de ressources que les chatbots

Passer des chatbots aux agents autonomes n’est pas qu’un changement superficiel — c’est un changement d’architecture. Les boucles de raisonnement itératif multiplient les inférences et les opérations d’entrée/sortie avec des outils, de sorte qu’une seule tâche peut coûter un ordre de grandeur plus cher qu’une simple réponse limitée.

Chatbots : une seule requête limitée

Un assistant classique fonctionne approximativement ainsi : demande → une (ou quelques) appels au modèle → réponse. Le coût augmente en fonction du nombre de tokens entrants et sortants. La latence correspond à un seul parcours vers l’avant plus le processus d’échantillonnage.

from langchain_community.vectorstores import FAISS
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
from langchain_openai import ChatOpenAI, OpenAIEmbeddings

# Initialize the components (Vector store and LLM)
vectorstore = FAISS.from_texts(
    ["AI Agents require iterative loops."],
    embedding=OpenAIEmbeddings()
)
retriever = vectorstore.as_retriever()
model = ChatOpenAI(model="gpt-4o-mini")

# Build the linear RAG chain
rag_chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | model
    | StrOutputParser()
)

# Execute the single, bounded inference call
# This represents exactly one unit of compute.
response = rag_chain.invoke("Why do agents need more compute?")

Agents : planifier, agir, corriger

Les agents encadrent ces appels dans une boucle : réfléchir → choisir un outil → observer → réfléchir à nouveau. Chaque étape renvoie un contexte de plus en plus volumineux. La correction automatique après échec ajoute encore des étapes.

import json

class AgenticResearchLoop:
    def __init__(self):
        self.conversation_history = []
        # We mock the LLM responses to illustrate the sequential, stateful calls
        self.mock_llm_steps = [
            # Call 1: Initial planning step
            {
                "thought": "I need to identify the top 3 Salesforce competitors. I will start with a web search.",
                "action": "web_search",
                "action_input": "top CRM competitors to Salesforce 2024"
            },
            # Call 2: Analyzing results and planning the next action
            {
                "thought": "The search returned HubSpot, Microsoft Dynamics, and Veeva. Now I need to query HubSpot's latest quarterly earnings.",
                "action": "web_search",
                "action_input": "HubSpot latest quarterly earnings revenue"
            },
            # Call 3: Processing data and executing the next planned step
            {
                "thought": "HubSpot reported $557M in revenue. Now I will search for Microsoft Dynamics earnings.",
                "action": "web_search",
                "action_input": "Microsoft Dynamics 365 quarterly revenue growth"
            },
            # Call 4: Final synthesis of all collected information
            {
                "thought": "I have successfully retrieved data for the key competitors. I can now compile the final summary.",
                "action": "finalize_answer",
                "action_input": "Salesforce competitors summary: HubSpot ($557M revenue), Microsoft Dynamics (growing), and Veeva."
            }
        ]
        self.api_call_counter = 0

    def query_llm(self, accumulated_prompt: str) -> dict:
        """Simulates an expensive inference call to the LLM provider."""
        self.api_call_counter += 1
        print(f"[LLM CALL #{self.api_call_counter}] Consuming tokens (Context size: {len(accumulated_prompt)} chars)...")
        # In production, this would be a real chat completion API call
        return self.mock_llm_steps[self.api_call_counter - 1]

    def run(self, user_goal: str):
        print(f"User Goal: {user_goal}\n")
        context = f"Goal: {user_goal}\n"

        while self.api_call_counter < len(self.mock_llm_steps):
            llm_response = self.query_llm(context)
            print(f"  Reasoning thought: {llm_response['thought']}")
            print(f"  Executing Tool: {llm_response['action']}({llm_response['action_input']})")

            observation = f"Successful result from {llm_response['action']}"
            print(f"  Observation: {observation}\n")

            context += (
                f"Thought: {llm_response['thought']}\n"
                f"Action: {llm_response['action']}\n"
                f"Observation: {observation}\n"
            )

# Execute the agent
agent = AgenticResearchLoop()
agent.run("Research the top 3 competitors to Salesforce and summarize their latest quarterly earnings")

Boucles de type ReAct

Un schéma minimal de ReAct montre pourquoi la consommation en ressources augmente fortement :

+-------------+      Tool Call Parameter      +----------------+
|             | ----------------------------> |                |
|  LLM Agent  |                               | External Tool  |
|             | <---------------------------- | (API/Database) |
+-------------+      Raw JSON Observation     +----------------+
       |
       v
[Append to Context Window] ---> [Trigger Next LLM Inference Turn]

Chaque résultat obtenu via un outil devient de nouveaux tokens auxquels l’inférence suivante doit faire attention.

Anatomie de l’explosion

Plusieurs inférences par tâche au lieu d’une seule.
Croissance du contexte — historique, traces d’outils, carnets de notes.
Impasses spéculatives — plans abandonnés après utilisation de tokens payants.
Latence des outils cumulée avec le temps de traitement du GPU.

Compléxité de l’utilisation des outils

Les API externes ajoutent du temps réel et parfois davantage d’appels au modèle pour interpréter les résultats :

import json

class AgentExecutor:
    def __init__(self, prompt_template: str):
        self.context = prompt_template
        self.total_tokens_processed = 0
    def execute_step(self, reasoning: str, action_result: dict):
        step_input = f"\nThought: {reasoning}\nObservation: {json.dumps(action_result)}"
        self.context += step_input

        # Calculate mock token count (roughly 4 characters per token)
        context_tokens = len(self.context) // 4
        self.total_tokens_processed += context_tokens

        print(f"Context Size: {context_tokens} tokens | "
              f"Cumulative Tokens Billed: {self.total_tokens_processed}")
agent = AgentExecutor("System: You are an agent that books travel using tools.")
# Step 1: Flight Search Tool Output
agent.execute_step(
    reasoning="I need to find flights from JFK to LHR first.",
    action_result={"flights": [{"id": "AA100", "price": 450, "time": "08:00"}]}
)
# Step 2: Hotel Search Tool Output (Context has grown)
agent.execute_step(
    reasoning="Found flight AA100. Now I must find a hotel near Heathrow.",
    action_result={"hotels": [{"name": "Airport Inn", "price": 120, "rating": 4.2}]}
)

Une chaîne de traitement en plusieurs étapes (recherche → panier → paiement → confirmation) représente autant de travail que plusieurs réponses de chatbot, même si chaque étape semble « simple ».

L’échec est coûteux

Les tentatives de réparation et les réflexions améliorent la fiabilité mais nuisent aux factures. Sans budget, un agent perdu peut tourner en rond.

import time
from typing import Callable, Any, Dict

class AgentRuntimeLimitError(Exception):
    """Raised when an agent violates runtime guardrails."""
    pass

def execute_agent_step(
    step_fn: Callable[[], Dict[str, Any]],
    max_iterations: int = 5,
    max_duration_seconds: float = 10.0
) -> Dict[str, Any]:
    """
    Executes an agent step loop with strict termination guardrails
    to prevent infinite ReAct loops and runaway API billing.
    """
    start_time = time.time()
    iterations = 0

    while iterations < max_iterations:
        elapsed_time = time.time() - start_time
        if elapsed_time > max_duration_seconds:
            raise AgentRuntimeLimitError(f"Execution timed out after {elapsed_time:.2f}s.")

        step_result = step_fn()
        iterations += 1

        if step_result.get("status") == "COMPLETED":
            return step_result

    raise AgentRuntimeLimitError(f"Exceeded maximum iterations limit: {max_iterations}"

Charges de travail réelles

Codage autonome : modifier, tester, lire les journaux, modifier à nouveau — des dizaines d’appels au modèle.
Gestion client multi-API : identité, inventaire, expédition — outils séquentiels.
Surveillants d’infrastructure : sondages, diagnostic, propositions de correctifs dans le cadre de SLO stricts.

Lorsque le chat suffit

Préférez les solutions à utilisation unique ou des outils légers lorsque la tâche consiste en Q&R, en résumé ou en une seule recherche. Recourrez aux agents lorsque l’environnement est partiellement observé et que l’action nécessite plusieurs étapes.

Règles de sécurité

Limits stricts sur le nombre d’étapes, de tokens et de coûts par exécution
Parcours déterministes pour les actions à haut risque
Sandboxes pour les outils de code/shell
Observabilité : traçage de chaque réflexion/outil avec des étiquettes de coût
Mémorisation des résultats stables ; réduction des prompts entre les étapes

Exigences de l’architecture

Considérez les agents comme des systèmes distribués : budgets, idempotence, audits et SLO — et non comme des interfaces de chat dotées d’un indicateur de boucle. Le facteur de calcul 10× n’est pas une erreur ; c’est le prix d’un contrôle itératif, à moins de le concevoir différemment.

Marquez chaque intervalle avec agent_id et step_index afin que le service financier puisse attribuer le multiplicateur 10×.

Marquez chaque segment avec agent_id et step_index afin que le service financier puisse appliquer le multiplicateur de 10×.

Tous les articles Envoyer le brief