Агенты, которые пишут агентов: Self-Improving Agents и Генерация Субагентов

Введение: Этап 2 Самообучения

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

Ключевые Проекты и Исследования

1. Darwin / Gödel Machine (Sakana AI, 2024)

Sakana AI представила Darwin — систему для самоэволюционирующихся агентов. Ключевые идеи:

Рекурсивная структура: Агент не просто выполняет задачу, а анализирует свою производительность и создает специализированные субагенты для слабых мест.
Gödel Machine философия: Система может модифицировать собственный код во время выполнения, если доказывает, что это улучшит результаты.
Практическое применение: Агент замечает, что плохо решает определенный класс задач → генерирует специализированного "соседа" → делегирует такие задачи ему.

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

2. Voyager: LLM-Powered Autonomous Agent in Minecraft (2023)

Исследователи из Nvidia и других учреждений создали Voyager — агента, который:

Пишет и генерирует код на лету для решения задач в Minecraft.
Создает библиотеку умений (skill library): каждое новое решение сохраняется как переиспользуемый "скилл".
Рекурсивная композиция: Сложные задачи разбиваются на цепочки простых скиллов. Когда простых скиллов недостаточно, создается новый сложный скилл.

Ключевое наблюдение: После 50+ часов игры Voyager создал >3500 уникальных скиллов. Система демонстрирует, как автоматическое создание инструментов накапливается экспоненциально.

3. AutoGPT / BabyAGI и их эволюция (2023-2025)

AutoGPT (2023): Первый публичный пример autonomous agent-а, который сам планирует подзадачи.
BabyAGI: Упрощенная версия с циклом: выполнить → оценить → добавить в очередь новых задач.
Эволюция проблемы: Ранние версии часто "зацикливались" или деградировали. Ключевое улучшение — явное управление состоянием и верификация результатов перед применением.

Современное понимание: Просто дать агенту возможность писать код недостаточно. Нужна система верификации — не каждый написанный скилл должен немедленно применяться. Нужна审查 и тестирование.

4. MetaGPT: Self-Evolving Multi-Agent Systems (2023-2025)

MetaGPT демонстрирует самоэволюционирующиеся мультиагентные системы:

Система не просто координирует агентов через фиксированные роли, а динамически переоценивает и перераспределяет роли на основе выполнения.
Агент с ролью "аналитик" может заметить, что работает неэффективно → запросить создание специализированного подагента-ассистента.
Self-improving loop: Метрики производительности → идентификация узких мест → создание/модификация субагентов.

5. Claude Skills Auto-Generation Паттерны

На примере Claude и подобных систем видны паттерны автоматической генерации скиллов:

Паттерн 1: Observability + Threshold

1. Агент выполняет задачу используя generic инструменты
2. Система отслеживает: повторяется ли эта цепочка операций?
3. Если повторилась 2+ раза в разных контекстах → оформи как скилл
4. Скилл регистрируется в системе с документацией

Паттерн 2: Правило Лучиана — "Повторил дважды → оформи скиллом" - Формализованное правило самосовершенствования - Автоматизация: агент ведет внутренний лог всех операций - Нейросетевой классификатор определяет: это повторение или новый паттерн? - Если повторение → автоматическое создание SKILL.md в репозитории

Примеры реальных скиллов, рожденных из повторений: - Multi-file edit patterns → deduplicate в unified refactoring skill - Bash error recovery loops → packaged как error-handling skill - Document analysis workflows → composite research skill

6. Риски и Ограничители: Как Не Дать Агенту Испортить Себя

Риск 1: Specification Gaming

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

Защита: - Многокритериальная оптимизация (не одна метрика) - Верификация на реальных задачах, а не только на бенчмарках - Красные командиры (adversarial evaluation) проверяют созданные субагенты

Риск 2: Побочные Эффекты Модификации

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

Защита: - Каждая модификация тестируется на регрессионных тестах - Rolled-back версии: сохранять снимки и уметь откатываться - Гарантированная совместимость: новый скилл не должен конфликтовать со старыми

Риск 3: Управление Версиями и Конфликты

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

Защита: - Семантическое версионирование скиллов - Explicit dependencies: скилл X требует версию Y>=2.0 - Conflict resolution: агент-арбитр проверяет совместимость перед слиянием

Риск 4: Информационная Перегрузка

Агент создает слишком много скиллов, система становится неуправляемой.

Защита: - Квоты на создание (макс N новых скиллов в день) - Автоматическое "распадание" неиспользуемых скиллов - Граф зависимостей для идентификации мертвого кода

Практические Примеры в Production

Пример 1: DeepSeek R1 и Продакшн Self-Improving Loop (2025)

Известно, что некоторые передовые системы используют production feedback для автоматического улучшения: - Реальные ошибки пользователей → анализ → создание коррекционного микроагента - Микроагент добавляется в цепочку обработки - Метрики улучшаются → скилл фиксируется

