Продвинутый

Ultraworkers Claw‑Code: Rust museum exhibit, autonomous a...

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

Руководимый агентом музейный экспонат, написанный на Rust с Gajae‑Code/LazyCodex, полностью автономен и поддерживается без вмешательства человека.

Ultraworkers Claw‑Code: Rust museum exhibit, autonomous agent

Руководимый агентом музейный экспонат, написанный на Rust с Gajae‑Code/LazyCodex, полностью автономен и поддерживается без вмешательства человека.

Архитектура и технологии

Rust‑основа

Во-первых, Rust обеспечивает память безопасность без сборщика мусора, что критично для автономного агента, работающего 24 × 7. Компилятор проверяет типы на этапе сборки, поэтому типичные ошибки, такие как обращение к освобождённой памяти, невозможны. Пример базовой структуры агента выглядит так:

rust
// src/agent.rs
use std::sync::Arc;
use tokio::sync::Mutex;

#[derive(Clone, Debug)]
pub struct Agent {
    pub config: Arc<Mutex<AgentConfig>>,
}

impl Agent {
    pub async fn new(config: AgentConfig) -> Self {
        Self {
            config: Arc::new(Mutex::new(config)),
        }
    }

    pub async fn run(&self) {
        let cfg = self.config.lock().await;
        // основной цикл работы агента
        loop {
            // выполнение задач, чтение метрик и т.д.
            tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
        }
    }
}

Для сборки используется Cargo:

bash
cargo build --release

После получения бинарника его удобно запускать через systemd‑unit, чтобы обеспечить автозапуск и мониторинг:

ini
# /etc/systemd/system/claw-agent.service
[Unit]
Description=Ultraworkers Claw‑Code autonomous agent
After=network.target

[Service]
ExecStart=/opt/claw-agent/target/release/claw-agent
Restart=always
User=claw
Group=claw
Environment=RUST_LOG=info

[Install]
WantedBy=multi-user.target
bash
sudo systemctl daemon-reload
sudo systemctl enable claw-agent.service
sudo systemctl start claw-agent.service

Gajae‑Code/LazyCodex

Gajae‑Code — это доменно‑специфический язык, построенный поверх Rust, позволяющий описать поведение агента в декларативном виде. LazyCodex добавляет ленивую оценку, благодаря чему агент может отложить выполнение тяжёлых операций до момента их реального потребления. Пример конфигурации модуля выглядит так:

yaml
# config/lazy_modules.yaml
modules:
  - name: "photo_processor"
    depends_on: ["image_loader"]
    lazy: true
    tasks:
      - "resize"
      - "watermark"

В коде модуль объявляется так:

rust
// src/modules.rs
use gajae_code::prelude::*;

#[derive(Debug, Clone)]
pub struct PhotoProcessor {
    pub input: Arc<Mutex<ImageSource>>,
    pub output: Arc<Mutex<Vec<u8>>>,
}

impl PhotoProcessor {
    pub async fn new(input: ImageSource) -> Self {
        Self {
            input: Arc::new(Mutex::new(input)),
            output: Arc::new(Mutex::new(Vec::new())),
        }
    }

    pub async fn run(&self) {
        let img = self.input.lock().await.read().await;
        let resized = img.resize(1920, 1080);
        let watermarked = resized.add_watermark("© AlexK".as_bytes());
        self.output.lock().await.push(watermarked);
    }
}

Для развертывания в контейнере удобно использовать Docker‑file, где lazy‑модули подключаются как отдельные слои:

dockerfile
# Dockerfile
FROM rust:1.78 as builder
WORKDIR /app
COPY . .
RUN cargo build --release

FROM debian:bullseye-slim
COPY --from=builder /app/target/release/claw-agent /opt/claw-agent/
RUN useradd -m -u 1000 claw
USER claw
EXPOSE 8080
CMD ["/opt/claw-agent/claw-agent"]

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

Автономное управление

Автономное управление

Когда мы говорим об автономности в контексте Ultraworkers Claw‑Code, важно понимать: это не просто скрипт, который крутится в бесконечном цикле. Это система, которая самостоятельно принимает решения на основе входящих сигналов. Если сравнивать с классической автоматизацией, то обычный cron-job — это расписание поездов, а Claw‑Code — это беспилотный автомобиль, который сам решает, как объехать препятствие.

С практической точки зрения, предсказуемость такой системы обеспечивается за счёт жесткой типизации Rust и логики, заложенной в Gajae‑Code. Агент не «фантазирует», он оперирует состояниями, которые описаны в его кодовой базе.

