Агенты-оснастки: Конец программирования?

Каждый, кто обращает на это внимание, может это почувствовать: фейерверк технологий начинает замедляться. GPT-4, Claude 3 Opus и Gemini 1.5 несомненно сильны, но они не представляют собой такой же ошеломляющий скачок, как GPT-3 по сравнению с GPT-2. Бенчмарки продолжают расти — MMLU, HumanEval, GSM8K — но реальный «вау»-эффект от сырой мощности LLM больше не удваивается каждые шесть месяцев.

Это замедление не воображаемо; это экономика. Обучение передовой модели сейчас обходится в сотни миллионов долларов на вычисления, кураторство данных и инженерные работы. Каждая дополнительная процентная доля в таких рейтингах, как MMLU или Codeforces, требует экспоненциально больше графических процессоров, больше токенов и больше человеческой обратной связи.

Снижающаяся отдача ощущается повсюду. Более крупные контекстные окна — 200K, 1M токенов — существуют, но эффективное рассуждение над этим контекстом по-прежнему дает сбои в хрупких ситуациях. Модели программного кода отлично справляются с рутинным кодом и распространенными паттернами, но порой выдают несуществующие API или неправильно интерпретируют крайние случаи, которые любой средний инженер заметил бы в ходе ревью кода.

Итак, границы изменились. Кол Медин точно подметил это в своем видео: "сырой потенциал LLM больше не взрывается", но слой вокруг них — да. Оркестрация инструментов, системы памяти и координация многих агентов обеспечивают более значительные изменения, чем еще 0,3 в бенчмарке.

Думайте об этом как о переходе от более быстрых процессоров к более качественным операционным системам. Агентские системы, контекстные маршрутизаторы и модели мира располагаются поверх GPT-4 или Claude 3 и извлекают большую надежность из примерно одного и того же базового интеллекта. Аппаратное обеспечение мозга достигает плато; программный стек вокруг него начинает играть более важную роль.

Это переосмысляет этот момент не как потолок, а как переломный момент. Вместо того чтобы молиться о том, чтобы GPT-5 стал в 10 раз умнее, команды разрабатывают агентские «управляющие», которые управляют инструментами, повторными попытками и длительными рабочими процессами, чтобы модели сегодняшнего дня вели себя как надежные коллеги. Центр инноваций смещается с весов модели на проектирование системы.

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

Сырые модели начинают выглядеть как голый кремний: впечатляющие на бумаге, хрупкие на практике. Центральное утверждение Кола Медина прямое: настоящая работа переместилась на «уровень над LLM» — логику оркестрации, которая превращает умный механизм автозаполнения в нечто, чему можно доверять при выполнении реальной работы.

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

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

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

Современные гарнитуры объединяют несколько возможностей, которые раньше существовали в разрозненных скриптах и произвольных запросах: - Хранилища долговременной и кратковременной памяти - Маршрутизация инструментов и повторные попытки с учетом ошибок - Координация подагентов и планирование - Ограничения, валидация и наблюдаемость

Проекты, такие как внутренний хастинг Anthropic, DeepAgent от LangChain и Linear Agent Harness от Коула Медина, демонстрируют формирующийся паттерн. Вместо одной завершенной беседы вы получаете графы агентов, инструментов и состояний, которые могут работать в течение часов без вмешательства человека.

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

Ожидание "GPT-6, но в 10 раз лучше" упускает суть. Следующий 10-кратный скачок произойдет благодаря улучшенной разработке систем: более умным циклам планирования, более полным моделям мира, более тесной связи обратной связи из логов с подсказками и политиками.

Команды разработчиков, которые рассматривают модель как товар, а инструмент — как продукт, приобретут ценность. Все остальные просто будут вызывать API и надеяться на лучшее.

Агент, использующий звук, может показаться несуразным, но компании Anthropic и LangChain определяют нечто очень конкретное: структурированный контрольный уровень, который многократно вызывает LLM, отслеживает состояние и управляет инструментами до тех пор, пока задача не будет выполнена. Спецификация хранилища от Anthropic описывает контроллер, который управляет циклом, обработкой ошибок, памятью и маршрутизацией инструментов, в то время как модель просто предсказывает следующий токен. Документация LangChain по DeepAgent идет дальше, рассматривая хранилище как программируемую политику, которая определяет, что делает агент на каждом этапе.

