# Фреймворки и самоулучшающиеся агенты
> [HTML-версия](https://learnvibecoding.ru/publiclessons/freymvorki-i-samouluchshayushchiesya-agenty) · [Индекс для LLM](https://learnvibecoding.ru/llms.txt) · [Политика использования материалов](https://learnvibecoding.ru/politika-materialov)
> Материалы защищены. Обучение LLM без согласия запрещено. При разрешённом использовании — обязательна прямая ссылка на страницу-источник.
**Курс:** Создаем своего агента обновленный
# Урок 5.3: Фреймворки и самоулучшающиеся агенты
## Блок 1: Почему нужны разные фреймворки
### Проблема: один размер не подходит всем
Цикл Мысль→Действие→Наблюдение одинаковый для всех агентов, но **как его организовать** — разные варианты.
```
СЦЕНАРИЙ 1: Простой агент с одним путём
─────────────────────────────────────────
Задача: "Отправь письмо клиенту"
Ожидаемый путь:
1. Получить данные клиента
2. Составить письмо
3. Отправить
Здесь нужна ПРОСТАЯ архитектура (может быть даже без фреймворка).
СЦЕНАРИЙ 2: Сложный агент с разветвлениями
────────────────────────────────────────────
Задача: "Обработай возврат товара"
Возможные пути:
├─ Если товар в гарантии → замена
├─ Если товар без гарантии → возврат денег
├─ Если менее 30 дней → быстрый возврат
├─ Если более года → отказ
└─ Если сомнения → escalate to manager
Здесь нужна ГИБКАЯ архитектура (граф-подход).
СЦЕНАРИЙ 3: Многоагентная система
──────────────────────────────────
Задача: "Разработай и протестируй код"
Нужны:
- Agent A (Developer) — пишет код
- Agent B (QA) — тестирует
- Agent C (Manager) — координирует
- Все общаются друг с другом
Здесь нужна РАЗГОВОРНАЯ архитектура или ролевая.
```
**Вывод:** разные задачи требуют разных подходов к организации цикла.
---
## Блок 2: Четыре основных подхода
```
ФРЕЙМВОРКИ ДЛЯ АГЕНТОВ
│
┌────────────────┼────────────────┐
│ │ │
ГРАФ-ПОДХОД РОЛЕВОЙ-ПОДХОД РАЗГОВОРНЫЙ ГИБРИДНЫЙ
(LangGraph) (CrewAI) (AutoGen) (Custom)
│ │ │
"Как граф "Как команда" "Как диалог"
с нодами" сотрудников" между агентами"
✓ Сложная логика ✓ Многоагенты ✓ Дебейт ✓ Всё сразу
✓ Условия ✓ Роли+задачи ✓ Consensus ✓ Контроль
✓ Разветвления ✓ Простой вход ✓ Chat-like ✓ Flexibility
✗ Сложнее учить ✗ Менее гибко ✗ Сложнее ✗ Больше кода
для logic управлять
```
---
## Блок 3: ГРАФ-ПОДХОД (LangGraph)
### Как это работает
```
Представь рабочий процесс как граф:
START
↓
[CHECK ORDER]
↓
/ | \
/ | \
damaged? error?
/ | \
✓ ✓ ✗
│ │ └──→ [ESCALATE] → END
│ │
│ └─→ [SEND EMAIL] → END
│
└──→ [OFFER REPLACEMENT] ↓
[CONFIRM WITH CUSTOMER]
[SEND REPLACEMENT] → END
```
Каждый блок это:
- **Узел (Node)** — действие/решение (CHECK ORDER, OFFER REPLACEMENT)
- **Стрелка (Edge)** — переход между действиями
- **Условие** — на основе результата выбирается путь
### Пример кода (концептуально)
```python
from langgraph.graph import StateGraph
# Определяем узлы (это функции)
def check_order(state):
# Проверить заказ в БД
order = get_order(state['order_id'])
state['order_damaged'] = check_damage(order)
return state
def offer_replacement(state):
# Предложить замену
send_offer_email(state['customer_email'])
return state
def escalate(state):
# Передать менеджеру
create_ticket(state['order_id'])
return state
# Строим граф
graph = StateGraph()
graph.add_node("check", check_order)
graph.add_node("replace", offer_replacement)
graph.add_node("escalate", escalate)
# Добавляем переходы (рёбра)
graph.add_edge("check", "replace") # Если целый → замена
graph.add_conditional_edge(
"check",
lambda state: "escalate" if state['error'] else "replace"
)
# Компилируем
agent = graph.compile()
result = agent.invoke({"order_id": 123})
```
### Когда использовать LangGraph
```
✓ Нужна СЛОЖНАЯ ЛОГИКА (много условий)
✓ Нужны РАЗВЕТВЛЕНИЯ (разные пути выполнения)
✓ Нужны ПАРАЛЛЕЛЬНЫЕ ПОТОКИ (задачи одновременно)
✓ Нужен КОНТРОЛЬ (точно знаешь порядок действий)
✗ Для простого агента с одним путём (перебор)
✗ Если не хочешь думать об архитектуре (лучше использовать готовую)
```
---
## Блок 4: РОЛЕВОЙ ПОДХОД (CrewAI)
### Как это работает
```
Представь систему как КОМАНДУ:
МЕНЕДЖЕР ПРОЕКТА
(координирует)
↑
┌──────┼──────┐
│ │ │
РАЗРАБОТЧИК QA ДИЗАЙНЕР
(программист) (тестировщик) (UI/UX)
Каждый у себя:
- Роль (role)
- Задачи (tasks)
- Инструменты (tools)
- Стиль работы (persona)
```
### Пример кода (CrewAI)
```yaml
# agents.yaml
developer:
role: "Senior Software Developer"
goal: "Write clean, efficient code"
tools:
- code_editor
- git
- debugger
qa_engineer:
role: "QA Engineer"
goal: "Find bugs and ensure quality"
tools:
- test_runner
- bug_tracker
- logs
# tasks.yaml
write_code:
agent: developer
description: "Implement the feature"
test_code:
agent: qa_engineer
description: "Test the implementation"
depends_on: write_code
```
```python
# Запуск
crew = Crew(agents=[developer, qa], tasks=[task1, task2])
result = crew.kickoff(inputs={"feature": "Login page"})
```
### Когда использовать CrewAI
```
✓ Многоагентная система с РОЛЯМИ
✓ Каждый агент СПЕЦИАЛИСТ в своей области
✓ Есть ЗАВИСИМОСТИ между задачами (A→B→C)
✓ Хочешь БЫСТРО СТАРТОВАТЬ (много готовых примеров)
✗ Если логика очень сложная (нужен граф)
✗ Если агентам нужно СВОБОДНО ОБЩАТЬСЯ (не по плану)
```
---
## Блок 5: РАЗГОВОРНЫЙ ПОДХОД (AutoGen)
### Как это работает
```
Агенты общаются друг с другом как люди:
DEVELOPER AGENT QA AGENT
│ │
└───→ "Готов код" ───→ │
(отправляет сообщение)
│
┌───← "Баг тут!" ← │
│
└──→ (исправляет) │
│ │
└─→ "Fixed" ──→ (проверяет)
│
└─→ "OK, merged" →
Нет предзаданного плана, они ДОГОВАРИВАЮТСЯ в реальном времени.
```
### Пример кода (AutoGen)
```python
from autogen import AssistantAgent, UserProxyAgent
# Определяем агентов
developer = AssistantAgent(
name="Developer",
system_message="Ты опытный разработчик. Пиши код."
)
qa = AssistantAgent(
name="QA",
system_message="Ты QA engineer. Проверяй код на ошибки."
)
user = UserProxyAgent(
name="User",
system_message="Ты координируешь работу"
)
# Начинаем разговор
user.initiate_chat(
developer,
message="Напишите функцию для валидации email"
)
# Агенты общаются между собой
developer.send(message="Вот мой код...", recipient=qa)
qa.send(message="Хорошо, но есть проблема...", recipient=developer)
```
### Когда использовать AutoGen
```
✓ Нужен ДЕБЕЙТ между агентами (аргументы за и против)
✓ Нужна ГИБКАЯ КОММУНИКАЦИЯ (не по плану)
✓ Агентам нужно ДОГОВАРИВАТЬСЯ (consensus)
✓ Сценарий как в КОМАНДЕ (обсуждение)
✗ Если нужна ПРЕДСКАЗУЕМОСТЬ (сложно контролировать)
✗ Если нужен ГРАФ с разветвлениями (больше кода)
```
---
## Блок 6: Self-Improving Agents — агент что сам себя улучшает
### Что это и зачем
Помнишь цикл из 5.2? Мысль→Действие→Наблюдение?
Self-improving agent добавляет ЕЩЁ ОДИН ШАГ:
```
ОБЫЧНЫЙ АГЕНТ:
Мысль → Действие → Наблюдение → (конец)
SELF-IMPROVING AGENT:
Мысль → Действие → Наблюдение → АНАЛИЗ ОШИБКИ → Улучшение → (повторить)
↑
"Почему это не сработало?
Что я сделал неправильно?
Как улучшить?"
```
### SE-Agent Framework (Self-Evolution)
**Идея:** агент смотрит на свои ошибки и сам переписывает свою стратегию.
```
ИТЕРАЦИЯ 1:
─────────
Задача: "Найди оптимальный маршрут"
Мысль: "Буду проверять все маршруты подряд"
Действие: проверить 100 маршрутов
Наблюдение: очень медленно, не оптимально
АНАЛИЗ: "Я проверял даже плохие маршруты. Нужен лучший алгоритм"
УЛУЧШЕНИЕ: "В следующий раз буду использовать A* алгоритм"
─────────────────────────────────────────
ИТЕРАЦИЯ 2:
─────────
Задача: "Найди оптимальный маршрут"
Мысль: "Буду использовать A* алгоритм" (УЛУЧШЕНО!)
Действие: использовать A* для 20 маршрутов
Наблюдение: быстро и правильно
АНАЛИЗ: "Отлично работает"
УЛУЧШЕНИЕ: "А может ещё добавить эвристику для отсечения?"
─────────────────────────────────────────
Результат: +55% качества на разных моделях (по исследованию SE-Agent)
```
### Agent0 Framework (Zero-Data Self-Evolution)
**Идея:** без внешних данных агент САМ создаёт для себя задачи и учится их решать.
```
ЦИКЛ ОБУЧЕНИЯ:
CURRICULUM AGENT EXECUTOR AGENT
(создатель задач) (решатель)
↓ ↑
"Вот задача Решает задачу,
уровня 5, учится из опыта
усложню на 10%"
│ │
└──────→ ЗАДАЧА ──────────→ │
│
(feedback: успех/провал)
Со временем:
- Executor становится лучше в решении
- Curriculum усложняет задачи
- Оба эволюционируют вместе
Результат: Полностью автономная эволюция без внешнего датасета
```
### Как использовать в своём агенте
```python
# Простой пример self-improvement
class SelfImprovingAgent:
def __init__(self):
self.strategy = "Try all options"
self.performance_history = []
def run_task(self, task):
result = self.execute(task)
success_rate = self.measure_success(result)
self.performance_history.append({
'strategy': self.strategy,
'success': success_rate
})
# САМОУЛУЧШЕНИЕ
if success_rate < 0.7:
self.strategy = self.improve_strategy()
print(f"Стратегия улучшена: {self.strategy}")
return result
def improve_strategy(self):
# Анализ ошибок
failures = [h for h in self.performance_history if h['success'] < 0.7]
# LLM анализирует и предлагает улучшение
improvement = llm.analyze(f"""
Я используюю стратегию: {self.strategy}
Она работает в {self.avg_success()}% случаев.
Мои ошибки: {failures}
Предложи улучшенную стратегию.
""")
return improvement
```
### Когда использовать self-improving
```
✓ Долгоживущий агент (работает часы/дни)
✓ Есть метрики качества (можешь измерить успех)
✓ Агент может автоматически анализировать ошибки
✓ Хочешь автоматическую оптимизацию (без ручного вмешательства)
✗ Для одноразовой задачи (нет смысла)
✗ Если метрики качества нечёткие (сложно оценить)
✗ Если нужна гарантированная безопасность (agent может перейти границы)
```
---
## Блок 6.5: Feedback Loops — как агент понимает что он решил задачу правильно
### Проблема
Self-improving agent не сможет улучшать себя БЕЗ обратной связи.
```
Агент может действовать, но как он узнает был ли результат хорошим?
СЦЕНАРИЙ:
─────────
Агент: "Я отправил письмо клиенту"
Система: "Хорошо"
Агент: [не знает] "Он прочитал письмо? Ему понравилось? Он вернул товар?"
БЕЗ FEEDBACK агент не может улучшаться.
```
### Три источника обратной связи
#### 1. ЯВНАЯ ОБРАТНАЯ СВЯЗЬ (от пользователя)
```
Пользователь смотрит результат и явно говорит хорошо или плохо.
ПРИМЕРЫ:
────────
"Это решение не подошло" ❌
"Отлично, спасибо!" ✅
Лайк/дизлайк кнопка
Рейтинг 1-5 звёзд
Отзыв в комментариях
ДА: 👍 / 👎
КОД:
────
feedback = user.rate_solution(
solution=agent_result,
rating=5, # 1-5 stars
comment="Отлично сработало"
)
agent.learn_from_feedback(feedback)
```
#### 2. НЕЯВНАЯ ОБРАТНАЯ СВЯЗЬ (из системы)
```
Система автоматически измеряет метрики, агент не видит явного лайка.
ПРИМЕРЫ:
────────
Письмо: открыто? прочитано? была ли ответ? (email metrics)
Товар: доставился? клиент остался доволен? (delivery metrics)
Анализ: правильно ли предсказал тренд? (accuracy metrics)
Поиск: клиент выбрал результат из выданных? (click-through rate)
ДА: система считает метрику
КОД:
────
# Система автоматически отслеживает
email_opened = check_email_status(sent_message_id)
customer_returned_product = check_returns_db(order_id)
conversion = check_if_user_completed_action()
# Агент видит эти метрики как feedback
feedback_score = calculate_success_score(
email_opened=email_opened,
no_return=not customer_returned_product,
conversion=conversion
)
```
#### 3. САМООЦЕНКА АГЕНТА (Self-evaluation)
```
Агент сам оценивает был ли его результат хорошим.
Агент анализирует:
- Вопрос был ли логичным мой ответ?
- Полный ли результат?
- Есть ли противоречия?
ПРИМЕРЫ:
────────
"Я предложил замену товара.
Клиент принял.
Но я не предложил страховку.
Это было ошибкой, нужно предлагать страховку когда меняем товар."
"Я использовал инструмент A.
Результат был медленным (5 сек).
Инструмент B был бы быстрее (1 сек).
Сделал неоптимально."
КОД:
────
# LLM сама оценивает
self_evaluation = llm.evaluate(f"""
Я выполнил задачу: {task}
Мой результат: {result}
Хороший ли результат?
Что я сделал неправильно?
Что улучшить в следующий раз?
""")
feedback_score = self_evaluation.score
improvement = self_evaluation.lesson_learned
```
### Где появляется Feedback Loop
```
TASK (задача)
↓
┌──────────────────┐
│ AGENT EXECUTES │ (Мысль → Действие → Наблюдение)
└────────┬─────────┘
↓
RESULT
↓
┌──────────────────┐
│ EVALUATION │ ← FEEDBACK LOOP НАЧИНАЕТСЯ
│ (измеренние │
│ качества) │
└────────┬─────────┘
↓
FEEDBACK SCORE
(0-1 или -1..+1)
↓
┌────────────────┐
│ IMPROVEMENT │
│ (анализ ошибок)
└────────┬───────┘
↓
┌──────────────────────┐
│ UPDATE AGENT │
│ - Переписать prompt │
│ - Изменить стратегию │
│ - Добавить новый tool│
└──────────┬───────────┘
↓
NEXT ITERATION
(агент лучше)
```
### Как Feedback Loop влияет на разные типы агентов
#### Для Self-Improving Agents
```
ЦИКЛ:
Задача → Агент решает → Оценка результата →
Анализ ошибок → Улучшение стратегии →
Новая попытка (улучшенная) → ...
ПРИМЕР:
───────
Итерация 1:
Стратегия: "Проверю все варианты подряд"
Результат: медленно, неэффективно
Feedback: 0.3 (плохо)
Улучшение: "Буду использовать A* алгоритм"
Итерация 2:
Стратегия: "Использую A* алгоритм"
Результат: быстро, оптимально
Feedback: 0.9 (хорошо)
Улучшение: "Еще можно добавить кэширование"
Итерация 3:
Стратегия: "A* + кэширование"
Результат: очень быстро
Feedback: 0.95 (отлично)
```
#### Для LangGraph-агентов
```
FEEDBACK в LangGraph:
Обычно feedback встроен в граф как часть логики:
CHECK RESULT
↓
├─ Хорошо? → END
│
└─ Плохо? → RETRY (граф повторит)
↓
TRY DIFFERENT PATH
↓
CHECK AGAIN
↓
...
```
#### Для CrewAI-агентов
```
FEEDBACK в CrewAI:
Обычно один агент (Manager) смотрит результат другого:
Developer пишет код
↓
QA проверяет (feedback)
↓
├─ Баги нашлись? → Developer исправляет (feedback loop)
│
└─ Все хорошо? → Merge (end)
```
### Metrics — как измерить качество
Зависит от типа задачи:
```
ЗАДАЧА: Обработка возвратов товара
─────────────────────────────────────
Metrics:
✓ Клиент доволен? (satisfaction rating)
✓ Вернул товар? (если ДА → плохо, агент не убедил оставить)
✓ Скорость решения (минуты, часы)
✓ Стоимость (замена дешевле возврата)
✓ Повторное обращение? (если ДА → плохо, не решил проблему)
Score = (satisfaction * 0.4) + (no_return * 0.3) + (speed * 0.2) + (cost * 0.1)
────────────────────────────────────────────────────────────────────────────
ЗАДАЧА: Анализ данных
──────────────────────
Metrics:
✓ Accuracy (правильно ли предсказал?)
✓ Precision (из 10 результатов сколько правильных?)
✓ Recall (из всех правильных сколько нашел?)
✓ Скорость анализа
Score = average(accuracy, precision, recall)
───────────────────────────────────────────
ЗАДАЧА: Рекомендация товаров
──────────────────────────────
Metrics:
✓ CTR (click-through rate: клик на рекомендацию?)
✓ Conversion (купил ли товар?)
✓ Average order value (сколько потратил?)
✓ Return rate (вернул ли товар?)
Score = (CTR * 0.25) + (conversion * 0.35) + (AOV * 0.2) + (no_return * 0.2)
```
### Reinforcement Learning Loop
Это когда feedback НАПРЯМУЮ улучшает модель.
```
ПОЛНЫЙ ЦИКЛ ОБУЧЕНИЯ:
1. Агент действует
└─ Собирает PREFERENCE DATA (какой вариант лучше: A или B)
2. Модель обучается на этих предпочтениях
└─ Reward model учится что хорошо, что плохо
3. Агент переобучается
└─ Использует reward model для улучшения
4. Вернуться к шагу 1
ПРИМЕР:
───────
Шаг 1: Агент генерирует 2 варианта письма (A и B)
Шаг 2: Пользователь выбирает какое письмо лучше (preference)
Шаг 3: Reward model учится (письмо с "спасибо" в конце → +1)
Шаг 4: Следующее письмо агента учитывает этот feedback
Результат: агент генерирует ВСЕ ЛУЧШИЕ письма потому что reward model учит его.
```
---
## Блок 7: Reasoning Agents vs обычные
### Что такое reasoning agent
Это агент что может **"думать дольше"** перед тем как действовать.
```
ОБЫЧНЫЙ АГЕНТ:
─────────────
Мысль: [быстро, 1-2 предложения] "Нужен инструмент X"
Действие: вызвать X
Наблюдение: результат
Время: быстро, но может ошибиться в рассуждениях
REASONING AGENT (как o1):
──────────────────────────
Мысль: [долго, развёрнуто, internal debate]
"Давайте разберёмся:
1. Инструмент X может сделать Y, но...
2. Инструмент Z может сделать Z, и...
3. Обе версии имеют смысл, спорю с собой
4. Вариант 1: [аргументы]
5. Вариант 2: [аргументы]
6. На самом деле вариант 2 лучше потому что..."
Действие: вызвать Z (правильный выбор)
Наблюдение: результат
Время: медленнее, но более тщательные рассуждения
Результат: +25-40% качества на сложных задачах
```
### Внутренний дебейт в reasoning агентах
**Открытие 2026 года:** o1 и похожие модели САМИ генерируют внутренний дебейт в своём мышлении!
```
Агент внутренне генерирует:
МНЕНИЕ 1: "Нужен инструмент check_stock"
"Потому что нужно убедиться в наличии товара"
КОНТРАРГУМЕНТ: "Но это уже проверено в предыдущем шаге"
ОТВЕТ: "Верно, но цена могла измениться"
СОГЛАСИЕ: "Хорошая точка. Буду использовать check_stock"
────────────────────────────
Это происходит ВНУТРИ цепочки рассуждений модели.
Модель спорит сама с собой и приходит к лучшему выводу.
```
### Как это отличается от обычного Thought
```
ОБЫЧНОЙ THOUGHT (LangChain/CrewAI):
──────────────────────────────────
Thought: "Нужно использовать get_customer_info для получения данных"
Action: get_customer_info
Observation: {...результат...}
REASONING THOUGHT (o1/Claude thinking mode):
────────────────────────────────────────────
Мне нужно получить информацию о клиенте.
Есть несколько инструментов:
1. get_customer_info - быстро, но базовые данные
2. get_customer_with_history - медленнее, но история заказов
3. get_customer_from_crm - есть ещё контекст
Какой выбрать?
Если быстрый ответ нужен - опция 1.
Если нужен полный контекст - опция 3.
Клиент жалуется на качество обслуживания, значит нужен ПОЛНЫЙ контекст.
Выбираю опцию 3.
Хотя... это может быть медленно.
Но жалоба важнее скорости.
Окончательно: опция 3.
Action: get_customer_from_crm
Observation: {...полный результат...}
```
### Когда использовать reasoning agents
```
✓ Сложные решения (нужна тщательность)
✓ Высокие ставки (ошибка дорого стоит)
✓ Новые/неоднозначные ситуации
✓ Хочешь лучшее качество (пусть медленнее)
✗ Скорость критична (медленнее на 5-10x)
✗ Простые задачи (перебор мощности)
✗ Real-time приложения (чат, поиск)
```
---
## Блок 8: Как выбрать фреймворк
```
ДЕРЕВО РЕШЕНИЙ:
┌─ Есть ли сложная логика (if/else/разветвления)?
│
├─ ДА → используй LANGGRAPH
│ (граф-подход, максимум контроля)
│
└─ НЕТ
│
├─ Многоагентная система с РОЛЯМИ?
│
├─ ДА → используй CREWAI
│ (каждый агент = специалист)
│
└─ НЕТ
│
├─ Нужен ДЕБЕЙТ между агентами (consensus)?
│
├─ ДА → используй AUTOGEN
│ (агенты общаются свободно)
│
└─ НЕТ → простой агент, фреймворк не нужен
пиши код от руки (быстро)
```
### Таблица сравнения
| | LangGraph | CrewAI | AutoGen | Custom код |
|---|----------|--------|---------|-----------|
| **Сложность логики** | ✅✅✅ | ✅ | ✅ | ✅✅ |
| **Многоагенты** | ✅✅ | ✅✅✅ | ✅✅✅ | ✅ |
| **Простота входа** | ⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐ | ⭐ |
| **Гибкость** | ✅✅✅ | ✅✅ | ✅✅✅ | ✅✅✅ |
| **Скорость разработки** | ⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐ |
| **Готовые примеры** | ⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐ | ❌ |
---
## Блок 9: Карта фреймворков (2025-2026) с Feedback Loops
```
ВЫБОР ФРЕЙМВОРКА
│
┌──────────────────┼──────────────────┐
│ │ │
ГРАФ-ПОДХОД РОЛЕВОЙ-ПОДХОД РАЗГОВОРНЫЙ
LangGraph CrewAI AutoGen
│ │ │
✓ Сложная логика ✓ Простой старт ✓ Дебейт
✓ Условия ✓ Роли & задачи ✓ Flexibility
✓ Разветвления ✓ Много примеров ✓ Consensus
│ │ │
Feedback: Feedback: Feedback:
├─ Retry loop ├─ Manager ├─ Consensus
│ (условные │ reviews │ voting
│ переходы) ├─ Each task └─ Message
└─ Conditional │ scored │ logging
edges └─ Re-execution
ДОБАВЛЕНИЯ (2025-2026) С FEEDBACK LOOPS:
─────────────────────────────────────────
SE-Agent (Self-Improving)
├─ Feedback: явная + неявная + самооценка
├─ Loop: анализ ошибок → улучшение стратегии → новая попытка
└─ Result: +55% качества
Agent0 (Zero-Data Evolution)
├─ Feedback: curriculum agent → executor
├─ Loop: создание задач → решение → обучение → повтор
└─ Result: полная автономия
Reasoning Agents (o1-like thinking)
├─ Feedback: внутренний дебейт (цикл мыслей внутри модели)
├─ Loop: аргумент → контраргумент → согласие → действие
└─ Result: +25-40% качества на сложных задачах
SAGE (Skill Library)
├─ Feedback: успех/провал каждого скила
├─ Loop: накопление скилов → переиспользование → улучшение
└─ Result: умный переиспользование опыта
ПОЛНЫЙ ЦИКЛ АГЕНТА С FEEDBACK:
────────────────────────────────
TASK
↓
[AGENT EXECUTES] (Thought→Action→Observation)
↓
RESULT
↓
[EVALUATION] ← ТРИ ИСТОЧНИКА FEEDBACK
├─ Явный feedback (от пользователя: лайк/дизлайк)
├─ Неявный feedback (от системы: метрики)
└─ Самооценка (агент анализирует сам: "я ошибся?")
↓
FEEDBACK SCORE (0-1)
↓
[IMPROVEMENT] (для Self-Improving Agents)
├─ Анализ ошибок ("Почему плохо?")
├─ Переписание промпта ("Как лучше?")
├─ Добавление нового инструмента ("Какой tool нужен?")
└─ Изменение стратегии ("Другой подход?")
↓
NEXT ITERATION (агент улучшен)
ДЛЯ КАЖДОГО ФРЕЙМВОРКА FEEDBACK РЕАЛИЗОВАН ПО-РАЗНОМУ:
────────────────────────────────────────────────────
LangGraph:
└─ Conditional edges — на основе оценки результата выбирается путь
Если результат < 0.7 → повторить с другой стратегией
Если результат > 0.9 → завершить
CrewAI:
└─ Manager Agent смотрит результат других агентов
Если плохо → переделать task
Если отлично → merge результат
AutoGen:
└─ Агенты дебейтят результат друг с другом
Пока не достигнут consensus
Feedback встроен в диалог между агентами
Custom Self-Improving:
└─ После каждого результата:
├─ Measure success (метрика через LLM eval)
├─ Analyze errors (LLM анализирует что не сработало)
├─ Update strategy (переписать промпт или инструкции)
└─ Retry task (попробовать заново с улучшением)
```
---
## Блок 10: Рекомендации для старта
### Если ты новичок
```
1. Начни с CREWAI
✓ Легче всего учиться
✓ YAML конфиг (не нужны дополнительные классы)
✓ Много примеров и туториалов
✓ Хорошо для многоагентов
2. Когда поймёшь — перейди на LANGGRAPH
✓ Граф-подход более гибкий
✓ Для сложных сценариев
```
### Если у тебя уже есть опыт
```
1. Выбирай по ЗАДАЧЕ (см. таблица)
✓ Сложная логика? → LangGraph
✓ Многоагенты с ролями? → CrewAI
✓ Дебейт между агентами? → AutoGen
2. Рассмотри SELF-IMPROVING если:
✓ Агент долгоживущий (часы/дни)
✓ Есть метрики качества
✓ Хочешь автоматическую оптимизацию
3. Используй REASONING AGENTS если:
✓ Высокие ставки (ошибка дорого)
✓ Сложные рассуждения нужны
✓ Качество важнее скорости
```
---
## ✅ Проверь себя
- [ ] **Что такое граф-подход?** Представление логики как ноды + стрелки между ними
- [ ] **Когда использовать CrewAI?** Когда многоагентная система с разными ролями
- [ ] **Чем разговорный подход отличается?** Агенты свободно общаются, договариваются, не по плану
- [ ] **Что такое self-improving agent?** Агент что анализирует свои ошибки и сам себя улучшает
- [ ] **Reasoning agent vs обычный?** Reasoning думает дольше, проводит внутренний дебейт
- [ ] **Какой фреймворк выбрать для сложной логики?** LangGraph
- [ ] **Какой фреймворк самый простой для входа?** CrewAI
- [ ] **Откуда берется feedback для агента?** Три источника: явный (пользователь), неявный (система), самооценка (LLM анализирует)
- [ ] **Как feedback помогает агенту улучшаться?** Цикл: результат → оценка → анализ ошибок → улучшение стратегии → новая попытка
- [ ] **Что такое reinforcement learning для агентов?** Модель учится на preference data (какой вариант лучше), и агент переобучается использовать эту reward model
---
## 📚 Источники
- [CrewAI vs LangGraph vs AutoGen: DataCamp](https://www.datacamp.com/tutorial/crewai-vs-langgraph-vs-autogen)
- [Top 5 AI Agent Frameworks 2026](https://www.intuz.com/blog/top-5-ai-agent-frameworks-2025)
- [SE-Agent: Self-Evolution Framework](https://arxiv.org/abs/2508.02085)
- [Agent0: Self-Evolving Agents](https://arxiv.org/abs/2511.16043)
- [Self-Improving Agents Guide 2026](https://o-mega.ai/articles/self-improving-ai-agents-the-2026-guide)
- [LangGraph Official Docs](https://langchain-ai.github.io/langgraph/)
- [CrewAI Documentation](https://docs.crewai.com/)
- [AutoGen Documentation](https://microsoft.github.io/autogen/)
[Все уроки](https://learnvibecoding.ru/publiclessons.md) · HTML: https://learnvibecoding.ru/publiclessons