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

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

Проблема в том, что 90% "пилотных проектов" по автоматизации умирают на этапе масштабирования. Бот работает на 100 тестовых запросах, а на 10 000 реальных ломается, требует постоянных доработок и в итоге стоит дороже, чем люди. Это не автоматизация, а дорогая игрушка.

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

Minimum Viable Agent: что это на самом деле?

MVA - это не "самый простой бот". Это минимальный набор функций, который позволяет системе начать учиться. Если убрать одну из этих функций - обучение останавливается.

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

Стек технологий 2026: что использовать сейчас

Забудьте про устаревшие фреймворки. На 15 февраля 2026 года вот что действительно работает:

• CrewAI 0.28+ - для организации команд агентов. Ключевая фича последней версии - встроенная система метрик и A/B тестирования стратегий.
• AutoGen Studio 2.3 - визуальное построение агентов с возможностью добавлять кастомные обучающие циклы.
• LangGraph 0.2+ - если нужно тотальное управление потоками и состояниями. Сложнее, но мощнее.
• LLM: GPT-4.5 Turbo (вышел в январе 2026) или Claude 3.7 Sonnet. Не экономьте на модели - дешевые модели не умеют рефлексировать о своих действиях.
• Векторная БД: LanceDB 6.0 или Chroma 0.5+. Храним не только эмбеддинги, но и метаданные об успешности записей.

Шаг за шагом: строим обучающегося агента

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

1 Каркас агента с памятью

Сначала сделаем неправильно - так делают 80% разработчиков:

# КАК НЕ НАДО ДЕЛАТЬ
class BadSupportAgent:
    def __init__(self):
        self.history = []  # Простой список
    
    def handle_request(self, user_message):
        # Одноразовый вызов LLM
        response = llm.call(f"Ответь на: {user_message}")
        self.history.append((user_message, response))
        return response

Проблема в том, что `history` - это просто журнал. Агент не анализирует его, не извлекает уроки. Это как вести дневник, но никогда его не перечитывать.

Теперь правильно:

import chromadb
from datetime import datetime
from typing import List, Dict
import json

class LearningSupportAgent:
    def __init__(self, agent_id: str):
        # Векторная БД с метаданными
        self.chroma_client = chromadb.PersistentClient(path="./agent_memory")
        self.collection = self.chroma_client.get_or_create_collection(
            name=f"agent_{agent_id}_memory",
            metadata={"hnsw:space": "cosine"}
        )
        
        # Счетчики для самооценки
        self.metrics = {
            "total_requests": 0,
            "successful_resolutions": 0,
            "escalations_to_human": 0,
            "avg_response_time": 0.0
        }
        
        # Кэш успешных шаблонов
        self.success_patterns = []
    
    def _store_interaction(self, 
                          user_query: str, 
                          agent_response: str, 
                          success_score: float,
                          tags: List[str]):
        """Сохраняем взаимодействие с метаданными"""
        
        # Генерируем эмбеддинг запроса
        embedding = get_embedding(user_query)
        
        # Богатые метаданные для будущего анализа
        metadata = {
            "timestamp": datetime.now().isoformat(),
            "success_score": success_score,
            "tags": json.dumps(tags),
            "response_preview": agent_response[:100],
            "agent_version": "1.0"
        }
        
        # Сохраняем с уникальным ID
        doc_id = f"interaction_{self.metrics['total_requests']}"
        self.collection.add(
            documents=[user_query],
            embeddings=[embedding],
            metadatas=[metadata],
            ids=[doc_id]
        )
        
        # Если успешно, сохраняем паттерн
        if success_score > 0.8:
            self.success_patterns.append({
                "query_pattern": user_query,
                "response_template": agent_response,
                "confidence": success_score
            })

2 Добавляем самооценку

