ECC: Система оптимизации производительности AI-агентов

ECC — это система для повышения эффективности AI-агентов через навыки, инстинкты, управление памятью и исследования. Поддержка Claude Code, Codex, Opencode, Cursor.

Архитектура ECC и основные компоненты

ECC — это не просто фреймворк для AI-агентов. Это попытка решить реальную проблему: безумие токенов и хаос в управлении контекстом. Я видел, как агенты в проектах с 500-километровым кодом превращают простую задачу в 200-километровый nightmare из-за неправильного управления памятью и навыками.

### Модуль управления навыками и инстинктами

С точки зрения безопасности, модуль навыков — это ваш firewall правил для AI-агента. Он определяет, что агент может делать, а что — нет. Типовая ошибка: включить все навыки сразу и надеяться на лучшее. На практике я видел случай, когда агент с Claude Code просто включил Docker-навык и начал исправлять production-контейнеры, потому что «не понял границ».

Базовая структура навыка выглядит так:

yaml
# ~/.ecc/skills/caveman.yaml
name: caveman
version: 1.0
triggers:
  - pattern: "reduce tokens"
  - pattern: "optimize context"
  - pattern: "minimal output"
actions:
  - type: filter
    target: output
    rules:
      - max_tokens: 500
      - remove_whitespace: true
      - compress_similar: true
constraints:
  - allow_docker: false
  - allow_network: false
  - max_execution_time: 30s

Инстинкты работают на уровне приоритетов. Они не дают агенту уйти в сторону:

json
{
  "instincts": {
    "security_first": {
      "priority": 100,
      "conditions": ["file_write", "production_path"],
      "action": "require_confirmation"
    },
    "token_economy": {
      "priority": 80,
      "conditions": ["output_size > 1000"],
      "action": "trigger_skill:caveman"
    }
  }
}

Рекомендуется тестировать новые навыки в изоляции. Я обычно создаю отдельный профиль для экспериментов:

bash
# Создаём тестовую среду
mkdir -p ~/.ecc/test-env/{skills,instincts,cache}
cp ~/.ecc/skills/caveman.yaml ~/.ecc/test-env/skills/

# Запуск с тестовым профилем
ECC_PROFILE=test-env claude-code --task "оптимизировать этот скрипт"

Настоящий совет: начните с минимального набора навыков. Добавляйте по мере необходимости. Каждый новый навык — это поверхность для атаки на ваш процесс.

### Система краткосрочной и долгосрочной памяти

ECC разделяет память на два уровня: краткосрочную (context window) и долгосрочную (persistent storage). Это не просто кеширование — это управление состоянием.

Краткосрочная память работает через sliding window с весами:

python
# Пример весового управления контекстом
class ContextManager:
    def __init__(self):
        self.window_size = 10  # последние 10 взаимодействий
        self.weights = {
            'current_task': 1.0,
            'recent_errors': 0.8,
            'user_corrections': 0.9,
            'irrelevant_chat': 0.1
        }
    
    def compress_context(self, interactions):
        # Сжатие с сохранением ключевых деталей
        return self.summarize(interactions, self.weights)

Для долгосрочной памяти ECC использует структуру типа knowledge graph:

yaml
# ~/.ecc/memory/project-knowledge.yaml
entities:
  - name: "auth-service"
    type: "service"
    properties:
      port: 8080
      framework: "FastAPI"
      last_modified: "2026-07-15"
    relationships:
      - depends_on: "postgres-db"
      - calls: "user-service"

patterns:
  - name: "jwt-validation"
    context: "auth-service"
    solution: |
      # Стандартный паттерн валидации JWT
      # Использовать RS256, проверять issuer и audience
      # Никогда не доверять client-data

Настоящий кейс из практики: в одном проекте я настроил ECC так, чтобы он автоматически сохранял решения проблем в долгосрочную память. Через три месяца агент начал предлагать готовые решения для новых задач, опираясь на прошлый опыт. Это сэкономило 40% времени на рутине.

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