Роль агент‑менеджера

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

В архитектуре LazyCodex агент‑менеджер опирается на событийную модель. Вместо того чтобы постоянно опрашивать датчики или API (что создаёт лишнюю нагрузку на CPU), он подписывается на события.

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

toml
# Конфигурация жизненного цикла агента-менеджера
[agent.manager]
runtime = "rust-runtime-v2"
autonomy_level = "full"
error_strategy = "restart_with_backoff" # Перезапуск с экспоненциальной задержкой

[agent.manager.capabilities]
sensor_reading = true
decision_making = true
state_persistence = "/var/lib/claw-code/state.db"

[agent.manager.constraints]
max_cpu_usage = 15 # Ограничение, чтобы не мешать работе хоста
memory_limit = "512MiB"

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

Потоки данных и интерактивность

Интерактивность Claw‑Code строится на двустороннем обмене данными. С одной стороны, агент получает внешние стимулы (движение посетителей, изменения освещения, сетевые запросы), с другой — выдаёт реакцию, которая может быть как визуальной, так и программной.

Потоки данных организованы через асинхронные каналы. В Rust это реализуется через tokio::sync::mpsc, что гарантирует отсутствие гонок данных (data races) — критически важного условия для автономных систем.

Процесс обработки входящего сигнала можно представить в виде цепочки:

  1. Сенсорный слой: получение сырых данных.
  2. Слой интерпретации: преобразование данных в понятные агенту события (Events).
  3. Слой принятия решений: выбор действия на основе текущего состояния.
  4. Слой исполнения: отправка команды на исполнительное устройство или вывод информации.

Для мониторинга того, как агент обрабатывает эти потоки, я рекомендую использовать логирование через tracing. Это позволит увидеть не просто «ошибку», а полный путь события от момента поступления до момента принятия решения.

Пример того, как в коде может выглядеть обработка критического события через агентский канал:

rust
use tokio::sync::mpsc;

// Определение типов событий для предсказуемости системы
enum ExhibitEvent {
    VisitorDetected(f32), // Дистанция до посетителя
    SystemAlert(String),  // Системная ошибка
    IdleTimeout,          // Время простоя
}

async fn agent_loop(mut rx: mpsc::Receiver<ExhibitEvent>) {
    while let Some(event) = rx.recv().await {
        match event {
            ExhibitEvent::VisitorDetected(dist) => {
                if dist < 1.5 {
                    // Инициируем интерактивный сценарий
                    execute_interaction("greet_visitor").await;
                }
            }
            ExhibitEvent::SystemAlert(msg) => {
                // Логируем через systemd/journald
                eprintln!("Critical alert: {}", msg);
                attempt_self_healing().await;
            }
            ExhibitEvent::IdleTimeout => {
                enter_low_power_mode().await;
            }
        }
    }
}

С точки зрения эксплуатации, такая структура делает поведение экспоната прозрачным. Если агент совершит неверное действие, мы всегда сможем восстановить цепочку событий и понять, какой именно входной параметр привел к такому результату. Подробности реализации логики принятия решений можно найти в документации проекта Gajae‑Code.

Инфраструктура и развёртывание

Proxmox-кластер и TrueNAS

Для обеспечения предсказуемости работы автономного агента Ultraworkers Claw-Code недостаточно просто запустить контейнер на ноутбуке. Если агент действительно автономен, его среда должна быть изолирована, отказоустойчива и иметь доступ к надёжному хранилищу. В моей домашней лаборатории я развернул среду для этого проекта на базе кластера Proxmox.

Я выделил под агента отдельную виртуальную машину (VM) с выделенными ресурсами, чтобы процессы Rust не конфликтовали с другими сервисами. Для хранения весов моделей, логов и состояний агента используется TrueNAS. Вместо того чтобы полагаться на локальные диски виртуальной машины, я настроил подключение через NFS. Это позволяет легко перенести VM на другую ноду кластера в случае сбоя, не теряя данные.

Сначала создайте директорию на TrueNAS и настройте права доступа. Затем на стороне Proxmox (в консоли гипервизора) проверьте доступность сетевого хранилища. Чтобы смонтировать NFS-ресурс внутри виртуальной машины с агентом, отредактируйте файл /etc/fstab:

bash
# Монтируем сетевой ресурс TrueNAS для хранения данных агента
# Используем опции soft, чтобы избежать зависания системы при сетевых задержках
192.168.1.50:/mnt/tank/ultraworkers_data /mnt/agent_storage nfs rw,soft,intr,noatime 0 0

После правки файла выполните команду для монтирования:

bash
sudo mount -a

С практической точки зрения, использование ZFS на стороне TrueNAS даёт нам дополнительные преимущества: снимки (snapshots) позволяют откатить состояние всей базы данных агента, если его автономные действия приведут к повреждению данных.

CI/CD пайплайн

Поскольку проект базируется на Rust и использует архитектуру Gajae-Code/LazyCodex, процесс сборки должен быть максимально чистым. Я не сторонник того, чтобы компилировать тяжелые Rust-проекты прямо на «боевой» ноде — это создаёт непредсказуемую нагрузку на CPU. Вместо этого я настроил пайплайн, который собирает артефакты в изолированной среде и деплоит их через Docker.

Для автоматизации процесса я использую GitLab Runner, запущенный в отдельном контейнере. Весь цикл — от пуша кода до обновления агента — проходит через несколько этапов.

Во-первых, компиляция. Мы используем многоэтапную сборку (multi-stage build) в Docker, чтобы итоговый образ весил минимум и не содержал в себе лишних инструментов сборки.

Пример Dockerfile для сборки агента:

dockerfile
# Этап сборки
FROM rust:1.75-slim as builder

WORKDIR /app
COPY . .

# Собираем релизную версию без отладочных символов
RUN cargo build --release

# Этап запуска
FROM debian:bookworm-slim

# Устанавливаем только необходимые библиотеки для выполнения
RUN apt-get update && apt-get install -y libssl3 ca-certificates && rm -rf /var/lib/apt/lists/*

WORKDIR /usr/local/bin
# Копируем только готовый бинарный файл из образа builder
COPY --from=builder /app/target/release/claw-code .

# Запуск агента
CMD ["./claw-code"]

Во-вторых, деплой. После того как образ собран и отправлен в локальный реестр, пайплайн обновляет конфигурацию в Docker Compose на целевой машине. Чтобы минимизировать время простоя, я использую стратегию обновления одного контейнера за раз.

Конфигурация docker-compose.yml для развёртывания агента выглядит так:

yaml
version: '3.8'

services:
  claw-agent:
    image: registry.local/ultraworkers/claw-code:latest
    restart: always
    volumes:
      # Подключаем NFS-шару, которую мы подготовили в Proxmox
      - /mnt/agent_storage:/data
      - /etc/localtime:/etc/localtime:ro
    environment:
      - RUST_LOG=info
      - AGENT_MODE=autonomous
    deploy:
      resources:
        limits:
          cpus: '2'
          memory: 4G

Если пайплайн завершается с ошибкой на этапе тестирования или сборки, система уведомляет меня через Alertmanager, и автоматическое обновление не происходит. Это гарантирует, что в среде всегда находится только проверенная и рабочая версия кода.

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

Почему для автономного агента выбран именно Rust

С практической точки зрения, автономность требует максимальной предсказуемости поведения системы в долгосрочной перспективе. Rust позволяет исключить целые классы ошибок, связанных с управлением памятью, которые в других языках могут привести к утечкам или падениям процесса спустя недели непрерывной работы. Использование модели владения (ownership) гарантирует, что агент будет работать стабильно без необходимости запуска тяжелого сборщика мусора, который мог бы вызвать непредсказуемые задержки в критические моменты.

Как обеспечить отказоустойчивость работы агента

Для обеспечения стабильности я рекомендую использовать systemd для управления жизненным циклом процесса. В конфигурационном файле сервиса важно установить параметр Restart=always, чтобы система автоматически перезапускала агента в случае непредвиденного завершения. Также стоит настроить логирование через journald, чтобы иметь возможность детально проанализировать причины сбоя, если агент всё же выйдет из строя.

В чём преимущество использования Gajae‑Code в этой архитектуре

Gajae‑Code позволяет отделить логику поведения агента от низкоуровневой реализации на Rust, используя декларативный подход. Это упрощает описание сложных сценариев взаимодействия, превращая написание кода в настройку правил. Благодаря интеграции с LazyCodex, агент не тратит ресурсы на вычисления, которые не требуются в текущий момент, что критично для оптимизации нагрузки на оборудование.

Можно ли запустить этого агента в контейнере

Да, архитектура агента позволяет упаковать его в Docker-образ, что обеспечит изоляцию и упростит развёртывание. Однако при использовании контейнеров важно правильно настроить права доступа и проброс необходимых ресурсов, чтобы агент сохранял свою автономность. Если вы планируете использовать контейнеризацию, убедитесь, что процесс внутри контейнера корректно обрабатывает сигналы завершения, чтобы избежать повреждения данных при остановке.

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