AIKraft Agents
Главная/Блог/Гайд/Оптимизация длинных агентов: кэш и…
Гайд13 мин чтения · 19 ноября 2026 г.

Оптимизация длинных агентов: кэш и архитектура

Как совместная работа Ollama и Together AI решает проблему падения производительности при запуске длинных агентов с использованием открытых моделей.

Оптимизация длинных агентов: кэш и архитектура

Представьте себе сценарий, знакомый каждому разработчику, который когда-либо работал с AI-агентами. Вы запускаете сложную задачу по написанию кода, и агент начинает свою работу. На каждом шаге он отправляет модели всю историю переписки: системный промпт, определения всех доступных инструментов, ваш исходный запрос, каждый файл, который агент прочитал, и каждую команду, которую он выполнил. В ответ модель обычно возвращает всего несколько десятков токенов — вызов инструмента. Затем процесс повторяется снова, но теперь с добавлением новой информации к уже огромному объему предыдущих данных.

Эта характеристика — огромная длина входной последовательности (ISL) и крошечная длина выходной последовательности (OSL) — является визитной карточкой большинства агентных нагрузок. Если бы графический процессор (GPU) каждый раз обрабатывал этот целый транскрипт с нуля, сессии становились бы все медленнее и дороже с каждым шагом. Однако существует механизм, который спасает ситуацию, но при неправильном использовании может полностью разрушить эффективность. Речь идет о префиксном кэшировании (prefix caching). В этой статье мы подробно разберем, как Ollama и Together AI решают эту проблему с разных сторон, чтобы помочь создателям агентов и инфраструктуры.

01Как выглядит шаг агента для GPU

Каждый запрос к модели проходит через две фазы. Первая — это префилл (prefill). В этот момент движок читает весь промпт одним большим параллельным проходом и генерирует первый токен. GPU отлично справляются с этой задачей, так как она требует выполнения огромного количества математических операций одновременно, что максимизирует арифметическую интенсивность. Именно фаза префилла определяет, сколько времени вы будете ждать, пока появятся первые новые токены.

Вторая фаза — это декодирование (decode). На этом этапе модель записывает остальную часть ответа по одному токену за раз. Каждый новый токен требует чтения обратно и внимания (attention) ко всему, что было до него. Декодирование ограничено пропускной способностью памяти (memory bandwidth) больше, чем вычислительной мощностью, и именно оно определяет, как быстро текст поступает на экран.

В обычном чате ответ тратит время на обе фазы, но шаг агента состоит преимущественно из префилла, потому что входными данными является вся сессия, а выводом — обычно короткий вызов инструмента. Модели с рассуждением (reasoning models) добавляют токены размышления, иногда их очень много, но по мере роста сессии до десятков тысяч токенов входные данные все равно доминируют. С каждым шагом входные данные становятся длиннее, а выход остается примерно того же размера — несколько вызовов инструментов.

Таким образом, для агентов вопрос «насколько быстр этот модель?» на самом деле означает: «насколько быстро она может обработать длинную историческую запись предыдущих шагов?». Способ быстро обработать задачу с множеством предыдущих шагов — это просто кэшировать их и читать обратно, а не пересчитывать заново.

Визуализация процесса префилла и декодирования в GPU
Визуализация процесса префилла и декодирования в GPU

02Кэш — это король

Самый простой способ представить KV-кэш (или префиксный кэш) — это чтение. Представьте, что для чтения каждого нового слова на странице вам приходилось начинать снова с самого начала. Чем дальше вы продвигались по странице, тем медленнее вы шли, потому что вам приходилось постоянно перечитывать все, что вы уже прочитали. Это модель без кэша. Кэш решает эту проблему внутри одного запроса: движок сохраняет работу, выполненную на предыдущих токенах (хранится в виде промежуточных пар ключ-значение), и вычисляет только новый токен.

Префиксное кэширование делает то же самое, но между запросами. Шаг 7 сессии агента — это шаг 6 плюс немного нового. Если движок все еще хранит работу шага 6, ему нужно обработать только новую часть.

Арифметика проста. Если каждый шаг добавляет одинаковое количество данных, то десять шагов без кэширования обрабатывают 1 + 2 + ... + 10 = 55 единиц промпта. С кэшированием они обрабатывают 10. При ста шагах, что не является редкостью для задач программирования, это 5 050 против 100. Реальные шаги варьируются по размеру, поэтому рассматривайте эти числа как идеализированные. Кэшированная сессия не является полностью бесплатной, так как каждый новый токен все равно должен обращаться к кэшированным данным. Но закономерность сохраняется: без кэширования работа, которую вы повторяете, растет пропорционально квадрату длины сессии.