Более чем просто прославленный цикл, современный инструмент представляет собой машину состояний. Каждое действие переходит между состояниями, такими как «планирование», «ожидание вызова инструмента», «ожидание человека» или «завершено», с четкими правилами о том, что допустимо в каждом состоянии. Эта структура делает поведение воспроизводимым и отлаживаемым, а не основанным на ощущениях и надеждах.

Основные обязанности сгруппированы по четырем категориям, которые присутствуют в Anthropic, LangChain и Linear Agent Harness Коула Медина. Система должна управлять постоянной памятью, контролировать инструменты, координировать множество исполнителей и supervising долгосрочные процессы. Если убрать любую из этих составляющих, агенты быстро регрессируют до однократных чат-ботов.

Управление памятью теперь выглядит как задача миниатюрной базы данных. Хранилища поддерживают краткосрочные рабочие области, векторные хранилища для семантической памяти и долгосрочные журналы, принимая решения о том, что подытожить, что удалить и что восстановить в контекстные окна, ограниченные 200k–1M токенов. Они также контролируют доступ к чувствительным данным, регулируя, какие подсистемы могут видеть какую информацию, что является обязательным требованием для любого корпоративного развертывания.

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

Этот уровень политики предотвращает катастрофы, связанные с инъекцией запросов, такие как «скачать базу данных продукта», и не позволяет ненадежным API сбивать с толку рабочие процессы после одной ошибки 500.

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

На высоте 10,000 футов LLM выглядит как ядро, в то время как обвязка ведет себя как оболочка ОС плюс среда выполнения. Она обеспечивает планирование, ввод/вывод, разрешения и логирование вокруг очень умного, но очень амнезийного ядра. Собственный документ Anthropic, Эффективные обвязки для долгосрочных агентов - Anthropic, фактически читается как документ по дизайну для этой оболочки.

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

Системы, работающие только по запросам, ведут себя как стажёры с амнезией. Попросите LLM переписать монолит на 200 000 строк одним запросом, и вы получите частичные правки, вымышленные файлы и сломанные импорты. Даже с использованием извлечения, наивный RAG просто помещает «релевантные» фрагменты в контекст; он не отслеживает состояние, не проверяет результаты и не помнит, что уже было выполнено.

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

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

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

Динамическое планирование становится функцией первоклассного уровня. Вместо жестко заданной последовательности, система обновляет список задач на основе обратной связи от инструмента: - Сгенерировать план - Запустить инструмент - Сравнить ожидаемое с фактическим - Вставить, удалить или изменить порядок шагов

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

Агент производственного уровня больше напоминает миниатюрные операционные системы, чем хитроумные подсказки. Гарнитуры DeepAgent от LangChain, внутренние фреймворки Anthropic и линейная гарнитура Коула Медина сходятся в одной архитектуре: плотный цикл, охватывающий четыре ключевых компонента, которые направляют большую языковую модель к цели, а не позволяют ей блуждать по настроению.

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

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

Параллельно с состоянием Контроллер Инструментов управляет каждым побочным эффектом. Инструменты никогда не позволяют модели вызывать необработанные API или напрямую взаимодействовать с файловой системой; они предоставляют курируемый набор инструментов с строгими контрактами на ввод и вывод. В LangChain инструменты объявляют JSON-схемы и средства безопасности, чтобы контроллер мог проверять аргументы, ограничивать запросы и блокировать явно опасные действия.

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

Память хранится в своем собственном модуле, соединяющем контекстные ограничения LLM в 200K–1M токенов с реальными рабочими нагрузками, которые могут длиться дни. Краткосрочная память обычно выглядит как черновик: текущая сводка последних N шагов, сжатая самой моделью для соблюдения бюджета. Долгосрочная память находится в векторных базах данных, таких как Pinecone, Weaviate или pgvector, индексированная эмбеддингами из моделей, таких как text-embedding-3-large.

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

Держит все это вместе, Диспетчер/Координатор управляет центральным циcludом. Он подает LLM текущее состояние и память, анализирует «намерение» модели (вызвать инструмент, создать подс задачу или завершить вывод) и направляет управление к нужному компоненту. Каждая итерация обновляет состояние, дополняет память и усиливает ограничения, превращая стохастическую модель в предсказуемую систему.

