У агентов для написания кода довольно необычный паттерн трафика. Каждый раз, когда агент делает шаг, обвязка отправляет модели весь разговор целиком: системный промпт, все определения инструментов, ваш запрос, каждый прочитанный агентом файл и каждую запущенную им команду. Возвращает же она обычно вызов инструмента длиной в несколько десятков токенов. Затем все повторяется снова: все то же самое с прошлого раза плюс еще немного.
Такая большая длина входной последовательности (ISL) и малая длина выходной последовательности (OSL) характерны для большинства агентских рабочих нагрузок. Если бы GPU приходилось обрабатывать всю эту стенограмму с нуля на каждом шаге, длинные сессии становились бы все медленнее и дороже с каждым новым шагом. Префиксное кэширование избавляет от большей части этой работы. Проблема в том, что если не проявлять осторожность, префиксный кэш очень легко сломать.
Мы подходим к этой проблеме с противоположных сторон. Ollama работает над интеграциями обвязок, что означает принятие решений о том, что попадает в каждый запрос. Together AI работает над движком вывода, что означает определение того, что происходит при поступлении этого запроса. Мы постоянно обнаруживаем, что большая часть нашей работы с каждой стороны связана с защитой кэша от того, что с ним может сделать другая сторона, поэтому мы захотели записать все это в одном месте, чтобы помочь разработчикам как агентов, так и инфраструктуры!
Как выглядит шаг агента для GPU
Каждый запрос проходит через две фазы. Первая — префилл (предварительное заполнение): движок считывает весь промпт за один большой параллельный проход и выдает первый токен. GPU хороши в этом, потому что это большой объем математических вычислений, выполняемых одновременно, что максимизирует арифметическую интенсивность. Префилл определяет, сколько времени вы ждете появления любых новых токенов. Вторая — декодирование: модель дописывает остаток ответа по одному токену за раз, и каждый новый токен требует чтения и внимания ко всему, что было до него. Декодирование ограничивается пропускной способностью памяти больше, чем вычислительной мощностью, и оно определяет скорость потоковой передачи текста.
Обычный ответ в чате проводит время в обеих фазах, в то время как шаг агента — это в основном префилл, поскольку входом является вся сессия, а выходом обычно является короткий вызов инструмента. Модели рассуждений добавляют поверх этого токены размышлений, иногда в большом количестве, но по мере того, как сессия вырастает до десятков тысяч токенов, ввод все равно доминирует. С каждым шагом ввод становится длиннее, а вывод остается примерно прежнего размера — несколько вызовов инструментов.
Таким образом, для агентов вопрос «насколько быстра эта модель?» в основном означает «как быстро она может справиться с длинной исторической хроникой предыдущих шагов?». Способ быстро обработать задачу с большим количеством предыдущих шагов заключается в том, чтобы просто кэшировать ее и считывать обратно, вместо того чтобы пересчитывать заново.
Кэш — всему голова
Проще всего представить KV-кэш (или даже префиксный кэш, если уж на то пошло) на примере чтения. Представьте, что для чтения каждого нового слова на странице вам приходилось бы начинать сначала с самого верха. Чем дальше вы продвигались бы по странице, тем медленнее вы бы двигались, потому что вам постоянно приходилось бы перечитывать все, что вы уже прочитали. Это модель без кэша. Кэш решает эту проблему в рамках одного запроса: движок сохраняет работу, проделанную над предыдущими токенами (в виде промежуточных пар ключ-значение) и вычисляет только новый.
Префиксное кэширование делает то же самое для разных запросов. Шаг 7 агентской сессии — это шаг 6 плюс еще немного, поэтому, если движок все еще хранит результаты работы шага 6, ему нужно обработать только новую часть.
Арифметика проста. Если каждый шаг добавляет одинаковое количество, десять шагов без кэширования обрабатывают 1 + 2 + … + 10 = 55 единиц промпта. С кэшированием они обрабатывают 10. При ста шагах, что не редкость для задачи кодирования, получается 5050 против 100. Реальные шаги различаются по размеру, поэтому воспринимайте эти цифры как идеализированные. Кэшированная сессия тоже не является полностью бесплатной, так как каждый новый токен все равно должен учитывать кэшированные. Но закономерность сохраняется: без кэширования объем работы, которую вы переделываете, растет пропорционально квадрату длины сессии.
Подвох заключается в том, что префиксный кэш сопоставляет промпт с самого начала и до первого отличающегося токена, после чего останавливается. Все, что идет после этого первого различия, приходится обрабатывать заново.
Добавление в конец промпта ничего не стоит. Изменение чего-либо раньше, даже одного символа, означает повторную обработку всего, что следует за этим. Если изменение происходит ближе к началу, вы фактически выбросили всю сессию и теперь должны перестроить кэш. Практически все остальное в этой статье проистекает из этого единственного правила.
Обвязка решает, где окажется это первое изменение. Движок решает, остался ли кэш на месте при поступлении следующего запроса. Начнем с обвязки.
Обвязки и API
Со стороны Ollama мы добавили возможность подключать вашу любимую обвязку с помощью команды ollama launch. Таким образом, вы можете подключать такие обвязки, как Claude Code, Codex, Pi (и другие), к открытым моделям вроде DeepSeek-V4.1-Flash и GLM-5.3 и сохранять свои привычные рабочие процессы.
Подключение обвязки к API может показаться простым делом, но между обвязкой и моделью существует множество уровней трансляции и различных ожиданий. Это часто становится причиной сбоев кэша (влекущих за собой временные и финансовые затраты), необъяснимого поведения агента и прямых ошибок обвязки.
Поздняя загрузка инструментов
В арсенале обвязок сейчас довольно много инструментов. Если каждое определение попадает в промпт сразу, вы тратите контекст на инструменты, которые задача никогда не использует, и модель хуже справляется с выбором правильного. Новые обвязки добавили функцию поиска инструментов для решения этой проблемы, при которой инструмент может быть загружен и использован самим агентом после его поиска.
Допустим, у вас есть личный ассистент в виде агента, обладающего такой возможностью. Вы просите агента экспортировать добавленные вами в избранное события в календарь, и он ищет «calendar», загружает определение save_calendar и вызывает его.
Для кэша вопрос заключается в том, куда попадает это определение.
Очевидный подход — добавить определение в список инструментов. Это работает, но список инструментов находится ближе к началу промпта, перед разговором. Поэтому, если префикс изменяется, все, что идет после него, обрабатывается заново. На длинной сессии это могут быть сотни тысяч токенов. Лучший подход — поместить определение в конец, куда в любом случае отправляется новый контент.
За исключением того, что не каждая модель поддерживает это. Некоторые шаблоны чата не предполагают появление определения инструмента посреди разговора, и вызов завершается ошибкой. Так что возможность обвязки загружать инструменты с поздним связыванием без дополнительных затрат зависит от модели. Пользователи не должны этого знать, но любой разработчик обвязки обязан.
Изменения в верхней части
Самый простой способ разрушить кэш — поместить в системный промпт что-то, что меняется от шага к шагу, например текущую метку времени, статус git или рабочий каталог, по которому агент продолжает перемещаться. Если обвязка заново рендерит системный промпт со свежими значениями на каждом шаге, каждый шаг превращается в полное перечитывание.
Вещи, которые фиксированы для сеанса, но различаются между сеансами, такие как имя пользователя или дата начала сеанса, не вредят этому сеансу. Но они мешают новым сеансам повторно использовать уже закэшированную конфигурацию, о чем мы поговорим со стороны движка. В любом случае решение одинаково: укажите эту информацию в сообщении задачи один раз и везде сохраняйте системный промпт абсолютно одинаковым.
Уровень рассуждений
Мы столкнулись с этим на стороне Ollama. В GLM-5.3-Flash уровень рассуждений не является отдельной настройкой, которой движок управляет отдельно. Чат-шаблон записывает его прямо в самый первый системный блок, перед инструментами и беседой.
Допустим, вы глубоко погружены в долгую задачу, и она идет не лучшим образом. Вы повышаете уровень рассуждений с низкого на высокий. Это разумный шаг, но теперь следующий запрос отличается от предыдущего почти с самого первого токена. Это означает, что весь сеанс обрабатывается заново. При длительной работе на это могут уходить сотни тысяч токенов, потраченные на изменение всего одной настройки.
Наш совет — выбрать уровень рассуждений в самом начале и оставить его прежним. Если вам действительно требуется больше размышлений, зачастую дешевле запустить новый сеанс с более высокими настройками, чем продолжать старый, к тому же вы получите чистый контекст. Вы также можете выполнить сжатие перед изменением значения рассуждений, чтобы уменьшить количество токенов в промпте.
Большие результаты инструментов
Вывод инструмента становится частью следующего запроса и каждого последующего запроса. Если агент читает файл на 3000 строк, когда ему требовалось сорок, вы платите за это не один раз; вы платите за это на каждом оставшемся шаге (даже если он закэширован, вы теряете место в окне контекста). Чтобы бороться с этим, обертки часто сокращают вывод инструментов. Это правильный подход, но то, как именно вы сокращаете вывод, имеет значение.
Вот ошибка, которую легко допустить случайно. Задача состоит в том, чтобы исправить ошибку с часовыми поясами в экспорте календаря. Агент читает calendar.py, и инструмент возвращает первые 100 строк файла из 640 строк, не сообщая о том, что вывод был остановлен. Нужная функция convert_timezone находится на строке 420. Модель понятия не имеет, что чего-то не хватает.
Решение заключается в одной дополнительной строке в выводе, которая сообщает модели, что она получила строки с 1 по 100 из 640 и что она может выполнить поиск по файлу или запросить другой диапазон. После этого модель ищет «timezone», находит строку 420 и читает строки с 410 по 450. Сокращение вывода экономит деньги. Сокращение без предупреждения приводит к тому, что модель уверенно редактирует код, который она никогда не видела.
Субагенты
Открытые модели, такие как Kimi K3, GLM-5.3 и GLM-5.3-Flash, теперь довольно хорошо справляются с разделением большой задачи и передачей частей субагентам. То, как обертка запускает каждого субагента, определяет, какая часть кэша родительского процесса может быть повторно использована.
Один из вариантов — наследование субагентом всего: того же системного промпта, инструментов и беседы плюс его собственного задания. Побочные чаты работают именно так. Они ответвляются от родительского сеанса, поэтому весь префикс уже закэширован. Другой вариант — отправить бриф: тот же системный промпт и инструменты, а затем только те файлы и инструкции, которые нужны субагенту. В этом случае кэш охватывает только настройку и ничего более.
Наследование звучит явно лучше, но это не так. Закэшированный префикс дешево обрабатывать, но не бесплатно. Каждый токен, генерируемый субагентом, все равно должен считываться через него, и все это время он занимает память GPU. Ревьюеру, которому нужны два файла и чек-лист, вероятнее всего, не нужны триста шагов истории. А если вы дадите субагенту собственный системный промпт, он вообще ничего не будет делить с родителем, даже конфигурацию.
Сторона движка
Вы можете сделать все вышеперечисленное идеально и все равно не получить преимуществ. Кэш должен существовать, и следующий запрос должен дойти до машины, на которой он хранится.
В Together AI мы рассматриваем движок выводов как машину для загрузки GPU работой. Аренда одного GPU стоит около 50 тысяч долларов в год, поэтому в идеале он никогда не должен простаивать, а в любой момент времени он обслуживает сотни пользователей, каждый из которых находится на разном этапе своего запроса. Трафик агентов создает нагрузку на эти ограничения несколькими специфическими способами.
Маршрутизация запросов для оптимального попадания в кэш
Кэш сеанса хранится на конкретном узле в конкретном дата-центре. Если следующий шаг беседы попадает в какое-либо другое место, этому узлу приходится обрабатывать все предыдущие шаги с нуля, и теперь два узла хранят один и тот же префикс. Для правильной маршрутизации нам сначала нужно выбрать дата-центр, в котором работает модель, есть свободные мощности и где выполнялся сеанс. Затем нам нужно выбрать узел внутри него, в котором есть кэш предыдущих шагов.
Существует два основных способа выбора узла. Простой способ — использовать ключ: клиент отправляет что-то вроде prompt_cache_key с каждым запросом, и тогда в идеале мы направляем каждый запрос с одинаковым ключом на один и тот же узел. Другой способ — хешировать префикс и отправлять запрос на тот узел, у которого закэширован самый длинный совпадающий префикс, даже если его туда поместил другой сеанс.
Этот второй вариант — вторая причина сохранять системный промпт идентичным. Если каждый сеанс обертки начинается с абсолютно одинакового системного промпта и определений инструментов, совершенно новый сеанс сможет найти эту конфигурацию уже закэшированной. Если вы добавите туда уникальные идентификаторы, то каждый сеанс гарантированно начнется с нуля.
Все также не так просто, как всегда отправлять запрос на «теплый» узел. Иногда «теплый» узел перегружен трафиком, и тогда выбор стоит между тем, чтобы постоять там в очереди, или занять простаивающий узел и заплатить за повторную обработку префикса. В этой парадигме маршрутизации с учетом нагрузки промах мимо кэша иногда может быть лучшим решением. Так что даже идеально стабильный промпт не гарантирует попадания, если движок выводов на бэкенде реализован неправильно.
Поддержание кэша в актуальном состоянии между шагами
Маршрутизация помогает только в том случае, если есть кэш, на который можно перенаправить запрос. Агент часто делает вызов инструмента, а затем ждет пару минут, пока выполняются тесты. Удержание кэша этого сеанса в памяти GPU все это время занимает пространство, необходимое активным пользователям, а его удаление означает повторное чтение всего при возвращении агента после вызовов инструментов. Поэтому мы также можем выгрузить кэш в память CPU, пока сеанс простаивает, и восстановить его для следующего шага.
Память — это ограничение, лежащее в основе большинства этих процессов. Мы не можем заранее знать, будет ли ответ состоять из 30 или 30 000 токенов, поэтому вместо того, чтобы резервировать место под худшие сценарии максимальной длины контекста, мы выдаем кэш-память небольшими блоками по мере необходимости для каждого запроса (PagedAttention), подобно тому, как операционная система управляет ОЗУ. И мы перестраиваем выполняемый пакет при каждом проходе (continuous batching), поэтому, когда агент одновременно запускает пять субагентов, каждый новый запрос занимает слот в момент освобождения одного из них, вместо того чтобы ждать окончания самого медленного в пакете.
Результатом для всех, кто создает обертку, является то, что именно запас кэш-памяти, а не вычислительная мощность, обычно ограничивает количество запросов, которые GPU может обслуживать одновременно. Каждый избыточный результат инструмента и каждый субагент, переносящий нерелевантную историю, занимают память, которую мог бы использовать кэш другого сеанса.
Агенты также доводят разделение на префилл (prefill) и декодирование (decode) до предела, используя огромные промпты и крошечные ответы. Чтобы лучше оптимизировать этот процесс, мы запускаем обе фазы на отдельных кластерах. Один из них настроен на вычислительную мощность и выполняет префилл; другой настроен на пропускную способность памяти и выполняет декодирование для сотен потоков одновременно, при этом кэш передается между ними через RDMA. Таким образом, поток длинных промптов агента не замедляет генерацию токенов для всех остальных.
Собираем всё вместе: один сеанс, обе стороны
Вот как всё это выглядит в рамках одного сеанса.
Со стороны обвязки (harness) агент находит инструмент календаря и добавляет его в конец беседы, поэтому всё, что было выше, не меняется. Он считывает calendar.py, видит, что получил только строки с 1 по 100 из 640, ищет «timezone» и считывает нужный раздел. Усилия остаются на прежнем уровне. Субагент-рецензент наследует сеанс, чтобы сверить agenda.ics с sessions.json.
Со стороны движка каждый ход возвращается к узлу, в котором кэширован сеанс. Пока выполняются тесты, кэш ожидает в памяти CPU. Запрос рецензента встраивается в текущий пакет, и каждый ход обрабатывает только то, что появилось нового.
Ничего из этого не заметно человеку, использующему агента; он просто видит, что работа остается быстрой и на девяностом шаге. Но это работает только в том случае, если обе стороны выполняют свою часть задачи. Обвязка может поддерживать промпт идеально стабильным и всё равно потерять кэш, если движок отправит 7-й ход не на ту машину. Движок может идеально маршрутизировать запросы и всё равно потерять кэш, если обвязка меняет первую строку на каждом ходу.
Парт пишет больше о создании агентов на parthsareen.com, а Ollama публикует обновления на ollama.com/blog. Вы также можете прочитать больше об упомянутых здесь открытых моделях и запустить их на https://www.together.ai/blog.












