Агенты возвращаются — но теперь они кое-что умеют

•
Опубликовано
•
10 мин чтения

Текст написан с позиции марта 2025 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.

Почти два года назад к автономным агентам относились скептически — и по делу. Тогда вся индустрия носилась с AutoGPT и его клонами, и каждый второй тред обещал, что мы вот-вот делегируем целые проекты программе, которая сама поставит себе цели, сама разобьёт их на подзадачи и сама всё сделает. Скепсис был не из вредности, а потому что идея не работала. Агент уходил в бесконечный цикл, придумывал несуществующие файлы, тратил токены на пересказ собственных планов и в итоге выдавал что-то, что было быстрее написать руками. Формулировка той поры звучала жёстко: автономность без надёжного исполнения — это не помощник, а генератор уверенно звучащего мусора.

Применительно к той волне эта оценка была верна, и отказываться от неё не нужно. Но честность инженера измеряется не тем, как красиво он один раз оказался прав, а тем, готов ли он пересмотреть позицию, когда меняется фундамент под ней. А фундамент за эти два года поменялся. Поэтому речь не про то, что прежний скепсис был ошибкой — про AutoGPT он был справедлив. Речь про то, что вернулась не та же самая идея в новой обёртке. Вернулась другая вещь, которая просто называется тем же словом.

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

Почему волна 2023 года была обречена технически, а не идейно

Самая вредная реакция на нынешнее возвращение агентов — услышать «AutoGPT не сработал, а теперь сработает» и решить, что дело было в недостатке энтузиазма или в недокрученных промптах. Дело было не в этом. Волна 2023 года провалилась по вполне конкретным инженерным причинам, и полезно их назвать, потому что именно по этим точкам и прошёл сдвиг.

Первая причина — модели тогда не умели рассуждать. Они умели правдоподобно продолжать текст. Когда вы просили GPT-3.5 или раннюю четвёрку «составить план и выполнить его», вы получали текст, который выглядел как план, но за ним не стояло устойчивой пошаговой логики. Модель не проверяла промежуточные выводы, не возвращалась назад, не замечала, что на третьем шаге противоречит первому. Длинная цепочка действий накапливала ошибку, и к десятому шагу агент уверенно работал в выдуманной реальности.

Вторая причина — tool-use был сырым. Вызов инструментов делался через хрупкий парсинг текста: модель писала что-то похожее на JSON, обвязка пыталась это разобрать, и половина запусков ломалась на невалидном формате. Не было нормального протокола, по которому модель надёжно сообщает «я хочу вызвать функцию X с аргументами Y». Третья причина — у агента, по сути, не было рук. Доступ к файловой системе и терминалу был самодельным, небезопасным и ненадёжным. Агент «планировал» правку кода, но не мог толком ни прочитать репозиторий целиком, ни прогнать тесты, ни увидеть реальный вывод ошибки.

Сложите эти три дефицита вместе, и провал становится не загадкой, а неизбежностью. Это была не плохая идея с хорошей реализацией — это была разумная идея на фундаменте, который её не держал. И ключевой вывод отсюда не «агенты — обман», а «агенты были преждевременны». Разница принципиальная.

Три вещи, которые к началу 2025 года можно потрогать руками

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

Первое — reasoning-модели. Осенью OpenAI выпустила линейку o1, которая тратит дополнительное время на внутреннее рассуждение перед ответом, а в январе DeepSeek выложила R1 с открытыми весами и подробным описанием того, как такое поведение получают через обучение с подкреплением. Это не косметика. Модель, которая умеет остановиться, проверить промежуточный шаг и переиграть его, ведёт себя в длинной цепочке принципиально иначе, чем модель, которая просто продолжает текст. Накопление ошибки, на котором ломался AutoGPT, перестало быть фатальным — оно не исчезло, но стало управляемым.

Второе — нормальный tool-use. Function calling перестал быть хаком поверх парсинга текста и стал штатной, структурированной частью API у всех серьёзных провайдеров. Модель отдаёт вызов инструмента в предсказуемом виде, обвязка его исполняет и возвращает результат обратно в контекст. Это звучит как скучная техническая деталь, но именно она превращает «модель, рассуждающая вслух» в «модель, действующую в мире». Отдельно отмечу появление MCP — Model Context Protocol, который Anthropic опубликовала в конце прошлого года как открытый стандарт подключения моделей к внешним источникам данных и инструментам. Пока это ранняя история, экосистема только формируется, но направление ясное: tool-use перестаёт быть набором несовместимых самоделок и движется к общему контракту.

Третье — у агента появились руки. Ранние агентные IDE и CLI-инструменты дали модели реальный, а не бутафорский доступ к проекту: читать файлы целиком, видеть структуру репозитория, запускать команды в терминале, прогонять тесты и — что важнее всего — видеть их вывод. Агент больше не воображает результат своих действий. Он его наблюдает. И это замыкает петлю обратной связи, без которой никакая автономность невозможна в принципе.

Агенты не поумнели — под ними просто перестала проседать опора

