Что означают предупреждения об безопасности ИИ от бывших исследователей Anthropic для разработчиков

Искусственный интеллект развивается с такой скоростью, что легко забыть о том, насколько он казался ограниченным всего лишь недавно.

Недавно работа с ИИ обычно подразумевала ввод вопроса в чат-бота и получение ответа. С тех пор модели значительно улучшились в создании кода, интерпретации изображений, генерации полноценных приложений, парсинге документов, вызове внешних инструментов и обработке гораздо больших объемов контекста.

Сегодня фокус сместился на агентов ИИ, способных самостоятельно выполнять задачи, а не просто отвечать на запросы.

Это изменение имеет большое значение.

Оно также преобразует более широкие дискуссии о том, куда движется ИИ.

Бывший сотрудник компании Anthropic Джейкоб Коксон недавно ушел с должности и публично предупредил, что создание все более мощных систем искусственного интеллекта сопряжено с серьезными рисками. Его заявление привлекло значительное внимание именно потому, что оно исходило не от критика извне этой области — он сам работал над разработкой передовых систем искусственного интеллекта в одной из компаний, занимающихся их созданием. Несколько других исследователей выразили подобные опасения, а генеральный директор Anthropic Дарио Амодей публично призвал отрасль замедлить разработки на передовой и внедрить более строгие меры безопасности.

Недавно Билал Чугтай, бывший исследователь Google DeepMind, выразил аналогичные опасения относительно возможности катастрофических последствий использования искусственного интеллекта.

Подобные заявления стоит внимательно рассмотреть.

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

Это не то утверждение, которое делается.

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

Все, кто изучает информатику или разрабатывает проекты, основанные на ИИ, также заинтересованы в этом обсуждении.

Не потому, что каждый разработчик должен стать экспертом по безопасности ИИ.

А потому, что именно разработчики в конечном итоге превращают эти системы в рабочее программное обеспечение, которым фактически пользуются люди.

Дело на самом деле не в чат-ботах

Когда кто-то слышит утверждение вроде «ИИ может уничтожить нас всех», обычно возникает образ робота из научной фантастики, приобретающего сознание и нападающего на человечество.

Такой подход здесь не особенно полезен.

Настоящая проблема заключается в системах, которые становятся всё более мощными, автономными и обладают всё более широким доступом к инструментам, данным и внешним ресурсам.

Существует значительный разрыв между ИИ, который отвечает на вопросы вроде:

"Как написать эту функцию на Python?"

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

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

Это действительно полезно.

Но именно здесь становится сложнее всё анализировать.

По мере того как система становится более мощной, установленные для неё ограничения приобретают ещё большее значение.

Искусственный интеллект, способный генерировать только текст, может нанести лишь ограниченный ущерб в случае ошибки.

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

Это уже не просто генерация вывода.

Это осуществление действий в реальном мире.

А действия имеют последствия.

То, что вызывает у меня беспокойство

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

Программа может пройти все тесты в контролируемой среде, но всё равно сломаться при взаимодействии с реальным миром.

API может возвращать данные, которые никто не планировал.

База данных может хранить записи, которые так и не были должным образом очищены.

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

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

Системы ИИ унаследовывают все эти риски.

В некотором смысле они умножают их.

Традиционное программное обеспечение в основном следует правилам, которые инженеры явно описывают.

В отличие от этого, системы ИИ генерируют результаты, которые никто не вводил напрямую.

Это одна из причин их мощи.

Это также то, что затрудняет их безопасную разработку.

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

Настоящий вопрос заключается в том, что происходит, когда она допускает ошибки.

Что будет, если входные данные некорректны?

Что произойдет, если зависимый API выйдет из строя?

Что произойдет, если модель неправильно интерпретирует цель запроса?

Что произойдет, если кто-то намеренно предоставит ей вредоносный контент?

Что произойдет, если агент получит доступ к инструменту, с которым у него нет права взаимодействовать?

И, возможно, самый сложный вопрос из всех:

Что произойдет, когда система сделает что-то, чего никто не ожидал?

По мере того как ИИ-системы становятся все более автономными, именно эти вопросы имеют наибольшее значение.

Гонка в области ИИ — часть проблемы

Существует еще один аспект, который легко упустить из виду.

Конкуренция.

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

Эта конкуренция способствовала значительному прогрессу.

Она также создала огромное давление для быстрой разработки.

Представьте две компании, соревнующиеся в создании всё мощнее систем. Одна решает снизить темпы, чтобы уйти в запас времени на тестирование. Другая продолжает двигаться вперед на полной скорости. Вдруг компания, действовавшая осторожно, начинает беспокоиться из-за возможного отставания.

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

В таком случае снижение темпов уже не является чисто техническим решением.

Оно превращается в экономическое, политическое и стратегическое решение.

