Управление ИИ-агентами с использованием рамки CARE: ясность, автономия и другие факторы
Управление ИИ-агентами с использованием фреймворка CARE: принципы ясности, автономии, взаимоотношений и справедливости в применении к делегированию задач, контрактам агентов, выбору моделей и контексту.
Источники: You Already Know How to Manage Agents: The CARE Framework for AI Engineering
Обучение управлению иногда передает знания, которые применимы к программному обеспечению более непосредственно, чем ожидается. Фреймворк CARE, используемый в обучении лидерству и включающий четыре принципа — Ясность, Автономия, Отношения и Справедливость, — практически однозначно соответствует устоявшимся практикам управления ИИ-агентами. Соблюдение этих же принципов при работе с агентами — разумный способ добиться лучших результатов. Ниже каждый принцип рассматривается с точки зрения ИИ-агента, выполняющего роль члена команды, которому поручена задача.
Текущее положение дел
Год-два назад работа с помощником-программистом представляла собой серию простых команд: создать функцию, исправить ошибку, добавить тесты. Сегодня агенты могут просматривать репозиторий, выполнять команды в терминале, искать информацию в документации, одновременно редактировать несколько файлов, запускать тесты и передавать задачи подагентам. Однако их часто по-прежнему управляют как автодополнением. Проблема всё чаще не в запросах, а в делегировании обязанностей.
Вкратце, четыре вопроса CARE:
- Ясность: как выглядит успех?
- Автономия: насколько человек может самостоятельно принимать решения?
- Отношения: кто должен выполнять эту работу?
- Справедливость: что им нужно для достижения успеха?
Технические менеджеры и руководители уже знают, насколько каждый из этих факторов важен для получения хороших результатов без постоянного контроля за исполнителем.
Ясность: определяйте результаты, а не запросы
Предположим, что заинтересованная сторона хочет реализовать кэширование на конечной точке профиля пользователя, и эта работа будет поручена агенту на основе технологий GenAI. Типичный слабый запрос звучит так: «Реализуйте кэширование для конечной точки профиля пользователя». Для человека, знакомого с системой, это звучит ясно. На самом деле это не так. У агента возникает десятки нерешённых вопросов: какая именно конечная точка? Что будет кэшироваться? На какой срок? Что приводит к аннулированию записи? Какая инфраструктура кэширования уже существует? Что считается выполненной работой?
Ясность не означает более длинный запрос. Она означает, что желаемый результат и ограничения сформулированы однозначно. Более чёткая версия этой задачи:
Goal:
Reduce repeated database reads from GET /users/{id}.
Constraints:
- Use the existing Redis abstraction.
- Do not introduce a new dependency.
- Cache only successful responses.
- TTL: 10 minutes.
- Existing public API behavior must not change.
Before implementing:
- Inspect similar caching implementations in the repository.
- Identify how cache invalidation is handled elsewhere.
Validation:
- Existing tests must pass.
- Add tests for cache hit, cache miss, and invalidation.
Definition of done:
The implementation is complete when the endpoint behaves identically
from the client's perspective and repeated reads no longer hit MSSQL.
Инжиниринг промптов — это лишь один аспект ясности. Настоящий навык заключается в том, чтобы настолько хорошо описать задачу, чтобы кто-то другой мог её выполнить, что и делают менеджеры и руководители каждый день.
Автономия: ответственность, а не просто инструкции
Может показаться, что у агентов не существует микроменеджмента, но он всё же существует. Когда агент зависит от постоянных подсказок, обычной причиной является отсутствие ясности и чётких инструкций. Представьте себе такую ситуацию:
Find the problem.
Okay, fix it.
Now run the tests.
There's an error. Fix that.
Run them again.
Пользователь вручную управляет каждым шагом, что приводит к износу обеих сторон.
Агент может полностью понимать задачу, но при этом не обладать автономией. Автономия связана с ответственностью: что агент может решить, что он может изменить, насколько далеко он может действовать самостоятельно и когда ему необходимо обратиться за помощью. Контракт агента хорошо это отражает:
You own this task until it is implemented and validated.
You may:
- inspect any file in the repository
- modify files related to this feature
- run builds, tests and static analysis
- create focused subagents for research or validation
After implementation:
1. Run the relevant test suite.
2. Inspect your diff for unintended changes.
3. Validate the implementation against the acceptance criteria.
4. Fix issues you discover before returning.
Escalate only if:
- the requested behavior conflicts with existing architecture
- required credentials/access are unavailable
- the change would require modifying a public API
Четкость определяет конечную цель, а автономия — степень контроля агента над процессом выполнения задачи. Однако автономия не означает возможности делать всё, что захочется; здоровая автономия сопровождается наличием границ.
Отношения: знайте своих агентов
Под отношениями здесь имеется в виду калибровка, а не антропоморфизм. Речь идет о накопленных знаниях о сильных и слабых сторонах, способах сбоев и прошлом опыте использования моделей и агентов. Менеджер узнает, где каждый человек работает лучше всего, и аналогичное понимание должно формироваться и в отношении системы искусственного интеллекта:
| Work | Agent/model characteristic |
| ------------------------------------- | ----------------------------------- |
| Repository-wide architecture research | Strong reasoning + large context |
| Small mechanical refactor | Fast, inexpensive model |
| UI implementation from screenshots | Strong vision model |
| Test generation | Fast coding specialist |
| Final architecture critique | Independent high-reasoning reviewer |
Схема с одной моделью, одним огромным контекстом и обработкой любых задач, которые к ней подаются, далека от идеала. Работа должна выполняться агентами, оборудованными для этого. Многокомпонентные архитектуры не предполагают наличие большего количества агентов; они направлены на передачу четко определенных задач тому агенту, который наиболее подходит для их выполнения:
Main Agent
│
├── Research Agent
│ └── Investigate existing caching patterns
│
├── Implementation Agent
│ └── Make the code change
│
└── Reviewer Agent
└── Validate implementation independently
Отношения улучшаются по мере того, как система накапливает знания о архитектурных решениях, правилах кодирования, часто встречающихся способах сбоев, ранее принятых решениях, а также о том, какие модели эффективны для выполнения определенных задач. Короче говоря, это сочетание понимания моделей и накопленного контекста.
Справедливость: предоставление необходимого агенту
Часто слышно жалобы вроде «ИИ снова выдумал» или «Он сгенерировал бесполезный результат». Но стоит посмотреть, что на самом деле было предоставлено агенту. Не было ни документации к API, ни требований к тикетам, ни логов, ни примеров кода, ни записей об архитектуре, ни способа подключения к работающему приложению. Был ли это сбой модели или кого-то попросили решить проблему без необходимой информации?
Предположим, агент мог бы найти или получить всё это:
.agent/
│
├── context/
│ ├── architecture.md
│ ├── domain.md
│ └── conventions.md
│
├── skills/
│ ├── debug-production.md
│ ├── review-mr.md
│ └── implement-feature.md
│
├── references/
│ ├── api-spec/
│ ├── examples/
│ └── decisions/
│
└── tools/
├── git
├── jira
├── logs
├── browser
└── tests
Точный формат менее важен, чем принцип. Агентам необходимы правильные инструкции и инструменты. Агенту для отладки производственных систем могут понадобиться код, логи, трейсы, недавние развертывания и история изменений в Git. Агенту интерфейса может потребоваться код, скриншот, система дизайна, браузер и документация компонентов. Рецензенту могут понадобиться различия между версиями кода, полный файл, тесты, заявка на рассмотрение, похожий код и руководства по хранилищу. Интеллектуальные возможности одинаковы, но требования к обеспечению равенства различаются. Прежде чем считать, что модель неспособна к выполнению задачи, уточните, была ли она обеспечена необходимыми ресурсами для этого.
CARE как инструмент отладки
Путь развития проходит от стимулирования к делегированию задач к их координации, и роль лидера меняется вместе с ним. Талантливые люди уже показывают плохие результаты при нечетких целях, чрезмерном контроле, несоответствующих заданиях или отсутствии ресурсов. Применение этих знаний к агентам означает, что те же принципы управления теперь работают для всех, кто создает решения в команде, независимо от того, являются ли они людьми или нет.
Все четыре аспекта в одном определении агента
Реализации различаются по структуре, но типичное определение рабочего агента обычно включает понятия CARE примерно в следующем виде:
---
name: implementation-agent
description: Implements scoped repository changes end-to-end. Use proactively for feature, bug-fix, and refactor tasks that require code changes and validation.
tools: Read, Grep, Glob, Edit, Write, Bash
model: inherit
---
You are an implementation agent responsible for completing scoped coding tasks end-to-end.
When given a task:
1. **Investigate**
- Read the relevant code before changing it.
- Search for similar implementations and existing project conventions.
- Do not guess when repository evidence is available.
2. **Plan**
- Form a short plan covering the files to change, the implementation approach, and validation.
3. **Implement**
- Make the smallest change that fully satisfies the task.
- Reuse existing patterns and dependencies.
- Do not modify unrelated code.
4. **Validate**
- Run the relevant tests, build/type-check, and lint/static analysis when available.
- If your change causes a failure, fix it and validate again.
5. **Review**
- Inspect the final diff.
- Remove accidental or unrelated changes.
- Confirm the requested behavior and acceptance criteria are satisfied.
Continue autonomously until the task is complete.
Escalate only when required access is unavailable, requirements materially conflict, or the task would require a destructive action or a public API/architecture change outside the requested scope.
The task is done only when the implementation is complete, relevant validation passes, and the final diff has been reviewed.
Делегирование — это навык будущего
Агенты не являются людьми, но системы, построенные вокруг них, сталкиваются с удивительно знакомыми проблемами управления. Если задать агенту нечеткую цель, контролировать каждый его шаг, использовать неподходящую модель или не предоставить необходимый контекст и инструменты, его производительность снижается. По мере повышения способностей агентов преимущество будет заключаться не только в более совершенных моделях или более точных указаниях. Команды, которые научатся эффективно делегировать задачи, смогут получить максимум пользы от ИИ.