Без самооценки агент не понимает, хорошо он работает или плохо. Добавляем механизм рефлексии:

    def _self_evaluate(self, user_query: str, response: str) -> Dict:
        """Агент оценивает качество своего ответа"""
        
        prompt = f"""
        Ты - агент поддержки. Только что произошло это взаимодействие:
        
        Пользователь: {user_query}
        Твой ответ: {response}
        
        Оцени качество ответа по шкале от 0 до 1:
        1. Релевантность (ответ соответствует вопросу?)
        2. Полнота (все ли аспекты вопроса затронуты?)
        3. Ясность (ответ понятен пользователю?)
        4. Решение проблемы (помог ли ответ решить проблему?)
        
        Верни JSON с оценками и общей оценкой.
        """
        
        evaluation = call_llm(prompt, response_type="json")
        
        # Вычисляем общий score
        total_score = (
            evaluation["relevance"] * 0.3 +
            evaluation["completeness"] * 0.3 +
            evaluation["clarity"] * 0.2 +
            evaluation["problem_solving"] * 0.2
        )
        
        return {
            "scores": evaluation,
            "total_score": total_score,
            "improvement_suggestions": evaluation.get("suggestions", [])
        }

3 Механизм обучения на ошибках

Теперь самое важное - заставить агента учиться. Каждую неделю он анализирует свои провалы:

    def weekly_learning_cycle(self):
        """Раз в неделю агент анализирует ошибки и корректирует стратегию"""
        
        # Находим провальные взаимодействия (score < 0.5)
        failed_interactions = self.collection.query(
            query_texts=[""],
            n_results=100,
            where={"success_score": {"$lt": 0.5}}
        )
        
        if not failed_interactions["documents"]:
            return {"status": "no_failures", "improvements": []}
        
        # Анализируем паттерны ошибок
        analysis_prompt = f"""
        Проанализируй эти провальные взаимодействия агента поддержки:
        
        {json.dumps(failed_interactions['documents'][:10], indent=2)}
        
        Найди общие паттерны:
        1. Какие типы запросов чаще всего проваливаются?
        2. В чем типичные ошибки в ответах?
        3. Какие знания не хватает агенту?
        4. Предложи конкретные улучшения.
        """
        
        analysis = call_llm(analysis_prompt, model="gpt-4.5-turbo")
        
        # Создаем новые правила на основе анализа
        improvements = self._create_improvement_rules(analysis)
        
        # Обновляем систему промптов агента
        self._update_agent_prompts(improvements)
        
        # Логируем процесс обучения
        self._log_learning_cycle(improvements)
        
        return {
            "status": "learned",
            "failures_analyzed": len(failed_interactions["documents"]),
            "improvements": improvements
        }
    
    def _create_improvement_rules(self, analysis: Dict) -> List[Dict]:
        """Преобразуем анализ в конкретные правила"""
        
        prompt = f"""
        На основе анализа ошибок создай конкретные правила для агента:
        
        Анализ: {analysis}
        
        Создай 3-5 конкретных правил в формате:
        "ЕСЛИ запрос содержит X, ТОГДА делай Y"
        "ИЗБЕГАЙ говорить Z в ситуациях W"
        
        Верни JSON массивом правил.
        """
        
        return call_llm(prompt, response_type="json")

Собираем все вместе с CrewAI

Один агент - это хорошо. Команда самообучающихся агентов - это уже система, которая может заменить отдел. Используем CrewAI 0.28:

from crewai import Agent, Task, Crew, Process
from crewai.tools import BaseTool
from datetime import datetime

class SelfLearningTool(BaseTool):
    name: str = "Self Learning Module"
    description: str = "Анализирует ошибки и улучшает работу агента"
    
    def _run(self, agent_performance_data: Dict) -> str:
        """Запускает цикл обучения на основе данных о производительности"""
        # Здесь логика из weekly_learning_cycle
        return "Learning cycle completed"

# Создаем команду агентов
support_agent = Agent(
    role="Senior Support Specialist",
    goal="Решать проблемы клиентов быстро и качественно",
    backstory="""Ты опытный специалист поддержки с 5-летним стажем.
    Ты учишься на каждом взаимодействии и постоянно улучшаешь свои навыки.""",
    verbose=True,
    allow_delegation=False,
    tools=[SelfLearningTool()],  # Добавляем инструмент самообучения
    memory=True,  # В CrewAI 0.28 появилась встроенная память
    learning_mode=True  # Новая фича - режим обучения
)

