Галоўная / Артыкулы / Кошт вычыслення ціклам агента проты чатботаў

Кошт вычыслення ціклам агента проты чатботаў

Чаму планаванне у стыле ReAct і ланцюгі засобаў можу падвяліць вартасць аналізу у 10 разоў — і якія меры дапамагаюць контролаваць гэтыя витраты.

2169 слоў

Чаму агенты спалююць працэздатнасць у ~10 разоў большую, чым чатботы

Пераход з чатботаў на автонамныя агенты — гэта не проста змена візуальнага аспекту, а змена архітактуры. Ітератыўныя циклы разумовых працэсаў збільшуююць колькасць вычысленняў і ввода-выводу з інструментамі, таму адна задача може коштаць у калькуляцыйных масштабах больш, чым адна вялікага розміру адпаведзь.

Чатботы: адна вялікага розміру вызов

Класычны асистэнт выконвае працэсы приблізна так: запит → адны (або кальколька) вызоў модэлю → адпаведзь. Косцты зростаюць прыбліжна пры колькасці токенаў, якія надходзяць і выходзяць. Затрымка складаецца з аднаго направленага шляху плюс процэс выбору.

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

Агенты: плануе, дзейнае, карэктуе

Агенты паказваюць гэты вызов у цікле: размышляе → выбирае інструмент → спазірвае → зноў размышляе. Кожны крок перасылае ўсё большы контекст. Самакарэкцыя пасля неудач дадае ўсё больш крокаў.

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

Мінімальны прыклад ReAct паказвае, чаму показнікі растуць:

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

Кожны результат інструмента стае новымі токанамі, якія неабходна врачыць пад час наступных вычысленняў.

Структура выбуху

Калькюліяў колькасцю на адну задачу замест адной.
Развіцце контэксту — історыя, следы абразоў, зошкі для нотатаў.
Гаданыя тупікі — планы, якія абмовляюцца пасля выкарыстоўвання платных токенав.
Затрымкі абразоў пад час працы з GPU.

Комплексныя способы выкарыстоўвання абразоў

Зовнішніе API дадаюць час адліквідацыі і інодзе больш заўважэнняў моделі для аналізу рэзультатаў:

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

Багатыяэтапная ланцоўка адпаведзення (шуканне → кошык → оплата → паўтарэнне) трэбуе столькі ж працы, сколькі калькюляцыя колькасці адпаведзенняў чатбота, нават калі кожны этап ёсць “простым”.

Праця з невыкарыстоўваннем ресурсаў ёсць дорогая

Пракушанні і перагляды спрыяюць надзеям на надзейнасць, але пагаршуюць ситуацыю з рахункамі. Без бюджэтаў агент, які не разумее ситуацыю, можа трапіць у скрутны становішча.

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

Рэальныя навантажэння

Аўтонамны кодаванне: рэдагаванне, тэставанне, чытанне логаў, практычнае рэдагаванне зноў — дзесяткі вызоў модэля.
Мнага-API аператыўныя функціі для клёнтаў: атрыбуты ідэнтыфікацыі, інвентар, адправка — парадоксальныя засобы.
Наглядачы інфраструктуры: апыткі, дыягностика, працэсы выправлення пад строгімі SLO-маў.

Калі чата достатнь

Выбірайце адзінаковыя аперацыі чыста для запитанняў і адказоў, стварэння падсумакоў чы адзінаго выкарыстоўвання інфармацыі, калі задача простая. Актываўайце агентаў, калі сярэдавішча часткова спазіруецца і трэба багатоэтапныя дзеяння.

Нормы і правілы

Строгія меры па колькасці крокаў, токенаў і грошаў за адну роботу
Дэтэрміністычныя шляхі для дзеянняў з высокым рызыкам
Сандбоксы для коду і засобаў у відметніку
Возможнасць спазіравання: стежыце за кожной думкай/засобам з атрыбутамі вартасці
Кэшуйце стабільныя резултаты выкарыстоўвання; скрацуйце запиты между крокамі

Што выклекае архітектура

Спрыткія трэба расследжваць як распраўленыя системы: бюджэты, ідэмпотентнасць, аудыт і SLO-яў — а не як інтерфейсы чату з пазначкай цыклу. 10× вычысленняя не ўскладненне; гэта цена ітератыўнага кантролю, якщо толькі вы яго не спроектуеце інакш.

Прызначыце атрыбуты agent_id і step_index кожнаму періоду, ўпрымкі фінансавых вопытакоў, каб можна было прызначыць кэфіцыент 10×.

Прызначыце атрыбуты agent_id і step_index кожнаму періоду, упрымкі фінансавых вопытакоў, каб можна было прызначыць кэфіцыент 10×.

Пазначыце кожны абсант agent_id і step_index, ўпрымкі фінансавых служб маглі б прызначыць кэфіцыент 10×.

Пазначыце кожны абсцэнт значэннямі agent_id і step_index, ўпрымкам фінансавых служб для застосавання кэфіцыента 10×.

Пазначыце кожны абсант agent_id і step_index, ўпрымкі фінансавых служб маглі б прызначыць кэфіцыент 10×.

Пазначыце кожны абсцэнт значэннямі agent_id і step_index, ўпрымкам фінансавых служб для застосавання кэфіцыента 10×.

Атрыбутавайце кожны фрагмент значэннямі agent_id і step_index, ўсёлякія фінансы моглі б прызначыць кэфіцыент 10×.

Усе артыкулы Даслаць брыф