Сколько стоит AI-разработка: токены, лимиты и бюджет команды
Пока AI в разработке был автодополнением, вопрос денег почти никого не волновал. Подписка на ассистента стоила как пара обедов в месяц, и обсуждать её на планёрке было так же странно, как обсуждать стоимость лицензии на редактор. К осени 2026-го картина другая. Агенты берут на себя законченные задачи, гоняют тесты, читают половину репозитория, работают параллельно в нескольких ветках — и в какой-то момент в бухгалтерии появляется строчка, которая растёт быстрее, чем зарплатный фонд. Вопрос «сколько это стоит» перестал быть риторическим.
Самая вредная реакция на такую строчку — испугаться и начать резать доступ: «лимит на человека, и пусть экономят». Вторая по вредности — пожать плечами: «время инженера дороже токенов, о чём тут вообще говорить». Обе реакции объединяет одно: они не смотрят, куда именно уходят деньги. А уходят они очень неравномерно, и почти всегда основная часть счёта — не полезная работа модели, а повторение одного и того же контекста, зацикленные агенты и задачи, отданные слишком дорогой модели без необходимости.
Зафиксирую сразу: в этой статье не будет конкретных цен за миллион токенов. Они меняются каждые несколько месяцев, у разных провайдеров устроены по-разному, и любая цифра устареет раньше, чем статью дочитают. Важнее другое — порядки величин и механика, по которой счёт растёт. Если понимать механику, конкретный прайс становится просто коэффициентом в формуле, а не поводом для паники.
Подписка и оплата за токены — это две разные модели риска
У команды сегодня по сути два способа платить за AI-разработку. Первый — подписка на инструмент: фиксированная сумма в месяц за человека, внутри которой есть какой-то объём использования, ограниченный лимитами. Второй — прямой доступ к API с оплатой за каждый входной и выходной токен. Снаружи это выглядит как выбор тарифа. На деле это выбор того, кто несёт риск непредсказуемого потребления.
Подписка переносит этот риск на провайдера. Ты платишь фиксированную сумму, а провайдер страхует себя лимитами: в какой-то момент инструмент скажет «приходи через несколько часов» или переключит тебя на модель попроще. Для бюджета это идеально — расход известен заранее. Для работы это значит, что потолок есть, и упираешься ты в него ровно тогда, когда задача сложная и контекст тяжёлый, то есть в самый неудобный момент.
API устроен наоборот. Потолка нет, кроме технических rate limits, зато нет и страховки: агент, который ночью застрял в цикле, честно выставит счёт за каждую итерацию. Для автоматизации — CI, ревью-ботов, пакетной обработки — API почти всегда единственный вариант, потому что подписка рассчитана на человека за клавиатурой, а не на конвейер. Поэтому зрелая команда обычно приходит к гибриду: подписки для интерактивной работы инженеров и API с отдельным бюджетом и мониторингом для всего, что запускается без человека.
Важно не перепутать: подписка не «дешевле», а предсказуемее. При активном использовании агентов её фактическая стоимость в пересчёте на токены может оказаться в разы ниже, чем тот же объём через API, — провайдеры сознательно дотируют интерактивное использование. Но эта выгода существует только внутри лимитов, и строить на ней автоматизацию — значит строить на чужом решении о том, сколько тебе можно.
Почему один и тот же файл оплачивается двадцать раз
Главный источник расходов в агентной разработке — не генерация кода, а чтение. Модель не помнит прошлый запрос: каждый шаг агента — это новый вызов, в который заново отправляется весь накопленный контекст. Системный промпт, описание инструментов, инструкции проекта, прочитанные файлы, вывод тестов, история рассуждений. На первом шаге это несколько тысяч токенов, к двадцатому — уже сотни тысяч, и каждый следующий шаг платит за всё, что было до него.
Отсюда неочевидная арифметика. Агентная сессия из тридцати шагов с контекстом, который вырос до сотни-другой тысяч токенов, потребляет на входе не сотню тысяч, а миллионы токенов суммарно. Выходных токенов при этом — код, ответы, правки — может быть на два порядка меньше. Если сформулировать совсем прямо: в агентной работе платишь не за то, что модель написала, а за то, сколько раз она перечитала одно и то же.
Из этого следуют вполне практичные вещи. Огромный файл с инструкциями проекта, который «на всякий случай» описывает всё подряд, — это налог на каждый шаг каждой сессии каждого инженера. Тест, который выводит в консоль тысячи строк, — это налог на каждую итерацию «запустить тесты, посмотреть, поправить». Агент, которому разрешили прочитать целиком сгенерированный файл или лок-файл на десятки тысяч строк, тащит этот файл через весь остаток сессии. Ни одна из этих вещей не выглядит как расход, пока не посмотришь на счёт.
Prompt caching меняет порядок цифр, если ему не мешать
Провайдеры прекрасно понимают эту арифметику, поэтому у всех крупных игроков есть кэширование промптов. Если начало запроса совпадает с недавно отправленным, повторная часть обрабатывается по сильно сниженной цене — речь идёт о кратной разнице, а не о скидке в десять процентов. Для агентной сессии, где каждый шаг повторяет весь предыдущий контекст, это означает, что основная масса входных токенов может стоить в разы дешевле номинала.
Ключевое слово — «начало». Кэш работает по префиксу: всё, что совпадает с прошлым запросом от первого токена до первого отличия, берётся из кэша, всё после — считается заново. Поэтому порядок частей контекста — не эстетика, а экономика. Стабильное (системный промпт, инструменты, инструкции проекта) должно идти первым, изменчивое — в конце. Вставить в начало системного промпта текущее время или случайный идентификатор запроса — значит тихо отключить кэш для всей сессии и удивиться счёту.
У кэша есть и своя цена. Запись в кэш обычно стоит чуть дороже обычного входа, а живёт кэш ограниченное время — минуты, если не платить за более долгое хранение. Агент, который делает паузу в ожидании человека, может вернуться к остывшему кэшу и заплатить за весь контекст по полной. Готовые инструменты для разработчиков, как правило, уже выстраивают контекст с оглядкой на кэш. Но как только команда пишет собственную автоматизацию поверх API, эта забота переходит к ней, и проверять процент попаданий в кэш стоит так же регулярно, как время сборки.
Агент в цикле стоит дороже, чем агент, который ошибся
Ошибка агента — это нормально и дёшево: он сделал не то, ты это увидел, поправил постановку. Дорого другое — когда агент не может ни закончить, ни сдаться. Тест падает, агент правит код, тест падает иначе, агент откатывает правку, тест падает как в первый раз. Каждая итерация добавляет в контекст вывод тестов и рассуждения, контекст растёт, стоимость шага растёт вместе с ним. Через час такая сессия может стоить больше, чем неделя обычной работы того же инженера с ассистентом.
Похожая история с повторами на уровне инфраструктуры. Запрос упал по таймауту или упёрся в rate limit, клиент автоматически повторил его — и если повтор идёт с полным контекстом без кэша, ты платишь за одну и ту же работу дважды. В собственных пайплайнах это легко проглядеть: в логах видно «успешно», а то, что успеху предшествовали три неудачные попытки с полным контекстом, видно только в счёте.
Лечится это не запретами, а ограничителями. У любой автоматической сессии должен быть бюджет — по шагам, по токенам или по времени, — после которого она останавливается и отдаёт управление человеку с отчётом о том, что пыталась сделать. Агент, который честно сказал «не получилось, вот три гипотезы», стоит дешевле и полезнее агента, который молча сжёг бюджет и выдал зелёный, но бессмысленный результат.
Параллельные агенты умножают не только скорость
В 2026-м стало нормой запускать несколько агентов одновременно: один пишет фичу, второй разбирается с флаки-тестом, третий делает ревью, четвёртый исследует незнакомый модуль. Это действительно ускоряет работу — пока инженер думает над одной задачей, остальные двигаются. Но у параллельности есть простая и жёсткая арифметика: каждый агент несёт собственный полный контекст, и кэш между ними работает только там, где у них совпадает префикс.
Особенно это заметно в схеме «оркестратор и субагенты». Оркестратор раздаёт задачи, каждый субагент заново читает инструкции проекта, заново исследует нужные файлы, заново строит картину. Если задачи пересекаются, команда платит за одно и то же исследование кодовой базы несколько раз. Это не повод отказываться от параллельности — изоляция контекста часто как раз повышает качество, потому что каждый агент не тонет в чужих деталях. Это повод помнить, что пять агентов — это примерно пять счетов, а не один счёт, поделённый на пять.
Почему это важно для бюджета? Потому что параллельность масштабируется молча. Один инженер, который освоил работу с пятью агентами, тратит как пятеро. Если таких инженеров в команде несколько, расходы растут не линейно по головам, а по произведению голов на агентов. Это нормально, если ускорение того стоит, — но проверять, стоит ли, нужно цифрами, а не ощущением.
Большая модель на каждом шаге — это как сеньор, который сам заводит тикеты
Разница в цене между старшей и младшей моделью одного провайдера обычно составляет порядок, иногда больше. При этом значительная часть шагов в агентной работе не требует сильной модели вообще: найти файлы по описанию, выжать суть из длинного лога, проверить, что ответ соответствует формату, классифицировать задачу, переименовать символ по всему проекту. Отдавать такие шаги самой дорогой модели — всё равно что поручать архитектору раскладывать бумаги по папкам.
Разумная схема выглядит так: младшие модели на дешёвых и проверяемых шагах — поиск, суммаризация, разметка, механические правки, — старшие на том, где цена ошибки высока: проектирование, нетривиальный код, ревью логики. Многие инструменты уже умеют так маршрутизировать сами, и важно не сломать это ручной настройкой «всегда использовать максимальную модель, потому что так надёжнее».
Но важно не свалиться в другую крайность. Экономия на модели для написания кода почти всегда обходится дороже, чем выглядит. Слабая модель напишет код, который компилируется, но требует втрое больше времени на ревью и переделку, — и эти часы человека стоят несравнимо больше сэкономленных токенов. Правило тут простое: на шагах, где результат проверяется автоматически и дёшево, экономь смело; на шагах, где результат проверяет человек, плати за качество.
Rate limits — это ограничение по пропускной способности, а не по деньгам
Даже команда с неограниченным бюджетом упирается в лимиты. У API есть ограничения на число запросов и токенов в минуту, у подписок — окна использования и недельные потолки. Когда десяток инженеров одновременно гоняют агентов через один организационный ключ, лимит превращается в общую очередь, и запросы начинают отваливаться именно в пиковые часы, когда всем одновременно нужно.
Это меняет то, как стоит думать о ресурсе. AI-мощность команды — это не только деньги в месяц, но и пропускная способность в минуту, и ею нужно управлять так же, как управляют общими раннерами CI. Разделять ключи для интерактивной работы и для автоматизации, чтобы ночной пакетный прогон не съедал лимит у людей. Переносить несрочные задачи — массовое ревью, генерацию документации, анализ старых модулей — в пакетный режим, который у многих провайдеров заметно дешевле и не конкурирует с интерактивными запросами. Закладывать в автоматизацию корректную обработку отказов с паузой, а не мгновенный повтор, который только усиливает затор.
У лимитов подписок есть и человеческое измерение. Инженер, который упёрся в недельный потолок в среду, до конца недели работает иначе, и его производительность падает не потому, что он хуже, а потому, что инструмент, вокруг которого выстроен его workflow, внезапно исчез. Если такое происходит регулярно, это сигнал не «тратить меньше», а пересмотреть тариф или посмотреть, на что уходит лимит.
Как считать окупаемость, не обманывая себя
Самая популярная метрика ROI в AI-разработке — «сколько времени сэкономили» — почти всегда завышена. Инженер помнит, что фича, на которую раньше ушёл бы день, сделана за час. Он не помнит, что потом полтора часа читал диф, ещё час разбирался с тонкой ошибкой в краевом случае, а через две недели коллега переписал половину, потому что код не вписался в архитектуру. Время генерации видно сразу, время проверки и переделки размазано по неделям.
Честный расчёт поэтому смотрит не на момент генерации, а на весь путь изменения до стабильного состояния. Сколько времени от постановки задачи до мержа, включая ревью. Сколько изменений, сделанных с участием агента, вернулись на доработку или были откатаны. Сколько времени ревьюеры тратят на AI-шные pull request'ы по сравнению с обычными. Как меняется число инцидентов. Ни одна из этих метрик не идеальна, но вместе они дают картину, которую нельзя получить из ощущения «стало быстрее».
И ещё одна поправка, которую часто забывают: стоимость AI-разработки — это не только счёт провайдера. Это время на ревью, которое растёт вместе с объёмом сгенерированного кода. Это когнитивная нагрузка на тех, кто поддерживает кодовую базу, в которой всё больше кода, который никто не писал руками. Это риск, что команда разучится делать то, что отдала машине. Деньги на токены — самая видимая и, как ни странно, часто самая маленькая часть этой суммы.
Если сравнить порядки, картина обычно такая: даже щедрый бюджет на AI в пересчёте на инженера составляет небольшую долю его стоимости для компании. Поэтому вопрос «не слишком ли много мы тратим на токены» почти всегда менее важен, чем вопрос «не слишком ли много мы тратим на исправление того, что токены произвели». Первый решается настройкой, второй — процессом.
Что бюджет команды должен видеть, чтобы им можно было управлять
Управлять тем, что не измеряется, невозможно, а AI-расходы по умолчанию измеряются плохо: один общий счёт в конце месяца, без разбивки. Минимум, который стоит иметь, — расходы в разрезе людей и автоматизаций, доля кэшированных токенов, распределение по моделям и список самых дорогих сессий за неделю. Последний пункт обычно самый полезный: в топе почти всегда оказываются зациклившиеся агенты и пайплайны с неудачно собранным контекстом, а не самые продуктивные инженеры.
Дальше включаются простые правила, которые не мешают работе, но срезают большую часть лишнего. Компактные инструкции проекта вместо энциклопедии на десятки тысяч токенов. Тихий вывод тестов и сборки, когда агент их запускает. Бюджет на шаги у каждой автоматической сессии. Маршрутизация дешёвых шагов на младшие модели. Отдельные ключи и лимиты для людей и для конвейеров. Ничего из этого не требует героизма — это та же гигиена, которую команды давно применяют к времени сборки и стоимости облачной инфраструктуры.
Важно и то, чего делать не стоит. Жёсткий персональный лимит «на всякий случай» превращает инженеров в бухгалтеров собственных токенов: они начинают экономить на контексте, давать агенту меньше информации и получать худший результат, за который потом платят временем ревью. Цель не в минимальном счёте, а в том, чтобы каждая потраченная единица работала, а не уходила на перечитывание лок-файлов.
Итог
Экономика AI-разработки в 2026-м устроена не так, как кажется по первому счёту. Основные деньги уходят не на генерацию кода, а на многократную пересылку контекста, зацикленных агентов, повторы и слишком дорогие модели на простых шагах. Prompt caching, порядок контекста, бюджеты сессий и маршрутизация по моделям меняют итоговую сумму кратно — без отказа от инструментов и без ухудшения результата.
При этом токены — не главная статья расходов. Главная — время людей на проверку, исправление и поддержку того, что произвела машина. Поэтому окупаемость стоит считать по всему пути изменения до стабильного состояния, а не по моменту, когда агент отчитался об успехе.
Если сформулировать главный практический вывод совсем прямо: не экономьте на модели там, где результат проверяет человек, и не переплачивайте за повторение контекста там, где его можно закэшировать или вообще не отправлять. Первое бережёт время команды, второе — её бюджет, и именно в таком порядке приоритетов.