Подвох заключается в том, что префиксный кэш совпадает с началом промпта до первого токена, который отличается, и останавливается там. Все, что после этого первого различия, должно быть обработано заново. Добавление в конец промпта не стоит дополнительных затрат. Изменение чего-либо в начале, даже одного символа, означает повторную обработку всего, что идет после него. Если изменение находится вверху, вы фактически выбрасываете всю сессию и теперь должны восстановить кэш заново. Почти все остальное в этом материале вытекает из этого одного правила.

💡
Ключевой принцип. Кэш работает только при неизменном начале промпта. Любое изменение в системном промпте или начале диалога обнуляет преимущества кэширования для всей последующей истории.

03Харнесы и API: где ломается кэш

Харнесы (harnesses) решают, что попадает в каждый запрос. Движки вывода (inference engines) решают, что происходит, когда этот запрос поступает. Мы часто обнаруживали, что большая часть нашей работы с каждой стороны заключается в защите кэша от того, что может сделать другая сторона. Давайте разберем основные проблемы на стороне харнеса.

Поздняя загрузка инструментов

Харнесы теперь содержат множество инструментов. Если каждое определение загружается в промпт заранее, вы тратите контекст на инструменты, которые задача никогда не будет использовать, и модель становится хуже в выборе правильного инструмента. Новые харнесы добавили функцию поиска инструментов, где инструмент может быть загружен и использован агентом после поиска.

Например, у вас есть персональный ассистент-агент. Если вы попросите его экспортировать отмеченные события в календарь, и он выполнит поиск по слову «календарь», загрузит определение save_calendar и вызовет его. Вопрос для кэша: куда поместить это определение?

Очевидный подход — добавить определение в список инструментов. Это работает, но список инструментов находится в верхней части промпта, перед разговором. Если префикс меняется, все, что после него, обрабатывается заново. В длинной сессии это могут быть сотни тысяч токенов. Лучший подход — поместить определение в конец, где новый контент и так добавляется. Однако не каждая модель поддерживает это. Некоторые шаблоны чата не ожидают определения инструмента посреди разговора, и вызов завершается ошибкой. Поэтому возможность харнеса загружать инструменты поздно без дополнительных затрат зависит от модели.

Вещи вверху, которые меняются

Самый простой способ разрушить кэш — поместить в системный промпт что-то, что меняется от шага к шагу, например, текущую метку времени, статус git или рабочую директорию, через которую перемещается агент. Если харнес перерендеривает системный промпт со свежими значениями на каждом шаге, каждый шаг становится полным перечитыванием.

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

Усилия рассуждения

Мы столкнулись с этой проблемой на стороне Ollama. В GLM-5.3-Flash усилия рассуждения не являются отдельной настройкой, которую движок обрабатывает отдельно. Шаблон чата записывает их в самый первый системный блок, перед инструментами и разговором. Если вы глубоко в длинной задаче и она идет плохо, вы повышаете усилия с низких до высоких. Это разумное действие, но следующий запрос теперь отличается от последнего почти с первого токена. Это означает, что вся сессия обрабатывается заново. В длинном запуске это может стоить сотни тысяч токенов из-за изменения одной настройки.

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

Большие результаты инструментов

Результат инструмента становится частью следующего запроса и каждого последующего. Если агент читает 3000-строчный файл, когда ему нужно было сорок строк, вы платите за это не один раз, а на каждом оставшемся шаге (даже если это кэшировано, вы теряете окно контекста). Для борьбы с этим харнесы часто обрезают вывод инструмента. Это правильное решение, но то, как вы обрезаете вывод, имеет значение.

Вот ошибка, которую легко построить случайно. Задача — исправить ошибку часового пояса в экспорте календаря. Агент читает calendar.py, и инструмент возвращает первые 100 строк из 640-строчного файла, не сообщая, что он остановился. Функция, которая имеет значение, convert_timezone, находится на строке 420. Модель не знает, что что-то отсутствует.

Решение — одна строка в выводе, сообщающая модели, что она получила строки с 1 по 100 из 640, и что она может искать файл или запросить другой диапазон. С этим модель ищет «часовой пояс», находит строку 420 и читает строки с 410 по 450. Обрезка вывода экономит деньги. Обрезка без предупреждения приводит к тому, что модель уверенно редактирует код, который она никогда не видела.

Сравнение эффективности кэширования при разных длинах сессии
Сравнение эффективности кэширования при разных длинах сессии

Подагенты

Открытые модели, такие как Kimi K3, GLM-5.3 и GLM-5.3-Flash, теперь довольно хорошо справляются с разделением большой задачи и передачей частей подагентам. То, как харнес начинает каждого подагента, решает, сколько кэша родителя он может использовать.

Один вариант — позволить подагенту унаследовать все: тот же системный промпт, инструменты и разговор, плюс его назначение. Боковые чаты работают таким образом. Они отходят от сессии родителя, поэтому весь префикс уже кэширован. Другой вариант — отправить краткое описание: тот же системный промпт и инструменты, а затем только файлы и инструкции, которые нужны подагенту. В этом случае кэш покрывает настройку и ничего более.

