Продвинутый

Как сделать AI‑агент, как ленивый старший разработчик

Алексей Кузнецов
Алексей Кузнецов
Системный администратор22 ноября 2026 г.12 мин чтения

Узнайте, как настроить AI‑агент, который работает как ленивый старший разработчик: минимум кода, максимум предсказуемости и надёжной автоматизации.

Как сделать AI‑агент, как ленивый старший разработчик

Узнайте, как настроить AI‑агент, который работает как ленивый старший разработчик: минимум кода, максимум предсказуемости и надёжной автоматизации.

Принцип ленивого разработчика в AI‑агенте

Принцип ленивого разработчика в AI‑агенте

Во-первых, ленивый разработчик — это тот, кто ставит цель минимизировать количество ручных запросов к AI, передавая агентом задачи, которые повторяются часто. Вместо того чтобы каждый раз вручную писать конфиги, команды или скрипты, вы формулируете запрос once и получаете готовый результат.

Например, вместо того чтобы вручную составлять docker‑compose.yml для трёх сервисов, скажите агенту:

yaml
version: "3.9"
services:
  api:
    image: python:3.11
    ports:
      - "8000:8000"
    volumes:
      - ./api:/app
  db:
    image: postgres:15
    environment:
      POSTGRES_PASSWORD: secret
    volumes:
      - db_data:/var/lib/postgresql/data
  worker:
    image: python:3.11
    command: celery -A tasks worker --loglevel=info
    volumes:
      - ./worker:/app
volumes:
  db_data:

Orca: запуск флота ботов с собственной подпиской — один из способов запустить автономные боты, которые могут принимать такие запросы и выполнять их без вашего постоянного участия.

С помощью Claude Code вы можете привязать к запросу файл конфигурации, а агент сам откроет его, внесёт изменения и сохранит, что исключает необходимость открывать редактор вручную.


Минимизация рутинных запросов

Ленивый подход подразумевает, что агент берёт на себя повторяющиеся запросы: генерацию кода, правку конфигурационных файлов, создание резервных копий и т.п. При этом важно, чтобы запрос был чётко сформулирован, а контекст (файлы, окружение) был передан полностью.

Пример: запрос на создание скрипта для автоматического бэкапа Nextcloud data на TrueNAS.

bash
#!/usr/bin/env bash
# backup-nextcloud.sh – создаёт снимок базы и копирует данные на TrueNAS

set -euo pipefail

# 1. Экспорт базы данных
docker exec nextcloud-db pg_dump -U www-data nextcloud > /tmp/nextcloud.sql

# 2. Сжатие файла
gzip -c /tmp/nextcloud.sql > /tmp/nextcloud.sql.gz

# 3. Копирование на TrueNAS (путь //truenas/backups/nextcloud)
rsync -av --progress /tmp/nextcloud.sql.gz //truenas/backups/nextcloud/

Сохраните файл, сделайте его исполняемым (chmod +x backup-nextcloud.sh) и добавьте в systemd‑таймер, чтобы он запускался каждый день в 02:00. Агент может автоматически сформировать unit‑файлы и таймер, если вы укажете нужный график.

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


Автоматизация повторяющихся задач

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

  • генерацию и поддержание cron‑задач;
  • настройку systemd‑таймеров;
  • создание и обновление скриптов, отвечающих за рутинные операции.

Пример: автоматизация очистки старых логов в journald с помощью systemd‑таймера.

ini
# /etc/systemd/system/clear-journald-logs.timer
[Unit]
Description=Очистка старых журналов systemd

[Timer]
OnCalendar=daily
Persistent=true

[Install]
WantedBy=timers.target
ini
# /etc/systemd/system/clear-journald-logs.service
[Unit]
Description=Удаление журналов старше 7 дней

[Service]
Type=oneshot
ExecStart=/usr/bin/journalctl --vacuum-time=7d

После размещения файлов выполните:

bash
sudo systemctl daemon-reload
sudo systemctl enable --now clear-journald-logs.timer

Агент, зная структуру systemd, может подготовить эти файлы за вас, а вам остаётся лишь проверить их наличие и активировать.

Для повышения эффективности работы агента в таких задачах полезно изучить подходы, описанные в affaan-m/ECC: Оптимизация производительности агента и affaan-m/ECC: Agent Harness Performance Optimization. Они показывают, как правильно формировать запросы, чтобы минимизировать накладные расходы и ускорить выполнение.


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

Конфигурация и развертывание полной AI‑агента

Конфигурация и развертывание AI-агента