Кодирование на основе настроений звучит как шутка, пока вы не осознаете, что это описывает то, чего на самом деле хочет каждый разработчик: обозначить результат, пропустить рутину и запустить проект. В этом контексте кодирование на основе настроений означает описание намерения на уровне «создать Slack-бота, который сортирует инциденты» и позволить системе самостоятельно находить API, разрабатывать модели данных и писать тесты без вашего постоянного контроля над каждой функцией.

В течение многих лет это оставалось фантазией, потому что сырые языковые модели ведут себя как одаренные, но ненадежные стажеры. Они создают фальшивые API, игнорируют крайние случаи и теряются в многошаговых планах после десятка шагов. Даже с GPT-4 или Claude 3.5, запрос на создание нетривиальной системы — скажем, полного CRUD SaaS с авторизацией, выставлением счетов и аналитикой — все еще приводит к коду, который компилируется, но тихо ломается под реальным трафиком и реальными данными.

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

Современные системы, такие как внутренний фреймворк Anthropic или DeepAgent от LangChain, не доверяют единому вызову LLM. Они внедряют циклы планирования → действия → проверки, фиксируя каждый шаг и направляя сбои на повторное рассмотрение через отладчики или к человеческой проверке. LangChain подробно документирует это в своих возможностях агентских системой - Документация LangChain, где агенты получают структурированные цели, выбирают инструменты и поддерживают многоэтапное состояние.

Таким образом, vibe coding становится «в какой-то мере» жизнеспособным, именно так, как утверждает Коль Медин. Вы настраиваетесь на границе системы — «перевести наш монолит на сервисно-ориентированную архитектуру к III кварталу, поддерживать задержку ниже 150 мс, повторно использовать существующую аутентификацию» — и управляемый процесс разбивает это на сотни конкретных действий. LLM больше не свободно ассоциирует; он функционирует внутри регулируемого, тестируемого рабочего процесса.

Ключевым моментом является то, что вы не просто взаимодействуете с обнаженным LLM-чатом. Вы издаете высокоуровневые директивы надежной системе, которую вы разработали: схемы инструментов, меры безопасности, механизмы наблюдения, стратегии отката. Творчество поднимается на новый уровень — от написания циклов for к проектированию системы, которая делает кодирование более интуитивным и на что можно действительно опираться в плане дорожной карты.

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

Коул Медин лаконично подчеркивает ключевой момент: “мы создаем систему, создаем каркас, но в ближайшем будущем не будем писать большую часть кода”. Эта фраза кажется преувеличением, пока вы не увидите, как агент типа DeepSeek, Claude или GPT настраивает REST-вызовы, миграции и тесты по абзацу намерений. Человек по-прежнему задает направление; агент занимается вспомогательной работой.

Разработчики New-day определяют цели агентов с точностью, сопоставимой со спецификациями продуктов. Вместо "создать страницу оплаты", они формулируют задачи как "поддерживать счета Stripe в актуальном состоянии с нашим внутренним регистром, проводить согласование ошибок каждый час и эскалировать аномалии свыше 5,000 долларов." Эта структура преобразует это в инструменты, подпроцессы и ограничения.

Инструменты становятся первоклассным ремеслом. Архитекторы выбирают или создают функции для: - Взаимодействия с API и внутренними сервисами - Запросов к векторным хранилищам и SQL-складов - Запуска изменений CI/CD и инфраструктуры

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

Logic Harness заменяет ручной код оркестрации. Разработчики проектируют циклы планирования, политики повторной попытки в случае ошибки, стратегии использования памяти и этапы одобрения. "Файл рабочего процесса" может указывать, как агент разбивает задачи, когда он может создавать подагентов и что подлежит регистрации для аудита. Он выглядит меньше как Java и больше как Terraform для когнитивных задач.

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

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

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

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

Открытый источник Linear-Copilot-Harness от Коула Медина показывает, как это выглядит внутри реального рабочего процесса SaaS. Он интегрирует LLM с API Linear для создания, сортировки и обновления заявок, учитывая контекст из истории проблем, командные соглашения и основные этапы проекта. Вместо хрупкого запроса "напиши заявку" это устройство управляет инструментами, памятью и ограничениями, позволяя агенту вести себя как младший менеджер проекта, встроенный в Linear.

Ремень Medin основан на таких паттернах, как: - Маршрутизация инструментов в зависимости от типа задачи - Постоянная память, связанная с линейными проблемами и пользователями - Многоступенчатые планы, которые могут быть перепланированы в случае сбоя инструментов

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

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