Наследование звучит строго лучше, но это не так. Кэшированный префикс дешев для обработки, но не бесплатен. Каждый токен, который генерирует подагент, должен читать через него, и он занимает память GPU все это время. Рецензенту, которому нужны два файла и контрольный список, вероятно, не нужна история из трехсот шагов. И если вы дадите подагенту свой собственный системный промпт, он не будет делиться ничем с родителем, даже настройкой.

04Страна движков вывода

Вы можете сделать все вышеперечисленное идеально и все равно не получить выгоды. Кэш должен все еще существовать, и следующий запрос должен достичь машины, которая его хранит. В Together AI мы рассматриваем движок вывода как машину для поддержания занятости GPU. Один GPU стоит около 50 000 долларов в год, поэтому Ideally он никогда не должен простаивать, и в любой момент он обслуживает сотни пользователей, каждый из которых находится в разной точке своего запроса. Трафик агентов оказывает давление на эти ограничения несколькими специфическими способами.

Маршрутизация запросов для оптимальных попаданий в кэш

Кэш сессии живет на определенном узле в определенном дата-центре. Если следующий шаг в разговоре попадает куда-то еще, этот узел должен обработать все предыдущие шаги с нуля, и теперь два узла хранят один и тот же префикс. Для правильной маршрутизации нам сначала нужно выбрать дата-центр, который запускает модель, имеет мощность и где сессия уже работала. Затем нам нужно выбрать узел внутри него, который имеет кэш предыдущих шагов.

Есть два основных способа выбрать узел. Простой способ — использовать ключ: клиент отправляет что-то вроде prompt_cache_key с каждым запросом, и тогда мы маршрутизируем каждый запрос с тем же ключом на один и тот же узел. Другой способ — хэшировать префикс и отправлять запрос на тот узел, который имеет самый длинный совпадающий префикс в кэше, даже если его поместила туда другая сессия.

Этот второй способ — еще одна причина держать системный промпт идентичным. Если каждая сессия харнеса начинается с точно такого же системного промпта и определений инструментов, совершенно новая сессия может найти эту настройку уже кэшированной. Если вы поместите уникальные идентификаторы туда, каждая сессия гарантированно начнет с холодного кэша.

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

Архитектура маршрутизации запросов в кластере Together AI
Архитектура маршрутизации запросов в кластере Together AI

Сохранение кэша живым между шагами

Маршрутизация помогает только в том случае, если кэш все еще существует. Агент часто выполняет вызов инструмента, а затем ждет несколько минут, пока запускаются тесты. Сохранение кэша этой сессии в памяти GPU все это время занимает место, которое нужно активным пользователям, а его выбрасывание означает перечитывание всего, когда агент возвращается из своих вызовов инструментов. Поэтому мы можем выгружать кэш в память CPU, пока сессия простаивает, и восстанавливать его для следующего шага.

Память — это ограничение, стоящее за большинством из этого. Мы не можем знать заранее, будет ли ответ 30 токенов или 30 000, поэтому вместо резервирования места для худшего случая максимальной длины контекста мы выдаем память кэша небольшими блоками по мере необходимости каждому запросу (PagedAttention), как операционная система управляет оперативной памятью. И мы перестраиваем текущий батч на каждом проходе (continuous batching), поэтому, когда агент запускает пять подагентов одновременно, каждый новый запрос занимает слот, как только один освобождается, а не ждет, пока закончится самый медленный в батче.

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

Агенты также выталкивают разделение префилл/декод до предела, с огромными промптами и крошечными ответами. Для лучшей оптимизации этого мы запускаем две фазы на отдельных кластерах. Один настроен на вычисления и делает префилл; другой настроен на пропускную способность памяти и делает декодирование для сотен потоков одновременно, с пересылкой кэша между ними через RDMA. Таким образом, волна длинных промптов агентов не замедляет потоковую передачу токенов для всех остальных.

Итоговая схема взаимодействия харнеса и движка вывода
Итоговая схема взаимодействия харнеса и движка вывода

05Что это значит на практике

Давайте соберем все это вместе в одной сессии. На стороне харнеса агент находит инструмент календаря и добавляет его в конец разговора, поэтому ничего выше него не меняется. Он читает calendar.py, видит, что получил только строки с 1 по 100 из 640, ищет «часовой пояс» и читает нужный раздел. Усилия остаются там, где они были в начале. Подагент-рецензент наследует сессию для проверки agenda.ics против sessions.json.

На стороне движка каждый шаг возвращается на узел, который имеет кэш сессии. Пока тесты запускаются, кэш ждет в памяти CPU. Запрос рецензента вставляется в текущий батч, и каждый шаг обрабатывает только то, что новое. Ничего из этого не видно человеку, использующему агента; он просто видит быстрый и эффективный результат. Понимание этих внутренних механизмов позволяет разработчикам создавать более надежные и экономичные агенты, используя открытые модели на полную мощность.

Источник: Ollama ↗