Здесь важно не свалиться в другую крайность и не объявить, что агенты «поумнели и теперь всё решают». Это была бы ровно та же ошибка хайпа, только с обратным знаком. Поэтому сформулирую через противопоставление, которое для меня здесь центральное: дело не в том, что агенты стали умнее своих обещаний, а в том, что под старыми обещаниями наконец появился фундамент, способный их частично нести.

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

И ещё одно уточнение, чтобы не было иллюзий. Reasoning-модель ошибается реже не потому, что «понимает», а потому, что у неё больше шагов на самопроверку и лучше встроена возможность переиграть ход. Это статистический сдвиг качества, а не появление сознания или гарантий. На длинной автономной дистанции ошибка всё равно накопится. Поэтому ключ — не дистанция, а длина поводка.

Узко и проверяемо — вот два слова, после которых агент начинает приносить пользу

Приземлим до конкретики. Я перестал считать агентов бесполезными ровно в той зоне, где у задачи есть два свойства одновременно: она узкая и она проверяемая. Узкая — значит, у неё понятная граница, а не «сделай мне фичу». Проверяемая — значит, есть дешёвый и объективный способ узнать, получилось или нет: тест, компилятор, линтер, diff, ответ сервера. Когда оба свойства совпадают, агент перестаёт быть рискованной игрушкой и становится рабочим инструментом.

Вот где это видно на практике:

  • Починка падающего теста. Агент видит вывод теста, читает соответствующий код, вносит правку, снова запускает тест. Петля замкнута, критерий успеха однозначный.
  • Механический рефакторинг с проверкой компилятором: переименование, вынос модуля, замена устаревшего API. Компилятор и тесты служат страховкой на каждом шаге.
  • Написание обвязки и шаблонного кода — конфигов, простых эндпоинтов, типовых обработчиков, — где структура известна, а ошибки ловятся типами.
  • Разбор и локализация ошибки по стектрейсу: агент собирает контекст из нескольких файлов быстрее, чем человек переключается между ними.
  • Точечные миграции скриптами, где результат можно прогнать на тестовых данных и сверить.

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

Поводок остался коротким, и отпускать его пока рано

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

Граница простая и жёсткая: агент по-прежнему нужно держать на коротком поводке и проверять каждый шаг. Не итоговый результат — каждый шаг. Разница между человеком, у которого агенты работают, и человеком, у которого они «опять наврали», проходит ровно здесь. Первый запускает агента короткими циклами, читает каждый diff, держит изменения мелкими и обратимыми, не даёт ему уходить в автономное плавание на десятки действий подряд. Второй говорит «сделай всё», отворачивается и потом разбирает завал.

Почему так? Потому что фундаментальная проблема не решена, а лишь смягчена. Модель всё ещё может сгаллюцинировать API, которого нет. Всё ещё может уверенно объяснить, почему сломанное решение правильное. Всё ещё теряет нить на длинном контексте и начинает дрейфовать от исходной задачи. Длинная автономная цепочка по-прежнему накапливает ошибку — просто медленнее, чем в 2023-м. Короткий поводок — это не недоверие из вредности, это трезвый учёт того, что инструмент вероятностный, а не детерминированный.

Отсюда же вытекает, где агента почти наверняка не стоит пускать вперёд. Задачи без дешёвой проверки — продуктовые и архитектурные решения, проектирование схемы данных под долгую жизнь, изменения в коде, где цена ошибки в проде высока, а тестового покрытия нет. Там, где нельзя быстро и объективно убедиться, что шаг верен, автономность не помощник, а способ незаметно накопить дорогой долг. На таких задачах агент максимум полезен как генератор черновика, который человек потом разбирает целиком и под свою ответственность.

Как встроить агента в developer workflow и не обмануть себя

Если перевести всё это в практику, то картина получается спокойная и без драмы. Агенты в марте 2025-го — это не «новый способ писать софт» и не замена инженеру. Это ещё один инструмент в наборе, у которого есть узкая зона, где он экономит реальное время, и широкая зона, где он опасен. Зрелость в работе с ним — это не энтузиазм и не отказ, а точное понимание, где проходит граница между этими зонами.

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

Тут полезно зафиксировать, что смена оценки — не противоречие. «Автономные агенты не работают» было правдой про фундамент 2023 года. «На узких проверяемых задачах они работают» — правда про фундамент 2025-го. Между этими двумя утверждениями нет конфликта: под одной и той же идеей просто сменилась опора, и оценка едет следом за ней, а не наоборот.

Где мы оказались к марту 2025-го

Агенты вернулись, и это не повторение AutoGPT-волны. За два года под старой идеей выросли три реальные вещи: модели, умеющие рассуждать пошагово, структурированный tool-use и настоящий доступ к файлам и терминалу с наблюдаемой обратной связью. Этого хватило, чтобы на узком классе задач — узких и проверяемых — автономность из обещания превратилась в работающий инструмент. Не магически и не целиком, но реально.

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

Автор

Senior Principal JavaScript Developer, Tech Lead. Пишет о React, TypeScript, React Native, архитектуре фронтенда и бэкенда и о том, как AI меняет работу разработчика.

Читайте также