Команды агентов Claude Code: будущее разработки с ИИ‑помощью

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

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

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

Впервые слышите о Claude Code? Освойте основы за один день на нашем курсе Claude Code 101.

Что такое команды агентов Claude Code?

Команды агентов Claude Code — это слой координации, позволяющий нескольким сессиям Claude Code работать над одним проектом одновременно. Одна сессия берёт роль тимлида и создаёт другие сессии — «товарищей по команде», — чтобы выполнять конкретные части работы.

Каждый такой «товарищ» — это полноценный независимый экземпляр Claude Code со своим собственным окном контекста. Они делят общий список задач, берут в работу задачи по мере появления и общаются напрямую, когда требуется координация.

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

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

Зачем нужны команды агентов

Одна сессия Claude Code хорошо справляется с задачами — пока проект не становится слишком большим.

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

Есть три типичные ситуации, где это особенно заметно:

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

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

Если одна сессия упирается в пределы при рефакторинге, отдайте изменения в бэкенде одному «товарищу», фронтенд — другому, а обновления тестов — третьему. Каждый использует только то, что нужно для своей части работы.

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

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

Как работают команды агентов Claude Code

Сессия команды проходит пять этапов, оркестровка выполняется внутри самого Claude Code.

• Определение цели: Опишите, что вы хотите получить, простым языком — как если бы вы ставили задачу младшему инженеру. Лид читает её и решает, как разбить на части.
• Делегирование работы: Лид создаёт общий список задач и запускает «товарищей», каждому даёт имя, роль и стартовый промпт. Вы можете задать структуру команды сами или поручить это лиду.
• Параллельное исполнение: Каждый «товарищ» берёт задачи, помечает их «в работе», завершает и отмечает «готово». Зависимости учитываются автоматически; блокировка файлов предотвращает конфликты. «Товарищи» могут переписываться напрямую — не нужно идти через лида.
• Объединение результатов: Лид собирает готовую работу, разрешает конфликты и формирует единый результат: PR, отчёт, отрефакторенный модуль — всё, что требуется целью.
• Проверка результата: Вы проверяете итог, как любой pull request: смотрите diff, запускаете код, проверяете тесты.

Специализированные роли в командах агентов

Роли задают форму команде агентов. Без них вы получите обезличенные сессии с пересекающейся работой. В Claude Code нет фиксированного списка ролей — вы определяете их в брифе или указываете лиду на определение субагента, сохранённое в .claude/agents/.

Агент‑планировщик

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

На практике эту роль часто берёт на себя сам лид. Можно также запустить выделенного «товарища»-планировщика, если объём работ это оправдывает.

Агент‑разработчик

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

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

Агент тестирования

Агент тестирования пишет и запускает тесты. Он может работать по согласованному контракту API, пока «товарищ»-разработчик ещё строит эндпоинт — так что к моменту готовности кода тесты уже будут на месте.

Можно держать «товарища» по тестированию на всём протяжении сессии, повторно прогоняя набор при каждом завершении задачи «товарищем»-разработчиком.

Агент‑ревьюер

Агент‑ревьюер читает диффы и помечает баги, проблемы со стилем, пропущенные краевые случаи и уязвимости. Особенно эффективно разделить ревью между двумя «товарищами» с разными фокусами — по безопасности и по производительности — а лид объединит их выводы.

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

Агент документации

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

Почему специализация улучшает результаты

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

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

Параллелизм — главный смысл команды агентов.

После того как лид разбил работу на задачи и запустил «товарищей», все они работают одновременно. Каждый «товарищ» — отдельная сессия Claude Code, поэтому работа не выстраивается в очередь за одним окном контекста. Общее время выполнения многокомпонентной фичи сокращается с суммы всех частей до времени самой медленной.

Вот три особенно удачные комбинации для параллельной работы.

• Фронтенд и бэкенд параллельно: Когда вы делаете новую фичу, затрагивающую оба слоя, бэкенд‑«товарищ» может строить эндпоинт API, пока фронтенд‑«товарищ» создаёт компонент, который его потребляет. Они координируются через личные сообщения. Как только бэкенд‑«товарищ» определяет формат ответа, он отправляет его фронтенду — и оба продолжают работу, не дожидаясь полного завершения друг друга.
• Реализация и тестирование параллельно: «Товарищ»-разработчик пишет реализацию, а «товарищ» по тестированию — тесты по согласованному контракту. К моменту, когда разработчик помечает задачу как завершённую, тесты уже готовы к запуску. Это значительно быстрее, чем сначала писать код, а потом в конце добавлять тесты.
• Документация и код‑ревью параллельно: Как только «товарищ»-разработчик завершает часть работы, «товарищ» по документации начинает писать докстринги и обновлять README, а «товарищ»-ревьюер читает дифф в поисках багов и проблем со стилем. Они не блокируют друг друга и отдают свои результаты лидам для объединения.

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

