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

Разбираем агента на четыре части и показываем, как они соединяются в одну систему.

Цикл управления (agent loop) — повторяющийся процесс, в котором «мозг»-LLM на основе памяти решает следующее действие, инструмент его выполняет, а результат снова попадает в память.

Четыре компонента

Любой агент, от учебного до промышленного, можно описать четырьмя частями. Если убрать любую — это уже не агент.

1. Модель — «мозг»

LLM отвечает за рассуждение: что происходит, какой инструмент нужен, с какими аргументами, закончена ли задача. Модель не выполняет действий сама — она лишь решает, что делать, и формулирует это текстом. Качество агента в первую очередь определяется тем, насколько хорошо модель рассуждает и следует формату.

2. Инструменты — «руки»

Инструмент — это функция, которую агент может вызвать: калькулятор, поиск, запрос к базе, отправка письма, выполнение кода. Инструменты выводят агента за пределы текста — позволяют считать точно, получать свежие данные и менять внешний мир. Им посвящён весь раздел 2.

3. Память — «контекст»

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

4. Цикл управления — «нервная система»

Цикл связывает всё: берёт текущую память, спрашивает модель о следующем шаге, выполняет инструмент, кладёт результат обратно в память — и повторяет, пока модель не скажет «готово» (или не сработает лимит шагов).

Как это соединяется

Опишем компоненты как Python-объекты и прогоним один полный оборот цикла. Модель — заглушка, инструменты — словарь функций, память — список.

# Память
memory = []

# Инструменты («руки»)
def calc(expr):
    return str(eval(expr))
TOOLS = {"calc": calc}

# Модель («мозг») — заглушка: решает шаг по памяти
def brain(memory):
    if not any("12" in m for m in memory):
        return ("action", "calc", "3 * 4")
    return ("finish", "Ответ: 12", None)

# Цикл управления
goal = "посчитать 3 * 4"
memory.append(f"GOAL: {goal}")
for step in range(1, 5):
    kind, a, b = brain(memory)
    if kind == "finish":
        print("ФИНАЛ:", a)
        break
    result = TOOLS[a](b)
    memory.append(f"{a}({b}) -> {result}")
    print(f"шаг {step}: вызвал {a}({b}) = {result}")

print("Память в конце:", memory)

Вывод:

шаг 1: вызвал calc(3 * 4) = 12
ФИНАЛ: Ответ: 12
Память в конце: ['GOAL: посчитать 3 * 4', 'calc(3 * 4) -> 12']

Видно, как четыре части работают вместе: brain (мозг) принял решение, TOOLS (руки) выполнили, memory (память) накопила результат, цикл (нервная система) всё повторял до финала.

Где обычно ломается

Мозг плохо рассуждает — модель выбирает не тот инструмент или путает аргументы. Лечится лучшей моделью, примерами в промпте, более чётким форматом.
Инструмент ненадёжен — упал API, вернулась ошибка. Нужна обработка ошибок (раздел 2).
Память переполнилась — история не влезает в контекст. Нужны обрезка, суммаризация, долгосрочная память (раздел 4).
Цикл не останавливается — агент зациклился. Нужен лимит шагов (раздел 3).

Итог

Агент = модель (мозг) + инструменты (руки) + память (контекст) + цикл (нервная система).
Модель только решает, действия выполняют инструменты, результаты копит память, всё связывает цикл.
Каждый компонент — потенциальная точка отказа; следующие разделы разбирают их по очереди.