Когда мы говорим об AI-агенте, который должен работать автономно, мы фактически проектируем новую программную сущность. Если вы планируете запускать его на своём оборудовании, важно сразу заложить фундамент, который не позволит агенту превратить вашу систему в хаос. С практической точки зрения, агент — это не просто скрипт, это процесс с неопределённым поведением. Чтобы это поведение не стало разрушительным, нам нужна изоляция и чёткие инструкции.

Использование Docker Compose для изоляции

Запускать агента напрямую в основной операционной системе — плохая идея. Даже если вы доверяете модели, ошибки в логике или неверная интерпретация команды могут привести к удалению важных данных или изменению системных конфигов. Я всегда придерживаюсь принципа предсказуемости: агент должен жить в своей «песочнице».

Docker Compose — это отличный инструмент, чтобы упаковать агента, его окружение и необходимые зависимости в единый, воспроизводимый стек. Это похоже на то, как мы разворачиваем микросервисы: всё изолировано, версии зафиксированы, а взаимодействие с внешним миром строго ограничено.

Для начала создадим базовый docker-compose.yml. В качестве примера возьмём контейнер, где будет развёрнут агент с доступом к локальному API.

yaml
services:
  ai-agent:
    image: python:3.11-slim # Используем минимальный образ для уменьшения поверхности атаки
    container_name: agent-worker
    volumes:
      - ./workspace:/app/workspace # Рабочая директория, где агент будет писать код
      - ./config:/app/config       # Конфигурационные файлы
    environment:
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
      - WORKSPACE_PATH=/app/workspace
    working_dir: /app
    restart: unless-stopped # Чтобы агент поднимался сам после сбоя или перезагрузки сервера
    networks:
      - agent-net

networks:
  agent-net:
    driver: bridge

При таком подходе, даже если агент решит выполнить команду rm -rf /, он удалит файлы только внутри контейнера. Чтобы повысить уровень безопасности, я рекомендую ограничить права пользователя внутри Dockerfile, не работая под root.

Перед запуском убедитесь, что у вас создан файл .env с вашим ключом доступа, иначе контейнер не сможет авторизоваться в сервисах Anthropic:

bash
# Создаем файл окружения
echo "ANTHROPIC_API_KEY=your_actual_key_here" > .env
# Запускаем стек
docker compose up -d

Если вы планируете масштабировать систему и запускать несколько агентов параллельно, стоит обратить внимание на оптимизацию производительности агента, чтобы избежать конфликтов ресурсов на вашей домашней лаборатории.

Настройка prompt-engineering

Если Docker — это стены вашей лаборатории, то системный промпт — это должностная инструкция сотрудника. «Ленивый старший разработчик» — это не про нежелание работать, а про стремление к автоматизации и минимизации ручного труда. Чтобы добиться такого поведения, промпт должен задавать не только роль, но и жесткие ограничения.

С точки зрения системного инженера, промпт — это конфигурационный файл. Если он написан плохо, система будет вести себя нестабильно. Я рекомендую использовать структурированный подход, разделяя инструкции на блоки: роль, контекст, инструменты и правила безопасности.

Пример эффективного системного промпта для агента, работающего через claude-code:

text
Role: Senior Software Engineer (Automation Focused)

Context: You are an autonomous agent operating within a restricted Docker container. 
Your goal is to solve tasks with maximum predictability and minimum manual intervention.

Operational Rules:
1. Write modular, testable code.
2. Always verify your changes by running tests or checking logs.
3. If a task is repetitive, write a script to automate it instead of doing it manually.
4. Do not attempt to modify system files outside of /app/workspace.
5. If you encounter an error, analyze the root cause before attempting a fix.

Output Format:
- Provide a brief summary of what you did.
- List the files changed.
- Provide the command used to verify the result.

Почему это работает? Во-первых, мы явно ограничиваем область видимости (директория /app/workspace). Во-вторых, мы задаём алгоритм действий при ошибке: «анализ причины, а не слепое исправление». Это именно то, что отличает опытного инженера от новичка.

Для более глубокого понимания того, как правильно выстраивать логику взаимодействия с моделями, можно изучить материалы по оптимизации Agent Harness.

Помните: чем точнее вы опишете границы дозволенного, тем более предсказуемым будет результат. А предсказуемость — это главное, что мы ищем в автоматизации.

Мониторинг и системный мониторинг предсказуемости

Мониторинг и системный мониторинг предсказуемости

Когда вы делегируете выполнение задач AI-агенту, вы по сути нанимаете нового сотрудника. Но в отличие от человека, агент не пришлёт сообщение в Slack с вопросом: «Я застрял, что делать?». Он либо молча продолжит тратить ваши токены впустую, либо уйдет в бесконечный цикл, пытаясь исправить одну и ту же ошибку.