Именно этот контекст делает недавнее предложение Дарио Амодеи достойным внимания. Он утверждает, что темпы развития передовых ИИ-технологий необходимо контролировать осознанно, и предлагает такие механизмы, как независимые оценщики от третьих сторон, общие критерии безопасности и более тесная международная координация. Сэм Альтман и Илон Маск оба выразили поддержку идеи о том, что прогресс в области передовых ИИ-технологий следует контролировать более тщательно.

Но остается сложный вопрос.

Кто будет решать, что на самом деле означает «слишком быстро»?

И кто будет контролировать соблюдение этих стандартов, когда они появятся?

Это гораздо более сложная проблема, чем простое требование к компаниям быть более осторожными.

Следует ли замедлить развитие ИИ?

Здесь нет однозначного ответа «да» или «нет».

С обеих сторон есть веские аргументы.

ИИ, безусловно, приносит много пользы.

Это помогает исследователям разбираться в сложном научном материале.

Оно поддерживает врачей и медицинских исследователей.

Оно ускоряет разработку программного обеспечения.

Это помогает студентам учиться.

Оно дарит малым предприятиям новые возможности.

Оно устраняет языковые барьеры и расширяет доступ к информации.

Оно способствует исследованиям климата, прогнозированию стихийных бедствий и решению множества других сложных проблем.

Эти преимущества не являются гипотетическими.

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

Цель подобного проекта — не просто обучить модель и показать одно числовое значение.

Настоящая цель — создание полноценной системы на основе этой модели.

Это означает сбор надежных данных, их правильное хранение, обработку, обучение на этих данных, предоставление прогнозов через API и, наконец, отображение результатов в панели управления.

Работа с этим циклом делает одну вещь очевидной.

Искусственный интеллект мощен именно потому, что его можно встроить в более крупную систему.

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

Плохие входные данные приводят к плохой модели.

Плохая модель приводит к тому, что API возвращает вводящие в заблуждение ответы.

А если фронтенд представляет эти результаты как нечто определенное, пользователи могут начать доверять тому, что на самом деле является лишь вероятностью, а не фактом.

Этот пример кажется незначительным по сравнению с искусственным интеллектом масштаба передовых технологий.

Но принципы инженерии применимы в любом масштабе.

Чем более мощной становится система, тем большая ответственность возлагается на нее.

Злоупотребления в реальном мире уже происходят

Нет причин ждать, пока какая-то гипотетическая сверхинтеллектуальность начнёт серьёзно относиться к безопасности ИИ.

Злоупотребления уже имеют место сегодня.

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

Почему это важно? Потому что это меняет всю перспективу обсуждения.

Безопасность — это не просто вопрос о том, превзойдёт ли какая-то будущая машина человеческий интеллект.

Это также вопрос о том, что люди уже могут достичь с помощью современных мощных систем.

Человек с минимальными техническими знаниями теперь может выполнять задачи, которые раньше требовали лет специализированного опыта.

Злоумышленник может использовать ИИ для написания вредоносного кода.

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

Один человек может автоматизировать работу, которая раньше требовала целой команды.

Для всего этого не обязательно, чтобы сама модель была вредоносной.

Плохие намерения исходят от людей.

И такое злоупотребление уже происходит, а не является какой-то далекой возможностью.

Автономные агенты ещё больше повышают ставки

Именно поэтому растущее использование ИИ-агентов требует гораздо более тщательного контроля со стороны тех, кто их создаёт.

Стандартный чат-бот отвечает только при получении запроса.

Агент, в отличие от этого, может проявлять инициативу и действовать самостоятельно.

Это различие может показаться незначительным.

Но это не так.

Представьте, что вы создаёте агента для кодирования в своём репозитории.

Вы предоставляете ему права на запись для создания файлов.

Вы позволяете ему выполнять команды.

Вы подключаете его к внешним API.

Вы настраиваете его так, чтобы он продолжал работать автономно до тех пор, пока не сочтёт задачу выполненной.

То, что вы создали, гораздо мощнее простого чат-бота.

Но при этом вы также создали гораздо более широкую поверхность для атак.

Что будет, если он неправильно интерпретирует задачу?

Что, если он уничтожит что-то критически важное?

Что, если скрытая инструкция, спрятанная в файле, тихо изменит его поведение?

Что, если он утечёт конфиденциальные данные какой-либо внешней службе?

Что, если он будет выполнять действия долгое время после того, как первоначальная цель уже была достигнута?

Ни один из этих примеров не является гипотетическим мысленным экспериментом из научно-фантастического сценария.

Это обычные проблемы инженерии программного обеспечения.

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

Почему согласованность — это не просто академический жаргон

Термин «согласованность» может казаться чем-то, предназначенным исключительно для исследователей в крупных лабораториях по ИИ и не связанным с повседневной разработкой.

Но существует гораздо более практичный способ рассмотрения этой проблемы.