Команды агентов Claude Code для больших кодовых баз

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

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

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

Это особенно важно в трёх случаях:

• Сквозные изменения: Рефакторинг, затрагивающий десятки файлов в нескольких модулях, трудно тянуть одной сессии, не теряя нить. Разбейте его по модулям и отдайте каждый модуль отдельному «товарищу», чтобы сохранить управляемый объём.
• Аудиты всего репозитория: Проверка безопасности или аудит производительности на большой кодовой базе выигрывают от параллельной работы нескольких «товарищей», каждый смотрит свою часть репо. Лид затем объединяет их выводы в единый отчёт.
• Долгоиграющие проекты: Многонедельный проект накапливает контекст, который одна сессия не удержит. Команды агентов позволяют разбить работу на контрольные точки, за каждую отвечает «товарищ», которому не нужно помнить всё, что было раньше.

Есть и цена вопроса.

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

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

Команды агентов и Claude Tag

Команды агентов — не единственный способ, которым Anthropic переосмысливает роль ИИ в командных процессах.

Claude Tag — отдельная функция, которая приводит Claude в Slack как общего участника организации. Вы отмечаете @Claude в канале, и Claude берёт на себя работу, используя инструменты вашей организации и контекст канала. Он помнит обсуждения, сам инициирует продолжения и действует от имени вашей организации.

Эти две функции решают разные задачи координации. Команды агентов координируют несколько сессий Claude Code на машине одного разработчика для одной сфокусированной задачи. Claude Tag координирует одну «личность» Claude среди команды людей в Slack на протяжении дней и недель. Но вектор один: ИИ переходит от инструмента для одиночного использования к участнику, работающему внутри существующего командного процесса.

Это меняет требования к самому ИИ.

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

Лучшие практики по созданию команд агентов

Хорошая команда агентов — это в основном про подготовку. Сама команда работает быстро, а время вы потеряете на плохо очерченных задачах и размытых ролях.

Вот несколько рекомендаций:

• Чётко определяйте роли: У каждого «товарища» должен быть один фокус и свой набор файлов. Когда создаёте «товарища», скажите ему, за что он отвечает, за что — нет, и с какими файлами или модулями он может работать. Размытые роли приводят к пересечению работ, а пересечения — к конфликтам при слиянии.

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

• Делитесь стандартами через CLAUDE.md: Каждый «товарищ» при запуске читает файл CLAUDE.md в рабочем каталоге, поэтому поместите туда общие соглашения: стиль кода, структуру файлов, подход к тестированию и формат сообщений коммитов.

• Встраивайте контрольные точки ревью: Отслеживайте прогресс «товарищей», перенаправляйте тех, кто сбился, и проверяйте результат лида перед принятием. Для рискованных задач требуйте утверждения плана до любых изменений. Это заставляет «товарища» сначала показать план и дождаться одобрения лида.

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

• Избегайте конфликтов файлов: Делите работу по границам файлов или модулей, чтобы зоны ответственности не пересекались. Двое, редактирующие один файл, перезапишут изменения друг друга. Если задача действительно требует участия нескольких «товарищей» в одном файле, выполняйте её последовательно, а не параллельно.

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

• Подбирайте модель под роль: Запускайте лида на более сильной модели, например Opus, поскольку координация выигрывает от глубины рассуждений, а «товарищей» — на Sonnet для исполнения.

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

Команда агентов Claude Code на практике

Вот весь процесс от начала до конца.

Я разберу небольшой пример: «hello world» REST API на FastAPI, который читает сообщение из базы SQLite, плюс маленькую HTML‑страницу, вызывающую API и показывающую результат. В приложении есть бэкенд‑маршрут, слой базы данных, статический фронтенд и документация в readme — отличный кандидат для команды из четырёх человек.

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

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

Файл настроек находится по пути ~/.claude/settings.json. Откройте его и добавьте:

{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}

Если не хотите редактировать файл настроек, установите переменную в вашей оболочке перед запуском Claude Code:

export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1

Оба способа работают. После установки переменной Claude Code распознаёт промпты, связанные с командами, и включает слой координации по запросу.

Запустите Claude Code и брифуйте команду