С практической точки зрения, мониторинг агента — это не проверка того, «умный» он или нет. Это контроль его предсказуемости. Нам нужно понимать, насколько эффективно он использует ресурсы, не деградирует ли его логика со временем и не начал ли он «галлюцинировать» в сторону бесконечных вызовов API. Если вы строите сложную систему, где агенты взаимодействуют друг с другом, стоит заранее изучить подходы к оптимизации производительности агента, чтобы мониторинг не превратился в сбор бесполезного шума.

Системный мониторинг с Prometheus

Для контроля за состоянием агента я использую классический стек Prometheus + Grafana. Если ваш агент работает в Docker-контейнере, мониторить нужно не только загрузку CPU и RAM, но и специфические метрики самого процесса: количество выполненных шагов (steps), расход токенов за сессию и время ответа (latency) от LLM.

Чтобы это работало, агент должен экспортировать метрики. Самый надёжный способ — поднять небольшой sidecar-контейнер или использовать библиотеку prometheus_client прямо в коде агента.

Пример того, как может выглядеть конфигурация prometheus.yml для сбора метрик с вашего агента:

yaml
scrape_configs:
  - job_name: 'ai-agent'
    scrape_interval: 15s
    static_configs:
      - targets: ['agent-service:8000'] # Адрес, где агент отдает метрики

В самом коде агента (например, на Python) важно фиксировать не только успех, но и «стоимость» каждого действия. Это позволяет увидеть аномалии: если среднее количество токенов на один шаг внезапно выросло в три раза, значит, агент попал в цикл или начал писать слишком многословные промпты.

Алерты и логирование

Мониторинг без алертинга — это просто красивая картинка в Grafense. Если агент начинает вести себя непредсказуемо, вы должны узнать об этом раньше, чем увидите пустой баланс на аккаунте Anthropic или OpenAI.

Я разделяю алерты на два типа:

  1. Инфраструктурные: упал контейнер, закончилось место на диске, превышен лимит памяти. Это стандарт.
  2. Поведенческие: агент совершил более 10 попыток исправления одной и той же ошибки подряд или стоимость одной сессии превысила установленный порог (например, 5 $).

Для логирования я рекомендую использовать структурированный подход (JSON). Обычный текстовый лог бесполезен, когда нужно быстро отфильтровать цепочку рассуждений (reasoning chain) конкретного агента.

Пример правильного лога в формате JSON, который легко переварит любой сборщик логов:

json
{
  "timestamp": "2023-10-27T14:20:01.123Z",
  "level": "ERROR",
  "agent_id": "vinnie-pukh-01",
  "session_id": "abc-123-xyz",
  "step": 4,
  "action": "tool_use",
  "tool": "bash_execute",
  "error": "Permission denied",
  "tokens_used": 450,
  "reasoning": "Attempting to fix file permissions after previous failure."
}

Если вы планируете масштабировать систему до целого флота автономных единиц, принципы мониторинга становятся ещё критичнее. В этом случае важно не просто смотреть на одного агента, а анализировать корреляции между ними, что подробно разбирается в материалах про запуск флота ботов.

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

Оптимизация кода и избавление от избыточных запросов

### Кеширование результатов

Кеширование позволяет избежать повторных запросов к модели и тем самым уменьшить задержки и расходы. Самый простой способ — сохранять результат в файле, а при повторном запросе проверять, есть ли уже запись.

bash
# вычисляем хеш запроса (пример для bash)
QUERY="SELECT * FROM users WHERE status = 'active'"
HASH=$(echo -n "$QUERY" | sha256sum | cut -d' ' -f1)
python
# пример кэширования в Python (файл cache.json)
import json, hashlib, os

CACHE_FILE = "cache.json"

def cache_key(query: str) -> str:
    return hashlib.sha256(query.encode('utf-8')).hexdigest()

def get_cached(query: str):
    key = cache_key(query)
    if key in CACHE_FILE:
        with open(CACHE_FILE, "r", encoding="utf-8") as f:
            return json.load(f)[key]
    return None

def set_cached(query: str, result):
    key = cache_key(query)
    data = {}
    if os.path.exists(CACHE_FILE):
        with open(CACHE_FILE, "r", encoding="utf-8") as f:
            data = json.load(f)
    data[key] = result
    with open(CACHE_FILE, "w", encoding="utf-8") as f:
        json.dump(data, f, ensure_ascii=False, indent=2)