Это просто означает заставить систему выполнять то, что вы действительно имели в виду, а не просто то, что вы сказали буквально.

Это звучит довольно просто.

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

Предположим, вы говорите ИИ-агенту: «Сделай этое приложение быстрее».

Быстрее в каком смысле?

Меньше занимаемой памяти?

Более короткие времена отклика API?

Меньше обращений к базе данных?

Быстрее загрузка страниц на фронтенде?

Более легкий алгоритм?

Агенту приходится каким-то образом угадывать, что именно вы имели в виду.

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

Затраты на неправильное понимание этой цели растут соответственно.

В этом и заключается настоящая сложность проблемы согласованности.

Речь никогда не шла о том, чтобы чат-бот звучал вежливо.

Речь идет о том, чтобы при увеличении возможностей систем они продолжали работать в рамках границ и намерений, установленных людьми.

Безопасность не должна добавляться в последний момент

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

Это верно даже для самых простых приложений.

При создании любого программного обеспечения безопасность — это не то, что рассматривается за несколько минут перед выпуском.

Тот же принцип должен применяться и к системам ИИ.

Если вы создаете что-то, работающее с помощью ИИ, вопросы разрешений требуют внимания с самого начала.

К каким ресурсам может обращаться модель?

Что она способна изменять?

Какая информация доступна ей?

Каков план действий в случае сбоя?

Есть ли у пользователей способ переопределить её решения?

Есть ли журнал аудита?

Можно ли её отключить?

Можно ли отследить совершённые ею действия?

Можно ли позже воспроизвести сбой для отладки?

Ни один из этих вопросов не кажется интересным.

Они не смогут сделать демо-версию более впечатляющей для просмотра.

Но именно ответы на вопросы отличают умный прототип ИИ от настоящей инженерной системы.

Чем больше вы фактически работаете с этими инструментами, тем яснее это становится.

Сама модель — лишь одна часть гораздо более сложной картины.

Важны основные данные.

Важен также бэкенд.

Важны API, к которым он обращается.

Важна база данных, стоящая за ним.

Не менее важна аутентификация.

Так же важен мониторинг.

Так же важна процедура развертывания.

И безопасность пронизывает всё это.

Разработчики играют более важную роль, чем им кажется

Разработчикам легко подумать, что безопасность ИИ — это зона ответственности кого-то другого.

Возможно, это задача крупных исследовательских лабораторий.

Возможно, должны вмешаться регуляторы.

Возможно, это чисто проблема исследований в области согласованности действий ИИ.

Эти усилия действительно важны. Но отдельные разработчики по-прежнему несут серьезную ответственность.

Каждый раз, когда модель ИИ подключается к приложению, принимаются решения о том, что ей разрешено делать.

Предоставление прав API — это тоже решение.

Подключение к базе данных — тоже решение.

Создание автоматизации — тоже решение.

Разрешение автономных действий — тоже решение.

Даже одинокий разработчик может непреднамеренно создать систему с гораздо более широкими возможностями, чем ей действительно нужно.

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

Отправка запроса модели быстро превращается в обычную навык.

Понимание того, как ведет себя вся система от начала до конца, имеет гораздо большую ценность.

Разработка ИИ по-прежнему имеет смысл

Ничто из этого не указывает на необходимость отказа от разработки ИИ.

Положительные аспекты настолько значительны, что невозможно от них отказаться.

Правильный ответ с точки зрения разработчика — стать гораздо лучше в создании продуктов ответственным образом.

Продолжайте разрабатывать.

Продолжайте экспериментировать.

Продолжайте исследовать.

Продолжайте выпускать системы, решающие реальные проблемы.

Но также уделяйте должное внимание их тщательной проверке.

Изучайте причины их сбоев.

Относитесь серьезно к вопросам безопасности.

Ограничивайте права доступа только тем, что действительно необходимо.

Продолжайте отслеживать системы после их запуска.

Честно говорите о том, что остается неопределенным.

А когда что-то идет не так, рассматривайте это как возможность для обучения, а не как проблему, которую нужно скрыть.

Темпы развития технологий не снижаются.

Инженерная дисциплина должна поспевать за ними.

Лучший вопрос, чем «Уничтожит ли ИИ нас»

Самый полезный вопрос — это не

«Может ли ИИ уничтожить человечество?»

Никто не может ответить на этот вопрос с полной уверенностью.

Некоторые исследователи считают риск серьезным.

Другие оценивают вероятность экзистенциальных последствий гораздо ниже.

В науке нет окончательного ответа о том, что произойдет и в какие сроки. Даже среди исследователей, которые серьезно относятся к этим рискам, мнения сильно различаются по поводу сроков и вероятностей.

Более плодотворный вопрос звучит так: что произойдет, если мы создадим системы, которые превзойдут наши возможности контроля над ними?

