Продвинутый

Музейный экспонат на Rust без участия человека

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

Разбираем проект claw-code: автономный музейный экспонат на Rust, управляемый ИИ-агентами без участия человека в разработке и поддержке.

Музейный экспонат на Rust без участия человека

Разбираем проект claw-code: автономный музейный экспонат на Rust, управляемый ИИ-агентами без участия человека в разработке и поддержке.

Что такое claw-code и зачем он нужен

Что такое claw-code и зачем он нужен

Идея автономного музейного экспоната

Обычный музейный экспонат требует ухода. Кто-то должен включать его утром, выключать вечером, следить, чтобы экран не завис, обновлять контент, когда меняется экспозиция. Я сам сталкивался с таким: в одном из проектов мы ставили интерактивный стенд на Raspberry Pi, и каждую неделю кто-то должен был ездить в музей, чтобы перезагрузить устройство — SD-карта регулярно вылетала из строя.

claw-code предлагает другой подход. Экспонат работает автономно: ИИ-агенты сами следят за состоянием системы, перезапускают сервисы при сбоях, обновляют контент и даже исправляют ошибки в коде без участия человека. Для меня это логичное продолжение того, что я делаю дома на своём кластере из трёх нод на Proxmox — только вместо ручного вмешательства всё берёт на себя код.

С практической точки зрения, автономный экспонат решает три задачи:

  • Не нужен дежурный техник на месте.
  • Контент остаётся актуальным без ручной правки.
  • Система восстанавливается после сбоев сама, а не ждёт утра, когда кто-нибудь приедет.

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

Стек технологий: Rust и Gajae-Code

Для ядра системы выбрали Rust. Это не случайность. Когда я начинал с LAMP на shared-хостинге, главной проблемой были нестабильные скрипты и утечки памяти. После многих лет работы с production-инфраструктурой я смотрю на язык через призму предсказуемости. Rust даёт именно это: строгая типизация, отсутствие сборщика мусора в runtime и гарантии безопасности памяти на этапе компиляции. Для экспоната, который должен работать без присмотра, это критично.

Вот как выглядит минимальная точка входа в проект:

rust
use claw_code::agent::AutonomousAgent;
use claw_code::exhibit::ExhibitController;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let controller = ExhibitController::new().await?;
    let agent = AutonomousAgent::new(controller).await?;

    agent.run().await?;

    Ok(())
}

Здесь нет ничего лишнего. ExhibitController управляет состоянием экспоната, а AutonomousAgent принимает решения о том, что делать дальше — перезапустить сервис, обновить контент или отправить алерт.

Gajae-Code — это слой, который связывает Rust-ядро с ИИ-агентами. Он отвечает за планирование задач, взаимодействие с внешними моделями и выполнение кода, который агенты генерируют сами. Если говорить просто, Rust отвечает за надёжность и предсказуемость, а Gajae-Code за автономное принятие решений.

Пример конфигурации агента выглядит так:

toml
[agent]
name = "curator"
interval_seconds = 300

[monitoring]
check_health = true
auto_restart = true

[exhibit]
content_source = "https://museum-api.example.com/content"
update_interval_hours = 6

Я привык писать конфиги руками, даже когда есть GUI. GUI для тех, кто не знает, где лежит конфиг. В данном случае всё прозрачно: агент проверяет состояние каждые 300 секунд, при сбое перезапускает компонент, а контент обновляется раз в шесть часов.

Больше о возможностях языка можно почитать на официальном сайте: Rust Programming Language.

Как работает разработка без человека

Когда в первый раз посмотрел на проект claw-code, подумал, что это очередной хайп вокруг нейросетей. Музейный экспонат, который пишет себя сам, без разработчиков — звучит какSpielbericht из раздела научной фантастики. Но после того как покопался в исходниках, понял: здесь нет магии, есть только чёткая архитектура и правильно расставленные границы между тем, что может ИИ-агент, и тем, что остаётся за кодом.

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

Роль ИИ-агентов в написании кода

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

Во-первых, агент пишет код не вслепую. У него есть контекст — описание интерфейсов, ожидаемое поведение, тесты. Если тест не проходит, агент возвращается к коду и правит его, пока зелёный. Это напоминает работу стажёра, которого посадили за код-ревью с чётким техзаданием: он не придумывает архитектуру, он реализует то, что сказано.

Пример. Допустим, нужно добавить новый датчик освещённости к экспонату. Агент получает задачу, смотрит на существующий модуль сенсоров и пишет что-то вроде:

rust
// src/sensors/light.rs
use anyhow::Result;

pub struct LightSensor {
    pin: u8,
}

impl LightSensor {
    pub fn new(pin: u8) -> Self {
        Self { pin }
    }