Маркетинговые команды уже экспериментируют с самоуправляющимися агентами для кампаний. Система управления может организовывать создание текстов, креативные A/B тесты, перераспределение бюджета и анализ данных в Google Ads, Meta и на email платформах. Платформы корпоративного уровня, такие как OutSystems Agent Workbench, спешат продуктировать это, упаковывая шаблоны системы управления в «рецепты агентов», которые интегрируются напрямую в существующие стеки.

Павел Панчеха предлагает самую ясную ментальную модель для всего этого: Языковые модели (LLMs) — это ядра, а системы управления агентами — это оболочки. Думайте о Linux плюс bash, а не о «магическом агенте». Ядро раскрывает сырую мощь; оболочка решает, как люди и программы на самом деле используют её.

Ядро ОС планирует процессы, управляет памятью и предоставляет системные вызовы. Оболочка, такая как bash или zsh, преобразует это в `ls`, пайпы, скрипты и автоматизацию. Подставьте Claude или GPT в качестве ядра, и ваше управление становится оболочкой: оно интерпретирует намерения пользователя, последовательно вызывает инструменты и поддерживает выполнение долгосрочных задач.

Прочитайте Агентские оболочки - Павел Панчеха, и аналогия становится ясной. “Ядро” LLM может: - Генерировать и трансформировать текст - Вызывать инструменты через структурированные функциональные вызовы - Поддерживать краткосрочное состояние разговора

Оболочка "пояса" охватывает следующее: - Контроль процессов для задач, которые выполняются минуты, часы или дни - Оркестрация инструментов через API, базы данных и кодовые базы - Устойчивость, журналирование и восстановление при сбоях

С этой точки зрения, DeepAgent от LangChain, примеры harness от Anthropic и harness линейного агента Коула Мединa выглядят не как экзотический ИИ, а скорее как знакомая инженерия ОС. Они реализуют циклы планирования, повторные попытки, механизмы отступления и конечные автоматы — просто нацеленные на вызовы LLM, а не на системные вызовы. Магия смещается с "инженерии подсказок" на проектирование надежного рабочего окружения.

Эта модель также объясняет, почему приросты производительности сырых LLM кажутся инкрементальными, в то время как приросты от использования технологий ощущаются как мультипликативные. Лучшее ядро важно, но лучшая оболочка меняет то, как каждый пользователь и каждый процесс взаимодействует с этим ядром. Bash сделал больше для удобства использования Unix, чем любое единичное обновление ЦП.

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

Ворота для агентов переходят от исследовательских блогов к резюме. К 2026 году умение «хорошо работать с ИИ» будет означать, что вы можете разрабатывать, отлаживать и внедрять ворота, которые обеспечивают работу LLM в течение нескольких часов, а не просто писать умные подсказки. Относитесь к созданию ворот как к изучению React в 2015 году или Kubernetes в 2018: сначала это будет необязательно, а затем станет обязательным для серьезной работы.

Начните с одной конкретной системы: помощника по кодированию, который может управлять репозиторием в течение 30–60 минут. Настройте вызовы инструментов для git, ввода-вывода файлов и тестов, затем добавьте охранные механизмы: отслеживание состояния, политики повторных попыток и явные критерии успеха. Измеряйте успех с помощью четких показателей: процент исправления ошибок, время до Pull Request и как часто людям требуется спасать агента.

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

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

GitHub уже полон шаблонов. Изучите открытые хранилища, такие как harness агента Cole Medin и примеры от Anthropic, а затем: - Создайте форк и замените инструменты на свои - Добавьте телеметрию и отслеживание затрат - Укрепите его для реальной нагрузки в вашей работе или побочном проекте

Будущее высокоэффективной работы с ИИ будет принадлежать тем, кто сможет обернуть сырые модели в надежные системы. Если Кол Медин прав и мы делегируем 99% программирования агентам, преимущества окажутся у тех, кто разрабатывает системы, внутри которых работают эти агенты. Вы можете стать человеком, который создает оболочки вокруг ядер завтрашнего дня.

Что такое инструмент для использования AI-агентов?

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

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

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

Заменят ли агентские платформы разработчиков программного обеспечения?

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

Связаны ли "вайб-кодирование" и агентские системы?

Да. "Кодирование настроения" — описание желаемого результата на естественном языке — становится более жизнеспособным с использованием harness, так как они обеспечивают надежность для преобразования высокоуровневых "настроений" в функциональное выполнение многоступенчатого кода.