Такой подход гораздо сложнее игнорировать.

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

Уже эти проблемы самы по себе являются достаточной причиной рассматривать безопасность как приоритет, а не что-то второстепенное.

Это меняет мой взгляд на собственные проекты в области ИИ

Когда я работал над проектами в области ИИ студентом, основной заботой обычно было просто заставить модель работать.

Обучить её.

Протестировать её.

Повысить показатели точности.

Подключить её к фронтенду.

Выпустить продукт.

Вот весь список задач.

Такой подход больше не работает.

Теперь внимание сосредотачивается на всей системе в целом, а не только на модели в её центре.

Откуда на самом деле берутся данные для обучения?

Являются ли они надёжными?

Что произойдёт, когда реальные данные начнут отклоняться от тех, что видела модель во время обучения?

Насколько высокой должна быть степень уверенности в полученном результате?

Какова альтернатива, если запрос к API провалится?

Может ли кто-то умышленно подавать в систему некорректные или вредоносные данные?

Как система выражает сомнения или неопределенность пользователю?

Есть ли способ для человека вмешаться и отменить решение?

Можно ли объяснить, почему система пришла к конкретному ответу?

Эти вопросы создают трудности в любом проекте.

Но они также делают конечный результат гораздо более надежным.

Я считаю, что именно в этом направлении должна развиваться вся дисциплина создания программного обеспечения по мере роста возможностей ИИ-систем.

Будущее будет определяться не только в лабораториях ИИ

Легко предположить, что судьба ИИ полностью находится в руках нескольких крупных лабораторий: Anthropic, OpenAI, Google DeepMind и еще нескольких.

Это предположение ошибочно.

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

На него повлияют исследователи.

Повлияют также правительства.

Повлияют университеты.

Повлияют стартапы.

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

Поэтому менталитет, который приносят разработчики в свою работу, действительно имеет значение.

Если разработчик рассматривает языковую модель лишь как ещё один API для вызова, последствия создаваемого продукта могут остаться без внимания.

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

Мы вступаем в новую фазу искусственного интеллекта

На протяжении многих лет основным вопросом в этой области было просто следующее: насколько способными мы можем сделать эти модели?

Сейчас усиливает свою значимость второй вопрос: насколько автономии мы действительно должны им предоставить?

Это совершенно иной тип вопроса.

Модель может быть чрезвычайно способной и при этом совершенно безопасной в использовании, если человек постоянно контролирует её действия.

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

Именно поэтому недавние предупреждения сотрудников ведущих компаний в области искусственного интеллекта привлекли особое внимание.

Они не являются доказательством того, что неизбежно наступит какая-то катастрофа, связанная с искусственным интеллектом.

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

Уже это само по себе заслуживает внимания.

Нам не нужен паникерский настрой

Ничто из этого не требует от разработчиков реагировать с тревогой.

Тревога не приводит к лучшему коду.

Страх сам по себе не делает ИИ более безопасным.

На самом деле помогает более качественная инженерная практика во всех аспектах.

Более строгие тесты.

Более надёжная безопасность.

Более тщательная оценка.

Большая прозрачность.

Глубокие исследования.

Более разумная политика.

И более квалифицированные разработчики.

Цель не в том, чтобы сделать эти системы менее полезными.

Цель — обеспечить, чтобы наша способность понимать и контролировать их соответствовала их растущей мощи.

Это, возможно, одна из ключевых инженерных проблем современности.

Честно говоря, именно это делает эту область настолько привлекательной в настоящее время.

Речь идет не просто о еще одной категории программного обеспечения, создаваемого для использования.

Это программное обеспечение, которое все чаще помогает создавать новые программы, принимать решения, интерпретировать информацию и действовать непосредственно в реальном мире.

Это открывает огромные возможности.

Однако это также сопряжено с ответственностью, которую разработчики не могут просто передать кому-то другому.

Настоящий вопрос

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

Я также не могу с уверенностью утверждать, что сроки, указываемые некоторыми исследователями, соответствуют действительности.

И я не думаю, что кто-либо может точно сказать, что принесет следующее десятилетие.

Но одно кажется достаточно ясным.

По мере того как наши системы становятся всё мощнее, ответственное их проектирование становится ещё более важным, а не менее.

Если мы создаём ИИ-агентов, способных писать код, вызывать инструменты, взаимодействовать с системами и действовать с растущей автономией, нам необходимо серьёзно подумать о том, что произойдёт, если эти агенты совершат ошибки.

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

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

И если ИИ собирается играть значимую роль в обществе, мы должны понимать его ограничения, а не предполагать, что он всегда прав.

Настоящий вопрос не в том, следует ли прекратить разработку ИИ.

Вопрос в том, сможем ли мы достаточно улучшить навыки создания таких систем до того, как они станут настолько мощными, что наши ошибки окажутся практически невозможными для исправления.

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