Пример 2: Anthropic's Constitutional AI + Auto-Skills (гипотетический, но основан на публичных трендах)

Идеальный паттерн для Claude: 1. Пользователь замечает повторяющийся паттерн ("эта задача требует 5 операций каждый раз") 2. Система предлагает: "Создать скилл для этого?" → Пользователь одобряет 3. Скилл генерируется, документируется, добавляется в библиотеку 4. Следующие эксеквюции уже используют скилл

Современные Вызовы и Неразрешенные Проблемы

1. Балансировка между Гибкостью и Стабильностью

Слишком консервативный агент: не создает новые скиллы, работает медленно
Слишком агрессивный: создает экспоненциально много скиллов, система деградирует
Open problem: Найти оптимальный баланс без ручной настройки

2. Верификация Generated Skills

Как доказать, что сгенерированный скилл корректен?
Formal verification (SMT solvers) ресурсозатратна для больших кодов
Statistical verification (тестирование на большом наборе примеров) несовершенна

3. Interpretability of Self-Modification

Почему агент создал именно такой скилл?
Как объяснить выбор в terms понятные человеку?
Связано с общей проблемой interpretability LLM

4. Масштабируемость к Production Scale

Voyager работал в симуляции (Minecraft) — легче контролировать
Как это масштабируется к реальным production системам?
Нужна строгая governance, audit trails, rollback механизмы

Автоматизация Правила Лучиана: Архитектура

┌─────────────────────────────────────────────────────┐
│ Агент выполняет задачу                              │
└────────────────┬────────────────────────────────────┘
                 │
                 ▼
┌─────────────────────────────────────────────────────┐
│ Operation Logger                                    │
│ - Все шаги записываются с временем и контекстом    │
└────────────────┬────────────────────────────────────┘
                 │
                 ▼
┌─────────────────────────────────────────────────────┐
│ Pattern Detector (NN-based)                         │
│ - Какой паттерн операций повторился?               │
│ - Confidence score                                  │
└────────────────┬────────────────────────────────────┘
                 │
          Confidence > 0.85?
         /              \
       YES              NO
        │                │
        ▼                └─→ Continue
┌─────────────────────────────────────────────────────┐
│ Skill Generation Engine                             │
│ - Генерирует код для скилла                        │
│ - Создает документацию и примеры                    │
│ - Задает версию (1.0)                             │
└────────────────┬────────────────────────────────────┘
                 │
                 ▼
┌─────────────────────────────────────────────────────┐
│ Regression Testing                                  │
│ - Проверить: скилл работает на известных примерах  │
│ - Не сломает ли старые скиллы?                      │
└────────────────┬────────────────────────────────────┘
                 │
          All passed?
         /         \
       YES        NO
        │          └─→ Reject + Log
        │
        ▼
┌─────────────────────────────────────────────────────┐
│ Integration                                         │
│ - Скилл добавлен в skill registry                  │
│ - Future iterations используют новый скилл         │
│ - Старые операции заменяются на вызов скилла      │
└─────────────────────────────────────────────────────┘

Выводы и Тренды на 2025-2026

Смещение парадигмы: От "stateless agents" к "self-evolving agents" с внутренним состоянием
Формализация правил: Правила типа "повторил дважды → оформи скиллом" становятся формальными компонентами архитектуры
Governance как feature: Не security add-on, а встроенная часть дизайна
Production readiness: На примере DeepSeek, Claude, других систем видно, что продакшн требует строгих гарантий

Источники

Darwin/Gödel Machine
Sakana AI (2024): "Darwin" и self-evolving agent research
Основана на философии Gödel's incompleteness и идеях J. Storrs Hall
Voyager
Wang et al., "Voyager: An Open-Ended Embodied Agent with Large Language Models" (2023)
ArXiv + Nature publication, показывает практические примеры code generation и skill composition
AutoGPT / BabyAGI
AutoGPT (2023): GitHub repo Significant-Gravitas/Auto-GPT
BabyAGI (2023): Yohei Nakajima's initial concept
OpenAI's evolution от GPT-3 к GPT-4 agents с Code Interpreter
MetaGPT
MetaGPT GitHub (2023-2024): https://github.com/geekan/MetaGPT
Документация по multi-agent self-organization
Claude Ecosystem
Anthropic's Claude API docs on skills и multi-turn prompting
Constitutional AI principles применяются к self-modification safety
ArXiv Recent Work (2024-2025)
Поиск "self-improving agents", "recursive self-modification", "meta-learning agents"
Ключевые исследователи: Kaplan, Leike, Gabriel (AI safety), Zaremba (OpenAI)

Дополнительные Материалы

Lencioni Group studies on recursive organizations: как люди организуют себя похожим образом
Software Architecture patterns: microservices, plugin architectures как аналогия для agent subagent composition
Reinforcement Learning from Human Feedback: как направить self-evolution в желаемом направлении