#LLM #агенты #ReAct #TAO

TAO-цикл: как агент думает, действует и наблюдает

15 августа 2026 · LLM

Что такое агент?

Общепризнанного понятия «агента» к настоящему времени не сложилось. Но для практической разработки целесообразно опираться на определение, которое в 2023 году предложила Лилиан Вонг (экс-Vice President of Research OpenAI). Её формула стала фактическим стандартом индустрии:

Агент = LLM + Планирование + Память + Инструменты

Разберём каждый составной компонент:

1. LLM — «мозг» агента

В системе автономного агента на основе LLM, языковая модель выполняет роль мозга агента, дополненного несколькими ключевыми компонентами: Планированием, Памятью и Использованием инструментов.

2. Планирование (Planning)

Агент не просто выполняет команду, а продумывает, как её выполнить:

Декомпозиция — разбивает сложную задачу на последовательность подзадач.
Саморефлексия — анализирует промежуточные результаты и корректирует план, если что-то пошло не так.

3. Память (Memory)

помнит контекст своей работы:

Краткосрочная память — история текущего диалога (контекстное окно модели).
Долгосрочная память — внешнее хранилище (например, векторная база данных), где знания сохраняются между сессиями.

4. Использование инструментов (Tool Use)

имеет «руки» — набор инструментов, которые агент может вызывать:

функции и скрипты;
внешние API (поиск, календарь, почта);
исполнители кода.

Инструменты позволяют агенту выходить за пределы генерации текста и фактически воздействовать на окружающую среду.

Все перечисленные признаки отвечают на вопрос: «Что умеет агент?». Но для практической разработки не менее важен вопрос: «Как именно он это делает в реальном времени?».

Важно! Агент — это не статичный набор функций, а непрерывный процесс. Чтобы достичь цели, он должен применять свои способности в строгой последовательности, снова и снова, пока задача не будет решена. Этот замкнутый алгоритм называется циклом агента, и в современной LLM-разработке он чаще всего строится по схеме TAO (Think-Act-Observe).

Исходя из названия TAO цикл это последовательность из трех действий агента:

Think (Рассуждение) происходит планирование выполнения задачи или на профессиональном жаргоне Chain of Thought (CoT) — «цепочка рассуждений» в этой части сложная задача разбивается на подзадачи.
Act (Действие) вызывается подходящий инструмент (Tool Use).
Observe (Наблюдение) Агент считывает результат своего действия и на основе наблюдения решает либо еще раз вызвать инструмент или вернуть окончательный ответ.

Для наглядности работы цикла TAO (Think-Act-Observe), который является классической реализацией паттерна ReAct (Reasoning + Acting), рассмотрим заготовку из Tools vs Skills агентского цикла:

1. Think (Размышление)

С технической точки зрения, чтобы активировать «рассуждения» LLM, необходимо задать специальный системный промпт. Это помогает модели определить порядок действий и понять, какие шаги нужно предпринять. Критически важно, чтобы эти рассуждения сохранялись в контексте (памяти) диалога.

...
#НОВЫЙ ПРОМТ ОТРАЖАЕТ ЧТО МОДЕЛЬ ДОЛЖНА ОПРЕДЕЛИТЬ ПОРЯДОК ДЕЙСТВИЙ
SYSTEM_PROMPT = """\
Ты помощник, который умеет считать даты на разные дни. Определи порядок действий и сделай вывод какой инструмент нужен для решения поставленной задачи.
Ты имеешь доступ к инструменту get_future_date, который возвращает дату через N дней от сегодня.
"""
...
    for step in range(MAX_ITERATIONS):
        print(f"🔄 Итерация {step + 1}/{MAX_ITERATIONS}")
        response = llm_generate(messages, tools)
        content = (response.get("content") or "").strip()
        #ВЫВОД РАССУЖДЕНИЯ
        print(f"На {step + 1} итерации рассуждения: {content}")
        messages.append({
            "role": "assistant",
            "tool_calls": response["tool_calls"],
            "content": content or None, # ← СОХРАНЯЕМ рассуждения!
        })
 ...

Замечание 1: Режим thinking необходимо логгировать, чтобы понимать почему модель приняла то или иное решение.
Замечание 2: Промт, в котором заложено рассуждение снижает вероятность галлюцинаций и повышает детерминированность при выборе соответствующих инструментов для решения поставленной задачи.

Для "активации" think в TAO цикле чаще применяют специальный паттерн промтинга:

Chain-of-Thought (CoT) — Цепочка мыслей, где модель заставляют генерировать промежуточные логические шаги перед выдачей финального ответа. Классический триггер: «Думай пошагово» (Let's think step by step).

Также комбинируют с Zero-Shot - добавление фразы про пошаговость или Few-Shot Демонстрация модели нескольких примеров, где сначала расписано решение, а в конце дан ответ.

Замечание 3: Chain-of-Thought (CoT) не единственный, но наиболее популярный паттерн для think - примеры других техник можно посмотреть здесь.

2. Act (Действие)

На основе своих рассуждений агент выбирает подходящий инструмент. Важнейшее правило этапа Act: агент всегда должен возвращать LLM результат выполнения, даже если произошла ошибка. Модель не знает, что произошло во внешнем мире, пока ей об этом не сообщат.

...
    print(f"🔧 Вызов инструмента: {name}({args})")

    try:
        result = str(available_fc.get(name)(**args))
    except Exception as e:
        # ВАЖНО: Ошибка тоже передается в Observe!
        result = f"Ошибка выполнения: {str(e)}"
        print(f"Ошибка при вызове {name}: {e}")

    messages.append(
        {"role": "tool", "tool_call_id": tool_call["id"], "content": result}
    )

Также может возникнуть ошибка при разборе аргументов tool:

try:
    args = json.loads(tool_call["function"]["arguments"])
except json.JSONDecodeError:
    result = "Ошибка парсинга аргументов"
    # ... обработка

3. Observe (Наблюдение)

На этом этапе мы предоставляем LLM результаты её работы (observations). Получив эти данные, модель сможет проанализировать (отрефлексировать) их на следующем шаге цикла for step in range(MAX_ITERATIONS):

    ...
    for step in range(MAX_ITERATIONS):
        ...
        messages.append(
            {
                "role": "assistant",
                "tool_calls": response["tool_calls"],
                "content": content or None,
            }
        )

        for tool_call in response["tool_calls"]:
            ...
            messages.append(
                {"role": "tool", "tool_call_id": tool_call["id"], "content": result}
            )
...

В зависимости от полученного результата (Observation) модель на следующей итерации примет решение:

Если данных недостаточно или возникла ошибка → сгенерирует новые рассуждения (Think) и попробует другой инструмент.
Если данных достаточно → сгенерирует финальный текстовый ответ пользователю (сработает условие break в блоке Think).

Если внимательно посмотреть на TAO-цикл, можно заметить, что основной каркас, описывающий программный объект, который можно называть агентом, уже сформирован. Поэтому справедливо предположить, что агент живёт в TAO-цикле.

Но если вернуться к формуле Лилиан Вонг:

Агент = LLM + Планирование + Память + Инструменты

Внимательный читатель обратит внимание, что память реализована только частично — а именно, краткосрочная. Агент отлично работает внутри одной задачи, но стоит перезапустить скрипт или начать выполнять новую задачу — агент начинает с чистого листа, не помня ни прошлых задач, ни своих выводов.

Чтобы реализовать полноценного автономного агента, нужно добавить второй тип памяти — долгосрочную.

...
import os
...

MEMORY_FILE = "agent_memory.txt"

def memory(observation: str = None) -> str:
    """
    Универсальная функция для работы с долгосрочной памятью.

    - Если observation=None: возвращает всю память как строку
    - Если observation задан: добавляет его в память и возвращает пустую строку
    """
    if observation is not None:
        # Режим записи: добавляем наблюдение
        with open(MEMORY_FILE, "a", encoding="utf-8") as f:
            f.write(f"- {observation}\n")
        return ""
    else:
        # Режим чтения: возвращаем всю память
        if os.path.exists(MEMORY_FILE):
            with open(MEMORY_FILE, "r", encoding="utf-8") as f:
                memory_content = f.read().strip()
                if memory_content:
                    return f"\n\nТвой прошлый опыт (из долгосрочной памяти):\n{memory_content}"
        return ""

def agent_cycle(
    user_query: str,
    system_promt: str = SYSTEM_PROMPT,
    tools: list[dict] = LLM_TOOLS,
    available_fc: dict = AVAILABLE_TOOLS,
) -> str:
    ...
    full_system_prompt = system_promt + memory()

    messages: list[dict[str, object]] = [
        {"role": "system", "content": full_system_prompt},
        {"role": "user", "content": user_query},
    ]

    for step in range(MAX_ITERATIONS):
        ...

        for tool_call in response["tool_calls"]:
            ...

        memory(user_query[:50])
    return "⚠️ Достигнут лимит итераций."

...

Важно в данном примере - функция для реализации хранения долгосрочной памяти служит демонстрацией простой реализации долгосрочной памяти - не рекомендуется использовать в production. В целом для сохранения истории диалогов используется несколько подходов от суммаризации через LLM до извлечения N-последних сообщений и др.

Подведем итоги:

Агент = LLM + Планирование + Память + Инструменты

LLM: «Мозг», ядро принятия решений.
Планирование: Декомпозиция сложных задач на подзадачи и саморефлексия.
Память: Помнит контекст своей работы (краткосрочной и долгосрочной)
Инструменты: «Руки» (API, функции, код) для реального воздействия на внешний мир.

Технически агент функционирует в рамках TAO цикла, поэтому можно скорректировать формулу - Агент = TAO LOOP (LLM + Планирование + Память + Инструменты)

TAO-цикл (ReAct)

Непрерывный итеративный процесс, в котором «живёт» агент:

Think (Размышление): Построение плана чаще (Chain-of-Thought). Рассуждения обязательно сохраняются в контекст для прозрачност и снижения галлюцинаций.
Act (Действие): Вызов инструмента. В LLM всегда передается результат выполнения, включая любые ошибки и исключения.
Observe (Наблюдение): Анализ полученного результата. Агент решает: запустить новую итерацию цикла или выдать финальный ответ.

Мощный блог