Создайте пустой каталог для проекта и запустите внутри него Claude Code:

mkdir hello-api && cd hello-api
claude

Теперь брифуйте команду. Промпт — это естественный язык, но чем точнее вы опишете роли и границы, тем лучше сработает команда. Вот промпт для hello world API:

Create an agent team to build a small "hello world" REST API.

The project is a FastAPI service that returns a greeting from a SQLite
database, plus a tiny HTML page that calls the API and shows the result.
- One teammate on the database: create app/db.py with a sqlite3 connection
  to a greetings.db file. Define a get_greeting() function that returns
  the message column from the first row. On import, create the table if
  it doesn't exist and seed it with "Hello, World!" if empty.
- One teammate on the backend: build a FastAPI app in app/main.py with
  a GET /greeting endpoint that calls get_greeting() from app/db.py.
  Add permissive CORS and mount the static/ directory at the root so
  the HTML page is served from the same origin.
- One teammate on the frontend: build static/index.html as a single page
  that fetches /greeting on load, shows a spinner while loading, displays
  the greeting in a centered card on success, and shows an error message
  on failure. Inline the CSS and JavaScript.
- One teammate on docs: write README.md with installation, run, and
  open-in-browser steps, plus an API reference table. Also create
  requirements.txt with fastapi and uvicorn[standard].
Use Sonnet for each teammate. Require plan approval before any teammate
makes changes.

В этом промпте стоит отметить три момента. Границы файлов (app/db.py, app/main.py, static/index.html, README.md, requirements.txt) предотвращают пересечения. Выбор модели (Sonnet) держит расходы на токены под контролем. А plan approval заставляет каждого «товарища» показать план до написания кода — это даёт вам контрольную точку, чтобы перенаправить тех, кто неправильно понял бриф.

Наблюдайте за работой команды

После отправки промпта лид разбивает работу на задачи и запускает «товарищей». Внизу терминала появится панель агентов со строкой на каждого «товарища».

Созданные агенты

Каждая строка показывает имя «товарища» и текущую активность. Лид наполняет общий список задач и назначает или освобождает их исходя из зависимостей. Бэкенд‑«товарищ» ждёт слой базы данных, потому что импортирует get_greeting() из него. «Товарищ» по документации ждёт, пока остальное продвинется достаточно, чтобы описывать точно.

Вы также можете посмотреть список задач. Нажмите Ctrl+T для переключения. В списке видны все задачи, их статус (в ожидании, в работе, завершена) и ответственный «товарищ».

Переход между «товарищами»

Каждый «товарищ» — полноценная сессия Claude Code, и вы можете общаться с любым из них.

В панели агентов используйте стрелки вверх/вниз, чтобы выбрать «товарища», затем нажмите Enter для открытия его транскрипта. Теперь вы в сессии этого «товарища», и всё, что вы печатаете, идёт ему, а не лиду. Так вы даёте конкретному «товарищу» дополнительный контекст или меняете его подход, не вовлекая остальных.

Нажмите Esc, чтобы вернуться к лиду.

Перенаправление «товарища», который сбился

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

Если у вас включено утверждение плана, «товарищ» приостанавливается после планирования и показывает своё предложение до записи файлов. Вот как это выглядит для агента базы данных:

Утверждение агента базы данных

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

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

Завершение и ревью

Когда все «товарищи» завершают свои задачи, лид отчитывается кратким резюме и командами для запуска проекта.

Финальные инструкции лида

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

Сгенерированный файл app/main.py

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

Таблица greetings

Затем установите зависимости, запустите uvicorn app.main:app --reload и откройте http://localhost:8000 в браузере, чтобы убедиться, что весь стек работает от конца до конца.

Итоговое приложение

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

Вот и всё!

Заключение

Команды агентов Claude Code — это про две вещи: специализацию и координацию. У каждого «товарища» есть своя часть работы и своё окно контекста. Лид держит их согласованными, список задач — синхронизированными, а прямые сообщения избавляют их от ожидания, пока вы перешлёте информацию между сессиями.

В более широком смысле разработка с ИИ смещается от одиночной к координированной. Команды агентов — как это проявляется в Claude Code сегодня, и тот же паттерн виден в Claude Tag для Slack. Те, кто освоит это сейчас, будут меньше упираться в лимиты контекста и больше выпускать реальные фичи.

Хотите получить сертификацию по генеративному ИИ? Вот лучшие сертификации по генеративному ИИ в 2026 году, включая топ‑курсы, советы по подготовке и ответы на частые вопросы.