bash
# Очистка памяти старше 90 дней
ecc-memory --cleanup --older-than 90d --confirm

# Аудит содержимого памяти
ecc-memory --audit --output-format json > memory-audit.json

Категорически не рекомендую хранить в долгосрочной памяти:

Персональные данные пользователей
Секреты и credentials
Любые данные, которые могут измениться

Для защиты используйте шифрование:

bash
# Включить шифрование памяти
ecc-config --set memory.encryption.enabled=true
ecc-config --set memory.encryption.algorithm=aes-256-gcm

Чеклист

Создать минимальный набор навыков (не более 5 базовых)
Настроить инстинкты безопасности с высшим приоритетом
Включить шифрование долгосрочной памяти
Протестировать новые навыки в изолированном профиле
Настроить автоматическую очистку памяти старше 90 дней
Запустить первый аудит памяти командой ecc-memory --audit
Проверить, что навыки не имеют доступа к production-путям
Установить лимиты на размер контекста (рекомендую 2000 токенов максимум)

Безопасность выполнения AI-агентов

Изоляция процессов и контейнерization

С точки зрения безопасности процесс AI‑агента должен запускаться в полностью изолированном окружении.
Типовая ошибка — запускать агент с привилегиями root в production.

Рекомендации:

настоятельно рекомендуется использовать контейнер с non‑root пользователем;
категорически не рекомендуется запускать контейнер с флагом --privileged;
рекомендуется монтировать файловую систему в режиме read‑only;
рекомендуется применять профиль seccomp, ограничивающий системные вызовы.

Пример Dockerfile для агента:

Dockerfile
# Dockerfile
FROM python:3.12-slim

# Создаём системного пользователя
RUN adduser --system --group --no-create-home agent

# Рабочая директория
WORKDIR /opt/agent
COPY . .

# Изменяем владельца
RUN chown -R agent:agent /opt/agent

# Переключаемся на non‑root пользователя
USER agent

Запуск контейнера с ограничениями:

bash
docker run --rm \
  --security-opt seccomp=./seccomp-profile.json \
  --read-only \
  --tmpfs /tmp:rw,noexec,nosuid,size=64M \
  -e OPENAI_API_KEY=YOUR_KEY \
  ecc-agent:latest

Предупреждение: если не задать --read-only, процесс сможет модифицировать свои файлы и потенциально загрузить вредоносный код.

Для более лёгкого изолирования можно использовать firecracker или podman с опцией --cap-drop ALL.

Контроль доступа к файловой системе и сети

Контроль доступа реализуется на уровне ОС: AppArmor, seccomp, Linux‑capabilities и сетевые namespaces.

Пример systemd‑unit с ограничениями:

ini
[Unit]
Description=AI Agent Service
After=network.target

[Service]
ExecStart=/usr/local/bin/ecc-agent
User=agent
Group=agent
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=full
ProtectHome=true
CapabilityBoundingSet=CAP_NET_RAW CAP_DAC_READ_SEARCH
ReadOnlyDirectories=/opt/agent
RestrictAddressFamilies=AF_INET AF_INET6

Сетевая изоляция:
Для минимизации атакуемой поверхности лучше полностью отключить сеть и открывать только необходимые порты через файрвол.

Пример iptables‑правил (nftables‑аналог аналогичен):

bash
# Разрешаем только HTTPS и DNS
iptables -A OUTPUT -p tcp --dport 443 -j ACCEPT
iptables -A OUTPUT -p udp --dport 53 -j ACCEPT

# Блокируем всё остальное
iptables -A OUTPUT -j DROP

Пример создания сетевого namespace:

bash
ip netns add ecc_ns
ip netns exec ecc_ns ip link set lo up
ip netns exec ecc_ns ip addr add 10.10.10.2/24 dev lo
ip netns exec ecc_ns ip route add default via 10.10.10.1
ip netns exec ecc_ns ./ecc-agent