    pub fn read(&self) -> Result<f32> {
        // Чтение через GPIO, калибровка по таблице из даташита
        Ok(0.0)
    }
}

Затем агент запускает тесты:

bash
cargo test --package claw-sensors --test light_sensor

Если тест падает, агент анализирует вывод, правит код и запускает снова. Человек в этом цикле не участвует — он только определил, какой датчик нужен и где он подключён.

С практической точки зрения, это работает только потому, что проект на Rust. Система типов и borrow checker работают как страховка: агент может наделать ошибок в логике, но компилятор не пропустит небезопасный код в продакшен. Без этого уровня предсказуемости автономная разработка была бы невозможна.

Поддержка и обновление без разработчика

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

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

ini
# /etc/systemd/system/claw-exhibit.service
[Unit]
Description=Autonomous museum exhibit
After=network.target

[Service]
Type=simple
User=claw
ExecStart=/usr/local/bin/claw-exhibit
Restart=always
RestartSec=5
Environment=RUST_LOG=info

[Install]
WantedBy=multi-user.target

Агент не просто перезапускает службу. Он проверяет, что новый бинарник стартовал, что метрики в порядке, что экспонат отвечает на запросы. Если что-то пошло не так — откатывается к предыдущей версии. Это работает по тому же принципу, что и rolling update в Kubernetes, только без оркестратора: один бинарник, один юнит, одна точка ответа.

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

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

Ограничения и риски автономных систем

Автономный агент может написать код, запушить его в репозиторий и даже перезапустить сервис, но когда в три часа ночи перестаёт работать музейный экспонат, у вас нет человека, который объяснит, зачем была добавлена эта строка. В проекте claw-code мы столкнулись с этим напрямую: система работает месяцами без присмотра, а отлаживать её приходится удалённо, через логи и метрики.

Отладка кода без участия инженера

Во-первых, агент не понимает контекста. Он видит текущий файл, возможно, соседние, но не знает, почему три месяца назад кто-то выбрал Arc<Mutex<T>> вместо Rc<T>. Когда происходит паника, стек вызовов показывает, где упало, но не показывает, зачем код так написан.

Пример из практики. Агент решил «оптимизировать» загрузку экспоната и заменил блокирующий вызов на асинхронный, но забыл обернуть его в tokio::spawn. В результате весь рантайм застыл на ожидании ввода-вывода. Лог выглядит так:

text
[2024-03-15T03:14:22Z] ERROR claw_code::exhibit::loader: thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: Os { code: 11, kind: WouldBlock, message: "Resource temporarily unavailable" }', src/exhibit/loader.rs:42

Без инженера рядом трудно понять, что unwrap() здесь — не ошибка агента, а следствие того, что он не учел особенности ОС. С практической точки зрения, отладка автономного кода требует больше инструментирования, чем обычного. Я всегда добавляю в такие проекты подробное логирование и трассировку:

toml
# Cargo.toml
[dependencies]
tracing = "0.1"
tracing-subscriber = { version = "0.3", features = ["env-filter"] }

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

bash
RUST_LOG=claw_code=debug,tracing=info ./target/release/claw-code

Во-вторых, компилятор Rust помогает, но не спасает от логических ошибок. Агент может удовлетворить borrow checker, добавив .clone() везде, где только можно, и код скомпилируется. Но производительность упадёт, а память будет раздута. Найти такое простым cargo check не получится — нужны профилировщики и метрики.

bash
cargo build --release
cargo flamegraph --bin claw-code

На удалённом экспонате в музее это уже сложнее: у вас нет физического доступа, и каждый перезапуск — риск.

Доверие к результату работы агентов

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

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

rust
// Агент написал тест
#[test]
fn test_load_exhibit() {
    let result = load_exhibit("test_config.toml");
    assert!(result.is_ok());
}

// Но не учёл, что в музее нет интернета,
// а конфиг ссылается на внешний ресурс

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

Пример конфига границ:

toml
# claw-code.toml
[autonomous]
allowed_modules = ["ui", "animation", "lighting"]
max_unsafe_blocks = 0

[critical]
require_human_review = true
modules = ["network", "storage", "hardware"]

Ещё один риск — зависимости. Агент может добавить crate, который никогда не обновлялся, или с подозрительной лицензией. cargo audit помогает, но только если вы его запускаете:

bash
cargo install cargo-audit
cargo audit

Наконец, откат. Если агент закоммитил сломанный код, у вас должен быть механизм быстрого возврата к последней рабочей версии. В идеале — теги в Git и автоматический деплой только по тегу:

bash
git tag -a v1.2.3 -m "Стабильная версия экспоната"
git push origin v1.2.3

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

Предсказуемость конфигураций — вот что позволяет спать спокойно. Агент может предложить решение, но окончательное решение о его внедрении должно оставаться за человеком.

