Startseite / Artikel / Die Rechenkosten von Agenten-Schleifen im Vergleich zu Chatbots

Die Rechenkosten von Agenten-Schleifen im Vergleich zu Chatbots

Warum ReAct-basiertes Planen und Toolchains die Inferenzkosten um das Zehnfache erhöhen können – und welche Schutzmaßnahmen die Kosten in Grenzen halten.

2169 Wörter

Warum Agenten etwa 10-mal so viel Rechenleistung wie Chatbots verbrauchen

Der Übergang von Chatbots zu autonomen Agenten ist keine oberflächliche Änderung – es handelt sich um einen Architekturwechsel. Iterative Schlussfolgerungszyklen erhöhen die Anzahl der Inferenzen sowie die Tool-Eingabe/Ausgabe, sodass eine einzige Aufgabe um ein Vielfaches teurer sein kann als eine begrenzte Antwort.

Chatbots: ein begrenzter Aufruf

Ein klassischer Assistent führt im Großen und Ganzen folgende Schritte aus: Prompt → ein (oder wenige) Modellaufrufe → Antwort. Die Kosten steigen mit der Anzahl der ein- und ausgehenden Tokens. Die Latenz beträgt einen Vorwärtsweg plus Sampling.

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?")

Agenten: planen, handeln, korrigieren

Agenten fassen diesen Aufruf in einen Zyklus ein: nachdenken → Tool auswählen → beobachten → erneut nachdenken. Jeder Schritt sendet einen wachsenden Kontext erneut. Selbstkorrekturen nach Fehlern führen zu weiteren Schritten.

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")

ReAct-ähnliche Zyklen

Ein minimalistisches ReAct-Beispiel zeigt, warum die Kosten in die Höhe schießen:

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

Jedes Tool-Ergebnis wird zu neuen Tokens, auf die die nächste Inferenz Rücksicht nehmen muss.

Anatomie der Explosion

Mehrere Schlussfolgerungen pro Aufgabe anstelle einer einzigen.
Kontextentwicklung – Historie, Tool-Spuren, Notizbücher.
Spekulative Sackgassen – Pläne, die nach Verbrauch der bezahlten Token aufgegeben werden.
Tool-Latenz, die sich mit der GPU-Zeit addiert.

Kombinationen der Tool-Nutzung

Externe APIs fügen Zeitaufwand durch reine Uhrzeit sowie manchmal zusätzliche Modellaufrufe zur Ergebnisverarbeitung hinzu:

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}]}
)

Eine mehrstufige Abwicklungskette (Suche → Warenkorb → Bezahlen → Bestätigen) erfordert die Arbeit von mehreren Chatbot-Antworten, selbst wenn jeder Schritt „einfach“ ist.

Fehler sind teuer

Wiederholungen und Überlegungen verbessern die Zuverlässigkeit, schaden aber den Rechnungen. Ohne Budgets kann ein verwirrter Agent verzweifeln.

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}"

Echte Arbeitslasten

Autonomes Programmieren: Bearbeiten, Testen, Protokolle lesen, erneut bearbeiten – Dutzende von Modellaufrufen.
Mehr-API-Kundenverwaltung: Identität, Lagerbestand, Versand – sequenzielle Tools.
Infrastrukturüberwacher: Abfragen, Diagnose stellen, unter strengen SLOs Lösungen vorschlagen.

Wenn Chat ausreicht

Wählen Sie Einzelaufrufe oder leichte Tools, wenn die Aufgabe aus Fragen/Antworten, Zusammenfassungen oder einer einzigen Abfrage besteht. Wenden Sie Agenten an, wenn die Umgebung nur teilweise beobachtbar ist und mehrstufige Aktionen erforderlich sind.

Schutzmaßnahmen

Harte Obergrenzen für Schritte, Tokens und Kosten pro Ausführung
Deterministische Abläufe für hochriskante Aktionen
Sandbox-Umgebungen für Code- und Shell-Tools
Überwachbarkeit: Jeder Gedanke/Tool wird mit Kostenmetadaten verfolgt
Caching stabiler Abfragergebnisse; kürzere Anfragen zwischen Schritten

Was die Architektur erfordert

Betrachten Sie Agenten als verteilte Systeme: mit Budgets, Idempotenz, Audits und SLOs – nicht als Chat-UIs mit einem Schleifenflag. Die 10×-Rechenleistung ist kein Fehler; sie ist der Preis für iterative Steuerung, es sei denn, man konzipiert das System anders.

Markieren Sie jeden Zeitabschnitt mit agent_id und step_index, damit die Finanzabteilung den 10×-Faktor zuordnen kann.

Markieren Sie jeden Abschnitt mit agent_id und step_index, damit die Finanzabteilung den 10×-Faktor zuordnen kann.

Alle Artikel Brief senden