На практике я видел случай когда агент, запущенный без --network none, смог выполнить DNS‑запросы к внешним резолверам и выгрузить конфиденциальные данные.

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

ECC: оптимизация агентных оболочек для Claude Code и анал...
Установка и настройка caveman — skill для сокращения токенов Claude Code
Оптимизация производительности агентного хранилища ECC

Запустить агент в non‑root контейнере с read‑only файловой системой
Ограничить набор возможностей через seccomp и CapabilityBoundingSet
Включить PrivateTmp и ProtectSystem в systemd‑unit
Настроить сетевой изолятор (iptables/nftables) и разрешить только необходимые порты
Включить аудит (auditd) и отслеживать вызовы execve, open
Проверить, что нет открытых привилегированных портов
Регулярно обновлять профили seccomp и AppArmor

Ссылка на общие рекомендации по безопасности контейнеров: Docker security best practices

Оптимизация ресурсов и производительности

Управление потреблением памяти и CPU

AI-агенты — это звери, которые без контроля быстро съедают всё доступное ОЗУ и CPU. На практике я видел случай, когда Claude Code простоял на 12 ГБ RAM из-за неоптимального контекста. Решение простое, но требует внимания к деталям.

Ограничение контекстного окна

Первое, что проверяй — размер контекста. Claude Code использует последние 200 КБ кода по умолчанию, но в больших проектах это может вырасти до необъятного. Настраиваем .claude/settings.json:

json
{
  "context_window": 50000,
  "max_file_size": "1MB",
  "exclude_patterns": [
    "node_modules/**",
    "*.log",
    ".git/**",
    "dist/**",
    "**/*.min.js"
  ]
}

Файл .claudeignore — ваш первый щит

Создай .claudeignore в корне проекта. Это работает как .gitignore, но для AI-агента:

# Бинарники и артефакты
*.pyc
*.so
*.dll
.git/

# Логи и временные файлы
*.log
tmp/
.cache/