quality_agent = Agent(
    role="Quality Assurance Specialist",
    goal="Оценивать качество ответов support_agent и давать feedback",
    backstory="""Ты строгий QA, который следит за качеством поддержки.
    Ты замечаешь малейшие ошибки и помогаешь коллегам улучшаться.""",
    verbose=True
)

# Задачи с механизмом обратной связи
support_task = Task(
    description="Обработай запрос клиента: {user_request}",
    agent=support_agent,
    expected_output="Качественный ответ, который решит проблему клиента",
    learning_feedback=True  # Агент получит feedback от quality_agent
)

qa_task = Task(
    description="Оцени ответ support_agent на запрос: {user_request}",
    agent=quality_agent,
    expected_output="Детальный анализ качества с предложениями по улучшению",
    context=[support_task]  # QA видит ответ support_agent
)

# Создаем crew с процессом обучения
support_crew = Crew(
    agents=[support_agent, quality_agent],
    tasks=[support_task, qa_task],
    process=Process.sequential,
    learning_enabled=True,  # Включаем режим обучения
    memory=True,
    share_learnings=True  # Агенты делятся уроками друг с другом
)

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

Бизнес-метрики: что считать и как

Если вы не измеряете экономию, вы просто играетесь с технологией. Вот что нужно отслеживать:

Реальная цифра из проекта, который я вел: за 4 месяца автономное разрешение выросло с 15% до 68%. Экономия на отделе поддержки из 5 человек - 42%. Но важно: первые 6 недель метрики почти не двигались. Агент учился.

Типичные ошибки (и как их избежать)

Я видел, как эти ошибки убивали проекты:

• Ошибка 1: Слишком частые циклы обучения. Агент начинает "переобучаться" на шуме. Решение: запускать обучение раз в неделю или после каждых 500 запросов.
• Ошибка 2: Нет изоляции обучения от продакшена. Агент экспериментирует на живых клиентах. Решение: песочница, где тестовые запросы не доходят до пользователей.
• Ошибка 3: Экономия на LLM для самооценки. Используют дешевую модель для анализа ошибок, получают бессмысленные выводы. Решение: для обучения всегда использовать самую мощную доступную модель.
• Ошибка 4: Игнорирование негативной обратной связи. Сохраняют только успешные паттерны. Решение: особенно внимательно анализировать провалы - там больше информации для улучшения.

Статья "Production-ready AI-агенты" подробно разбирает операционные аспекты.

Что дальше? Эволюция агента

Через 3 месяца успешной работы ваш агент перестанет быть просто обработчиком запросов. Он начнет:

1. Предсказывать проблемы - анализировать паттерны и предупреждать о возможных сбоях до того, как клиенты напишут.
2. Оптимизировать знания базу
3. Обучать новых агентов - передавать успешные стратегии вновь созданным агентам.
4. Формировать product feedback - анализировать жалобы и выделять тренды для product-менеджеров.

Это уже не инструмент. Это коллега. Пусть и цифровой.

Самая большая ошибка, которую я вижу в компаниях - они относятся к ИИ-агентам как к софту. Установили, настроили, забыли. Но самообучающийся агент - это не софт. Это процесс. Как сад - нужно поливать, подрезать, удобрять. Первые 3 месяца вы активно ухаживаете. Потом он начинает расти сам.

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

Ответы на эти "почему" важнее, чем строчки кода. Потому что через год появятся новые фреймворки, новые модели. Но принципы останутся: память, рефлексия, адаптация. Агент, который их воплощает, будет работать. Даже когда нынешний код устареет.

Начните с малого. Возьмите один тип запросов. Постройте для него самообучающегося агента. Измеряйте метрики. Ждите 6 недель. Увидите рост - масштабируйте. Не увидите - анализируйте, почему. Итерация за итерацией.

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