Skills, MCP и сабагенты: как собрать AI-агента из LEGO в 2026 году

Почему ваш AI-агент ведет себя как золотая рыбка?

Вы дали ему инструкцию на 500 слов. Он кивает, говорит "понял". Через три сообщения забывает половину. Еще через пять - тупит на элементарной задаче. Знакомо? Это не проблема модели. Это проблема архитектуры.

В 2026 году строить агентов через промпты - все равно что собирать компьютер из палок и веревок. Есть нормальные инструменты. Skills, MCP, сабагенты. Они превращают хаотичный диалог с LLM в предсказуемую систему.

Skills: не просто промпты, а упакованные знания

Skill - это не "напиши промпт для анализа кода". Это структурированный пакет знаний с четким интерфейсом. Представьте библиотеку функций в программировании. Каждая функция имеет сигнатуру, документацию, примеры использования. Skill работает так же.

Вот как выглядит плохой подход (которым все еще пользуются 80% разработчиков):

# НЕ ДЕЛАЙТЕ ТАК
prompt = """
Ты - эксперт по Python. Всегда проверяй код на:
1. Безопасность
2. Производительность
3. Читаемость
4. Соответствие PEP8

Используй black для форматирования.
Используй pylint для проверки.
Используй mypy для типизации.

Если видишь SQL-инъекцию - исправляй немедленно.
Если видишь медленный алгоритм - оптимизируй.
Если видишь плохие названия переменных - переименовывай.

Помни все эти правила всегда!
"""

Проблема? Агент забудет 90% этого через 10 сообщений. Контекстное окно переполнится. Приоритеты смешаются. Результат - непредсказуемое поведение.

Вот как это делается через Skills:

# python_code_review.skill.yaml
name: "python_code_review"
description: "Проверка Python кода на безопасность, производительность и качество"
version: "2.1"

# Явные триггеры - когда активировать skill
triggers:
  - "review python code"
  - "check this python script"
  - "analyze code quality"

# Структурированные знания (не просто текст)
knowledge:
  security_checks:
    - "SQL injection patterns"
    - "eval() usage detection"
    - "input validation patterns"
  performance_patterns:
    - "O(n^2) algorithms in loops"
    - "unnecessary database queries"
    - "memory leaks patterns"
  quality_rules:
    - "PEP8 compliance matrix"
    - "naming convention rules"
    - "function length limits"

# Примеры ввода-вывода (few-shot learning)
examples:
  - input: "review: def process(data): return eval(data)"
    output: "CRITICAL: eval() with user input detected. Replace with ast.literal_eval() or json.loads()"
  - input: "check: for i in range(n): for j in range(n): process(i, j)"
    output: "PERFORMANCE: O(n^2) nested loop detected. Consider vectorization or caching."

# Метаданные для агента
metadata:
  priority: "high"
  category: "code_quality"
  requires: ["python_knowledge", "security_basics"]

В статье "Agent Skills: как упаковать знания для LLM-агентов" я подробно разбираю, как превратить хаотичные промпты в структурированные Skills. Это фундамент.

MCP: дайте агенту руки и глаза

Model Context Protocol (MCP) - это стандарт 2025-2026 годов, который решает старую проблему: как безопасно дать агенту доступ к внешним инструментам. Раньше были костыли: API-ключи в промптах (опасно), самодельные обертки (ненадежно), ограниченный набор инструментов (негибко).

MCP работает по принципу клиент-сервер:

• Сервер предоставляет инструменты (tools) и ресурсы (resources)
• Клиент (Claude Desktop, Cursor, ваш агент) подключается к серверу
• Агент видит доступные инструменты и использует их безопасно

Почему это лучше старых подходов?

Вот минимальный MCP-сервер на Python (актуальный синтаксис на 2026 год):

# server.py
from mcp.server import Server, NotificationOptions
from mcp.server.models import InitializationOptions
import httpx

# Создаем сервер
server = Server("weather-server")

# Регистрируем инструмент
@server.list_tools()
async def handle_list_tools():
    return [
        {
            "name": "get_weather",
            "description": "Get current weather for a city",
            "inputSchema": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "City name"},
                    "country": {"type": "string", "description": "Country code (optional)"}
                },
                "required": ["city"]
            }
        }
    ]

# Обрабатываем вызов инструмента
@server.call_tool()
async def handle_call_tool(name: str, arguments: dict):
    if name == "get_weather":
        city = arguments["city"]
        # Безопасный запрос - ключ API остается на сервере
        async with httpx.AsyncClient() as client:
            response = await client.get(
                f"https://api.weatherapi.com/v1/current.json",
                params={"key": os.getenv("WEATHER_API_KEY"), "q": city}
            )
            return {
                "content": [{"type": "text", "text": f"Weather in {city}: {response.json()}"}]
            }
    
    raise ValueError(f"Unknown tool: {name}")

# Запускаем сервер
if __name__ == "__main__":
    server.run()

Агент видит инструмент get_weather, понимает его сигнатуру, использует когда нужно. Безопасно. Без хардкода API ключей в промпт.

В статье "Как подключить MCP-сервер ВкусВилла к Claude или GPT" есть практический пример интеграции с реальным API. А в "LM Studio MCP" показываю, как запустить агента вообще без облаков и API.

Сабагенты: когда один агент не справляется

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

Один агент с этим справится? Теоретически да. Практически - начнет путаться, забудет этапы, смешает контексты. Решение - сабагенты (sub-agents).

Главный агент становится оркестратором. Он:

1. Разбивает задачу на подзадачи
2. Создает сабагентов с конкретными Skills
3. Координирует их работу
4. Агрегирует результаты

Вот как это выглядит в коде (упрощенный пример):

class SecurityAgent:
    def __init__(self):
        self.skills = load_skills(["security_analysis", "dependency_check"])
    
    async def analyze(self, codebase):
        # Использует только security skills
        vulnerabilities = await self.check_vulnerabilities(codebase)
        dependencies = await self.check_dependencies(codebase)
        return {"vulnerabilities": vulnerabilities, "dependencies": dependencies}

class PerformanceAgent:
    def __init__(self):
        self.skills = load_skills(["performance_profiling", "algorithm_analysis"])
    
    async def analyze(self, codebase):
        # Использует только performance skills
        bottlenecks = await self.find_bottlenecks(codebase)
        optimizations = await self.suggest_optimizations(bottlenecks)
        return {"bottlenecks": bottlenecks, "optimizations": optimizations}

class OrchestratorAgent:
    def __init__(self):
        self.security_agent = SecurityAgent()
        self.performance_agent = PerformanceAgent()
        self.reporting_skills = load_skills(["report_generation", "slack_integration"])
    
    async def full_code_analysis(self, codebase):
        # Параллельный запуск сабагентов
        security_task = asyncio.create_task(self.security_agent.analyze(codebase))
        performance_task = asyncio.create_task(self.performance_agent.analyze(codebase))
        
        security_results = await security_task
        performance_results = await performance_task
        
        # Агрегация результатов
        report = await self.generate_report(security_results, performance_results)
        await self.send_to_slack(report)
        
        return report

Каждый сабагент имеет узкую специализацию. Свой набор Skills. Свой контекст. Главный агент не перегружен. Система масштабируется.

В статье "Как Джефф Эмануэль управляет 20+ ИИ-агентами" показана промышленная архитектура с десятками сабагентов. Они делают 2696 коммитов в неделю. Без хаоса.

Собираем систему: Skills + MCP + сабагенты

Теперь практика. Как собрать агента для автоматического code review.

1 Создаем Skills для code review

Не один мега-промпт. Набор специализированных Skills:

• security_code_analysis.skill.yaml - поиск уязвимостей
• performance_patterns.skill.yaml - антипаттерны производительности
• code_style_validation.skill.yaml - проверка стиля
• dependency_audit.skill.yaml - анализ зависимостей

Каждый Skill живет в отдельном файле. Загружается по требованию. В статье "Skills для AI-агентов: как динамически расширять возможности" я показываю файловую систему Skills, которая обновляется без перезапуска агента.

2 Настраиваем MCP-серверы для инструментов

Агенту нужны не только знания, но и действия:

• MCP-сервер для GitHub API (получение кода, создание PR)
• MCP-сервер для CI/CD (запуск тестов, проверка сборок)
• MCP-сервер для мониторинга (логи, метрики, алерты)
• MCP-сервер для коммуникации (Slack, email, Jira)

Каждый сервер предоставляет безопасный интерфейс. Агент не видит API ключи. Не может сделать что-то опасное.

3 Создаем сабагентов с четкими ролями

Вместо одного агента "на все случаи жизни":

• Security Reviewer: только security Skills + MCP для сканеров уязвимостей
• Performance Auditor: только performance Skills + MCP для профайлеров
• Style Checker: только code style Skills + MCP для линтеров
• Orchestrator: координация, агрегация, отчетность

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

4 Добавляем контекстные файлы

Skills - это знания. Но агенту нужно понимать проект. Для этого используем AGENTS.md и CLAUDE.md как в статье "AGENTS.md и CLAUDE.md: как создать контекстные файлы".

AGENTS.md описывает архитектуру:

# Агенты code review

## Security Reviewer
- Ответственный: проверка безопасности
- Skills: security_code_analysis, dependency_audit
- MCP серверы: github, vulnerability_scanner
- Выходные данные: отчет об уязвимостях

## Performance Auditor
- Ответственный: производительность
- Skills: performance_patterns, algorithm_analysis
- MCP серверы: profiler, metrics_collector
- Выходные данные: рекомендации по оптимизации

Агент читает этот файл. Понимает структуру. Знает, кого вызывать для каждой задачи.

Ошибки, которые все совершают (и как их избежать)

Что будет дальше? Микроплатежи и автономные агенты

Тренд 2026 года - агенты, которые не только работают, но и зарабатывают. Микроплатежи за вызов Skills. В статье "Микроплатежи для AI-агентов" я показываю, как Skills становятся товаром. Вы создаете Skill для анализа логов. Другие агенты платят по 2 цента за вызов. Пассивный доход из ниши.

Второй тренд - локальные модели. Зачем платить OpenAI, если AgentCPM-Explore на 4B параметров работает на ноутбуке и бьет рекорды? MCP позволяет подключать любые модели. Локальные, облачные, гибридные.

Третий тренд - автономия. Агенты, которые сами создают сабагентов. Сами обучают Skills. Сами выбирают инструменты через MCP. Мы движемся к системе, где вы ставите задачу, а архитектура строится автоматически.

Начните с малого. Возьмите одну задачу, которая сейчас решается через промпты. Разбейте на Skills. Вынесите инструменты в MCP серверы. Если задача сложная - добавьте сабагента. Измеряйте экономию токенов. Сравнивайте качество.

Через месяц у вас будет не набор промптов, а система. Которая масштабируется. Которая предсказуема. Которая не забывает инструкции после третьего сообщения.

Потому что в 2026 году золотые рыбки не выживают. Выживают системы.