Применение в выставочных пространствах

Применение в выставочных пространствах

Автономный экспонат — это не просто экран с зацикленным видео. Это устройство, которое должно работать месяцы без перезагрузки, реагировать на посетителей и корректно обрабатывать сбои. В claw-code всё это реализовано на Rust, а поведение экспоната определяет ИИ-агент, который сам генерирует контент и корректирует свою логику. Ниже разберу, как такое встраивается в реальную экспозицию и к чему стоит готовиться.

Интеграция с музейными экспонатами

Самый частый сценарий, с которым я сталкивался, — отдельный стенд с сенсорным экраном или проекцией, который должен ожить, когда посетитель подходит ближе. В claw-code за это отвечает комбинация датчика движения, локального агента на Rust и дисплейного сервера. Агент не ждёт команды из облака: он сам решает, что показать, основываясь на данных с датчика и текущем состоянии экспозиции.

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

toml
[agent]
model = "llama-3.1-8b"
temperature = 0.7
max_tokens = 512
context_window = 4096

[sensor]
type = "pir"
gpio_pin = 17
debounce_ms = 300
cooldown_sec = 10

[display]
interface = "hdmi"
resolution = "1920x1080"
brightness = 85

Важный момент: cooldown_sec предотвращает срабатывание при каждом проходе посетителя мимо стенда. Иначе агент начнёт генерировать новый текст каждые несколько секунд, и посетитель не успеет прочитать предыдущий.

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

ini
[Unit]
Description=Claw-code autonomous exhibit agent
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=exhibit
WorkingDirectory=/opt/claw-code
ExecStart=/usr/local/bin/claw-code --config /etc/claw-code/exhibit.toml
Restart=always
RestartSec=5
Environment=RUST_LOG=info
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target

После копирования файла в /etc/systemd/system/ применяю изменения:

bash
sudo systemctl daemon-reload
sudo systemctl enable --now claw-code.service
sudo journalctl -u claw-code.service -f

Если агент упадёт из-за ошибки в сгенерированном коде, systemd перезапустит его через пять секунд. Логи уходят в journald, откуда их можно забрать в Loki или оставить локально — зависит от того, есть ли в музее централизованный сбор логов.

Сам агент на Rust выглядит примерно так. Это упрощённый пример, без обработки всех пограничных случаев, но суть показывает:

rust
use std::time::Duration;
use tokio::time::sleep;

#[tokio::main]
async fn main() {
    let sensor = PirSensor::new(17).expect("GPIO не инициализирован");
    let mut agent = Agent::from_config("/etc/claw-code/exhibit.toml").await;

    loop {
        if sensor.motion_detected() {
            let content = agent.generate_narrative().await;
            Display::show(&content).await;
            sleep(Duration::from_secs(10)).await;
        }
        sleep(Duration::from_millis(200)).await;
    }
}

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

Будущее автономных установок

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

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

yaml
scrape_configs:
  - job_name: 'claw-code-exhibits'
    static_configs:
      - targets:
        - 'exhibit-winnie-the-pooh.local:9100'
        - 'exhibit-piglet.local:9100'
        - 'exhibit-owl.local:9100'

Если метрики недоступны, срабатывает алерт в Alertmanager. Человек не участвует в разработке экспоната, но участвует в поддержке инфраструктуры — и это нормально.

Ещё один вопрос — обновления. Агенты могут сами переписывать свой код, но бинарник claw-code и зависимости всё равно нужно доставлять на устройство. Я использую осторожный подход: обновление катится на один стенд, сутки работает в режиме наблюдения, а потом распространяется на остальные. В выставочном зале нельзя позволить себе, чтобы вся экспозиция одновременно перешла на нестабильную версию.

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

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

Что произойдёт, если ИИ-агент испортит код и не сможет исправить ошибку сам?

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

Нужно ли покупать отдельное железо для claw-code, или подойдёт обычный компьютер?

Зависит от того, что будет показывать экспонат. Для простого интерактивного стенда хватит одноплатного компьютера, но я не рекомендую полагаться на SD-карту — лучше надёжный SSD или сетевое хранилище. Если экспонат критичный, имеет смысл развернуть его на выделенном сервере или в кластере с резервированием.

Как часто экспонат будет обновлять контент и откуда берутся данные?

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

Можно ли использовать claw-code не в музее, а в офисе или на выставочном павильоне?

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

Что будет с экспонатом, если пропадёт интернет или электричество?

Без интернета агент не сможет загружать новые данные, но уже загруженный контент продолжит работать. С электричеством сложнее: без питания экспонат остановится, поэтому я рекомендую поставить бесперебойник и настроить корректное выключение через systemd. Иначе риск повреждения файловой системы выше, чем польза от автономности.

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