Для более масштабного решения удобно использовать Redis. Ниже пример docker‑compose.yml, который поднимает один контейнер Redis 6:

yaml
version: "3.8"
services:
  redis:
    image: redis:6-alpine
    restart: unless-stopped
    ports:
      - "6379:6379"
python
# пример работы с Redis (redis-py)
import redis, json

r = redis.Redis(host="localhost", port=6379, db=0, decode_responses=True)

def cached_redis(query: str, ttl: int = 3600):
    key = f"cache:{hashlib.sha256(query.encode()).hexdigest()}"
    cached = r.get(key)
    if cached:
        return json.loads(cached)
    return None

def set_redis(query: str, result, ttl: int = 3600):
    key = f"cache:{hashlib.sha256(query.encode()).hexdigest()}"
    r.setex(key, ttl, json.dumps(result, ensure_ascii=False))

В реальной практике я обычно комбинирую оба подхода: часто‑используемые запросы (например, запрос списка файлов) кеширую в Redis, а редкие — в файле. Это позволяет сбалансировать скорость доступа и объём хранимых данных.

Смотрите, как в проектах типа Orca и affaan-m/ECC реализованы стратегии кэширования: они используют как локальные файлы, так и внешние хранилища, чтобы минимизировать количество обращений к модели.

Объединение запросов в единый контекст

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

bash
# формируем единый запрос из списка задач (bash)
TASKS=(
  "Получить список всех Docker‑контейнеров"
  "Посчитать размер диска, занятый TrueNAS"
  "Вывести последние 10 строк журнала systemd"
)

QUERY=$(printf "%s\n" "${TASKS[@]}" | sed ':a;N;$!ba;s/\n/\\n/g')
echo "$QUERY"
yaml
# пример конфигурационного файла (yaml) с несколькими запросами
tasks:
  - description: "Список Docker‑контейнеров"
    command: "docker ps --format 'table {{.Names}}\t{{.Status}}'"
  - description: "Размер TrueNAS"
    command: "df -h /mnt/trueNAS"
  - description: "Логи systemd"
    command: "journalctl -n 10 --no-pager"

Вместо того чтобы посылать три отдельных запроса, я формирую один контекст, где указаны все задачи и их параметры. Модель затем отвечает на каждый пункт в одном ответе, а я просто паршу результат.

python
# пример объединения запросов в Python
tasks = [
    {"desc": "Список Docker‑контейнеров", "cmd": "docker ps --format 'table {{.Names}}\t{{.Status}}'"},
    {"desc": "Размер TrueNAS", "cmd": "df -h /mnt/trueNAS"},
    {"desc": "Логи systemd", "cmd": "journalctl -n 10 --no-pager"},
]

context = "\n".join([f"{t['desc']}: {t['cmd']}" for t in tasks])
# отправляем `context` в модель и получаем ответы по порядку

Такой подход используется в affaan-m/ECC: Agent Harness Performance Optimization – авторы показывают, что сокращение количества запросов до одного уменьшает среднее время ответа на 30 % при том же объёме токенов.

В итоге, кеширование и объединение запросов — два взаимодополняющих приёма, которые позволяют сделать AI‑агент более «ленивым», но при этом сохранять предсказуемость и надёжность. Применяйте их в своей лаборатории, и количество лишних запросов к модели резко упадёт.

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

Как указать контекст, чтобы агент знал, какие файлы менять?

Чтобы агент корректно понял, какие файлы нужно изменить, передайте ему полный путь к файлу и, при необходимости, его содержимое в запросе. Укажите, какие секции или строки требуется отредактировать, а не просто «изменить конфиг». Это позволяет избежать неоднозначностей и гарантирует, что изменения будут применены именно там, где вы ожидаете.

Может ли агент автоматически генерировать docker‑compose.yml?

Да, агент может автоматически генерировать docker‑compose.yml, если в запросе явно перечислены сервисы, их образы, порты и тома. Однако после получения yaml рекомендуется проверить его содержимое в редакторе перед применением, чтобы убедиться в отсутствии опечаток. При правильном описании агент создаёт файл без необходимости открывать его вручную.

Что делать, если агент вносит неверные изменения?

Если агент вносит неверные изменения, лучше использовать систему контроля версий, например Git, и проверять дифф перед слиянием. Также можно добавить в запрос проверку idempotентности, чтобы при повторном запуске не было дублирования. В случае критических ошибок откатите изменения через резервную копию или историю коммитов.

Как обеспечить предсказуемую работу агента при разных запусках?

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

Поделиться:TelegramX / TwitterVK

Читайте также