# Большие данные
data/*.csv
models/
weights/

Контроль CPU через systemd

Запускаешь агента как сервис? Ограничь ресурсы явно. Unit-файл для systemd:

ini
[Unit]
Description=Claude Code Agent
After=network.target

[Service]
Type=simple
User=claude
ExecStart=/usr/local/bin/claude-code --agent-mode
CPUQuota=50%
MemoryMax=2G
MemorySwapMax=0
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

Применяй: systemctl daemon-reload && systemctl restart claude-agent.

Мониторинг в реальном времени

Запусти htop в отдельной вкладке и следи за процессами claude, node, python. Если видишь рост памяти >100 МБ/минуту — это тревожный сигнал.

Кеширование результатов и предварительная обработка

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

Настройка кеша выполнения команд

Создаем директорию для кеша:

bash
mkdir -p /var/cache/ecc/agent-results
chmod 750 /var/cache/ecc/agent-results

Конфигурация кеша в ECC (ecc-config.yaml):

yaml
cache:
  enabled: true
  backend: "file"  # или redis://localhost:6379
  ttl: "24h"
  max_size: "10GB"
  compression: true
  paths:
    - "/var/cache/ecc/agent-results"
    - "./.ecc-cache"

preprocessing:
  enabled: true
  batch_size: 10
  parallel_jobs: 4

Пример: кеширование результатов анализа кода

Вместо повторного запуска eslint на каждый запрос:

bash
# Первоначальный запуск с кешем
ecc-cache put "eslint-$(git rev-parse HEAD)" $(eslint src/ --format json)

# Проверка кеша перед выполнением
if ecc-cache exists "eslint-$(git rev-parse HEAD)"; then
    echo "Используем кешированный результат"
    ecc-cache get "eslint-$(git rev-parse HEAD)"
else
    eslint src/ --format json | ecc-cache put "eslint-$(git rev-parse HEAD)" -
fi

Предварительная обработка файловой системы

ECC умеет предобрабатывать файлы перед передачей агенту. Настройка в skills/fs-preprocess.yaml:

yaml
skill: fs-preprocess
triggers:
  - "analyze codebase"
  - "review changes"
actions:
  - type: "filter"
    exclude: ["*.test.js", "docs/**", "examples/**"]
  - type: "compress"
    algorithm: "gzip"
    threshold: "100KB"
  - type: "chunk"
    max_lines: 500
    overlap: 50

Практический совет: инвалидация кеша

Не забывай про инвалидацию. Добавь хук в git:

bash
# .git/hooks/post-commit
#!/bin/bash
# Инвалидируем кеш после коммита
find .ecc-cache -type f -mtime +1 -delete

Проверка эффективности

После настройки кеширования запусти:

bash
# Статистика кеша
ecc-cache stats

# Топ используемых ключей
ecc-cache top --limit 10

Если видишь cache hit rate ниже 60% — значит, кеш не работает эффективно. Проверь TTL и ключи.

Чеклист:

Создан .claudeignore с исключениями для больших файлов и артефактов
Настроен CPUQuota и MemoryMax в systemd-юните
Инициализирован кеш-бэкенд (file или redis)
Добавлены скрипты инвалидации кеша в git-хуки
Запущен мониторинг потребления ресурсов через htop/iotop
Проверен cache hit rate через ecc-cache stats

Интеграция с инструментами разработки

ECC работает как middleware между AI-агентом и вашими инструментами. На практике это выглядит так: агент запрашивает действие, ECC оптимизирует запрос через навыки и кеширует результат. Дальше — детали.

Поддержка Claude Code, Codex и OpenCode

Claude Code — это уже не экспериментальная фича, а production-инструмент. Ключевой момент: ECC не требует патчить сам Claude Code. Достаточно настроить обёртку.

Пример конфигурации для Claude Code:

yaml
# ~/.ecc/integrations/claude-code.yaml
integration:
  name: claude-code
  enabled: true
  memory_limit_mb: 512
  token_optimization:
    enabled: true
    aggressive_mode: false
  skills:
    - code-analysis
    - pattern-recognition
    - context-compression
  
hooks:
  pre_process: |
    #!/bin/bash
    echo "ECC: анализ запроса..." >&2
    ecc-context-analyzer "$1"
  
  post_process: |
    #!/bin/bash
    echo "ECC: кеширование результата..." >&2
    ecc-cache-store "$1" "$2"

Codex и OpenCode используют схожую схему. Разница в том, что Codex умеет работать с GitHub API напрямую — это нужно учитывать при настройке rate limiting:

yaml
# ~/.ecc/integrations/opencode.yaml
integration:
  name: opencode
  github_rate_limit:
    requests_per_minute: 30
    burst: 5
  skills:
    - api-optimization
    - response-caching

Типовая ошибка: ставить aggressive_mode: true в продакшене. На тесте это выглядит круто, но в реальной работе вы получите обрезанные ответы там, где их не должно быть. Настоятельно рекомендуется тестировать каждый skill отдельно через ecc-skill-test.

Настройка под Cursor и другие IDE

Cursor — это IDE с встроенным AI. Интеграция через ECC выглядит иначе: мы работаем на уровне расширений.

json
// .vscode/extensions/ecc-cursor/package.json
{
  "name": "ecc-cursor-bridge",
  "contributes": {
    "commands": [
      {
        "command": "ecc.optimizeContext",
        "title": "Оптимизировать контекст через ECC"
      }
    ],
    "configuration": {
      "properties": {
        "ecc.memoryProfile": {
          "type": "string",
          "default": "balanced",
          "enum": ["minimal", "balanced", "full"]
        }
      }
    }
  }
}

Для JetBrains IDE:

xml
<!-- .idea/ecc-plugin.xml -->
<project version="4">
  <component name="eccSettings">
    <option name="agentTimeout" value="30000" />
    <option name="cacheStrategy" value="lru" />
    <option name="skillsPath" value="$HOME/.ecc/jetbrains-skills" />
  </component>
</project>

Не делайте так: кладите конфиги прямо в директорию проекта без .gitignore. На практике я видел случай, когда команда случайно закоммитила токены в репозиторий через кастомный skill. Результат: инцидент с 4-часовым downtime.

Для Vim/Neovim:

lua
-- lua/plugins/ecc.lua
return {
  "greyhat/ecc-nvim",
  opts = {
    agents = {
      claude = { 
        cmd = "claude-code",
        args = { "--ecc-integration" }
      },
      opencode = {
        cmd = "opencode",
        args = { "--with-cache" }
      }
    }
  }
}

Проверьте работу интеграции командой:

bash
# Тестируем подключение к агенту
ecc-integration-test --agent claude-code --verbose

# Проверяем latency
ecc-benchmark --iterations 100 --agent all

Связанные материалы:

Чеклист после настройки интеграции

Проверил ecc-integration-test для каждого агента
Настроил rate limiting для GitHub API (если используется Codex/OpenCode)
Протестировал skills в изоляции через ecc-skill-test
Добавил конфиги в .gitignore (если они содержат секреты)
Запустил benchmark и сравнил latency до/после
Настроил мониторинг: ecc-metrics --watch
Проверил, что aggressive_mode выключен в продакшене
Убедился, что кеш хранится на encrypted partition

Часто задаваемые вопросы

Что такое ECC и как он решает проблему «безумия токенов»?

ECC — это система управления поведением AI-агентов через навыки, инстинкты и ограничения. Проблема «безумия токенов» проявляется, когда агенты неконтролируемо расходуют токены на повторяющиеся операции и хранение избыточного контекста. С точки зрения безопасности, ECC работает как firewall: он ограничивает действия агента и заставляет его экономить ресурсы. На практике я видел случай, когда без такого контроля один агент превратил 500-километровый запрос в 200-километровый nightmare за сутки.

Какие AI-агенты поддерживает ECC?

Система поддерживает Claude Code, Codex, Opencode и Cursor — это агенты, которые работают с локальным кодом и могут выполнять действия в файловой системе. Категорически не рекомендуется использовать ECC с агентами, которые никогда не выходили в production, потому что поведение может быть непредсказуемым. Перед внедрением проверьте, что выбранный агент поддерживает управление контекстом через внешние конфигурации.

Как правильно настроить навыки для AI-агента без риска для production?

Никогда не включайте новые навыки в production-среде сразу после создания. Настоятельно рекомендуется создавать отдельный тестовый профиль и проверять навыки на небольшом коде. Ключевой принцип: ограничения должны быть жесткими — allow_docker: false, allow_network: false, max_execution_time: 30s. Типовая ошибка — дать агенту слишком широкие права, чтобы «не мешать работе», но на практике это приводит к случайным изменениям в продакшене.

Как работают инстинкты и как настроить приоритеты?

Инстинкты — это правила приоритетов, которые переключают навыки в зависимости от условий. Например, security_first с приоритетом 100 будет переключён при попытке записи в production-путь, тогда как token_economy (приоритет 80) сработает при большом объёме вывода. Рекомендуется начинать с высоких приоритетов для безопасности и постепенно добавлять экономические правила. Не делайте так: ставьте все приоритеты одинаковыми — агент будет вести себя непредсказуемо.

Какие риски управления памятью и как их избежать?

Главный риск — утечка конфиденциальных данных через контекст. Если агент хранит в памяти данные из production-окружения, они могут попасть в обучающие выборки или логи. Настоятельно рекомендуется использовать отдельные профили для разных окружений и очищать контекст после работы с sensitive данными. Перед выполнением любого действия проверьте, что путь назначения не содержит production-данных, иначе последствия могут быть серьёзными.