Hermes Agent Полное руководство

Первый AI-агент, который с рождения умеет самонастраиваться Практическое руководство по open-source фреймворку от Nous Research

Агент, который растёт вместе с тобой

Ключевые слова: Самообучающийся агент · Сквозная память · Система навыков · MCP · Мультиплатформенность

Для: Разработчиков и энтузиастов AI, желающих собрать собственного AI-агента Версия: v260408

HuaShu

WeChat: 花叔 · Bilibili: AI进化论-花生

На основе Hermes Agent v0.7.0. AI-инструменты развиваются стремительно — часть содержимого может измениться в будущих версиях. За актуальной информацией обращайтесь к официальной документации.

Содержание

ОГЛАВЛЕНИЕ

Часть 1: Концепции

• §01 Не очередной агент: От Harness к Hermes

• §02 Hermes Agent за 60 секунд

Часть 2: Ключевые механизмы

• §03 Обучающий цикл: Агент, который сам строит свою обвязку

• §04 Трёхуровневая память: От золотой рыбки к старому другу

• §05 Система навыков: Саморазвивающиеся способности

• §06 40+ инструментов и MCP: Подключи всё

Часть 3: Практическая настройка

• §07 Установка и конфигурация: Три способа

• §08 Первый разговор: Пусть Hermes узнает тебя

• §09 Мультиплатформенный доступ: Всегда под рукой

• §10 Пользовательские навыки: Научи Hermes новым трюкам

• §11 Интеграция MCP: Подключай свой стек инструментов

Часть 4: Реальные сценарии

• §12 Персональный ассистент знаний: Сила сквозной памяти

• §13 Автоматизация разработки: От код-ревью до деплоя

• §14 Создание контента: От исследования до черновика

• §15 Мультиагентная оркестрация: Запусти трёх лошадей сразу

Часть 5: Глубокие размышления

§16 Hermes vs OpenClaw vs Claude Code: Не выбор, а распределение ролей

§17 Границы самообучающихся агентов: Как далеко это может зайти

§01 Не очередной агент: От Harness к Hermes

Не очередной агент: От Harness к Hermes

Лобстерная лихорадка OpenClaw ещё не утихла, а тут уже Hermes Agent. Это не «ещё один инструмент для агентов» — это первый случай, когда концепция Harness Engineering превратилась в продукт.

Ещё один?

Я понимаю. Ты устал.

OpenClaw запустила лобстерную лихорадку в конце 2025 года. 26 миллионов пользователей. Все крупные технологические компании Китая бросились создавать свои аналоги. Твои соцсети наверняка были завалены постами «Я ращу лобстера» неделями. И теперь, прежде чем лобстерная лихорадка окончательно утихла, появляется что-то новое.

В феврале 2026 года Nous Research выпустили Hermes Agent. Меньше чем за два месяца количество звёзд на GitHub перевалило за 27 000.

Твоя первая реакция, вероятно: я ещё с лобстером не разобрался, а тут опять?

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

Что такое Harness Engineering

Если ты читал предыдущую оранжевую книгу Harness Engineering — можешь пропустить эту часть. Если нет — вот версия на 30 секунд.

В начале 2026 года в мире AI-кодинга сложился консенсус: узкое место — не модель, а окружение. Команда LangChain провела эксперимент: использовала одну и ту же модель (GPT-5.2-Codex), меняя только конфигурацию окружающей «обвязки» (harness). Результаты подскочили с 52,8% до 66,5%, рейтинг взлетел с Top 30 до Top 5. Ни строчки кода модели не меняли.

Митчелл Хашимото (создатель Terraform) первым назвал это: Harness Engineering. Его подход был прямолинейным — каждый раз, когда AI ошибался, он добавлял правило, чтобы ошибка не повторилась. Файл был живым, постоянно рос.

В той книге я разбил обвязку (Harness) на пять компонентов. Эти пять компонентов — ключ к пониманию Hermes.

Соответствие пяти компонентов

Harness Engineering — это методология. Она говорит: «какую обвязку ты должен построить для своего AI». Но у методологий есть проблема: исполнение полностью ручное. Ты должен сам писать CLAUDE.md, сам настраивать хуки, сам строить систему памяти, сам проектировать рабочие процессы.

Hermes сделал следующее: встроил все пять компонентов.

Посмотри на левую колонку vs правую. Слева — всё ручное, требуется опытный инженер. Справа — из коробки, готово к работе сразу после установки.

Это фундаментальное различие между Hermes и OpenClaw. OpenClaw даёт систему «конфигурация как поведение» — ты пишешь SOUL.md, и он становится тем, кем ты хочешь. Его система памяти способна (Daily Logs + MEMORY.md + семантический поиск), а экосистема навыков огромна, но навыки в основном пишутся и поддерживаются вручную. У Hermes все пять измерений встроены и работают автоматически.

Соединяя точки: если ты использовал CLAUDE.md + хуки + память в Claude Code — ты уже занимался Harness Engineering вручную. Hermes превращает эту ручную работу в автоматизированную систему. От «ты строишь обвязку для AI» к «AI строит свою собственную обвязку».

Почему Nous Research это создали

Команда, стоящая за Hermes Agent — не большая компания, а open-source исследовательская лаборатория.

Nous Research называют «таинственной силой open-source сообщества». Ключевая фигура, Teknium, сооснователь лаборатории и руководитель пост-тренировки. На ранних этапах они полагались на Redmond AI для вычислений, и команда всегда была небольшой. И тем не менее, семейство моделей Hermes (от Hermes 3 8B/70B/405B до Hermes 4 14B/70B/405B) достигло производительности передового уровня за счёт одного лишь пост-тренинга. Никакого претренинга с нуля, никакого огромного бюджета на вычисления.

Эта философия перешла и в Hermes Agent: используя open-source инструменты + любой LLM API, даже индивидуальные разработчики могут развернуть AI-агентов, сопоставимых с коммерческими решениями. Лицензия MIT, полностью открытый исходный код.

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

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

Эти принципы сформировали дизайн-философию Hermes Agent: он не принимает решения за тебя — ты устанавливаешь правила,

он учит правила, а потом становится всё лучше и лучше. Контроль остаётся у пользователя; система берёт на себя сложность исполнения.

Не замена, а развитие

Существует распространённое заблуждение: Hermes пришёл заменить Claude Code или OpenClaw. Это не так. Эти три инструмента решают задачи на разных уровнях.

Claude Code занимается интерактивным кодингом. Ты сидишь в терминале, общаешься, работаешь в реальном времени. Это твой напарник по парному программированию.

OpenClaw занимается конфигурацией как поведением. Ты пишешь SOUL.md, и он становится тем, кем ты хочешь. Конфигурация прозрачна, экосистема зрелая — 5 700+ навыков сообщества на ClawHub.

Hermes занимается автономной фоновой работой + самообучением. Тебе не нужно сидеть рядом с ним. Он работает сам, учится сам, развивается сам. Онлайн 24/7, доступен в любое время через Telegram или Discord.

Интересный момент: все три инструмента используют стандарт agentskills.io, поэтому навыки совместимы. Навык, написанный для Claude Code, работает и в Hermes, и наоборот. Это не три параллельные линии — скорее три роли с разными задачами в одной экосистеме.

Ключевой вывод

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

С обвязкой из коробки

Возвращаясь к вопросу, с которого мы начали: почему на этот раз всё иначе?

Лобстерная лихорадка научила обычных пользователей кое-чему: AI может быть «тем, кого ты растишь», а не просто «тем, что ты открываешь и используешь». SOUL.md, система памяти и персонализация OpenClaw позволили людям впервые почувствовать, что значит «мой AI».

Но владельцы лобстеров также обнаружили проблему: всю обвязку нужно строить самому. Писать SOUL.md, вручную настраивать навыки, периодически чистить память. Лобстер становится лучше с использованием, но только если ты готов вкладывать время в его кормление.

Hermes идёт другим путём: обвязка встроена прямо в заводские настройки и растёт сама.

С первого же разговора Hermes начинает автоматически писать в память, извлекать навыки и оптимизировать рабочие процессы. Чем дольше ты им пользуешься, тем глубже его понимание тебя, тем выше качество его работы. Ты не обучаешь его — он обучается сам.

Hermes — первый агент, который поставляется со встроенной обвязкой. И обвязка растёт сама.

§02 Hermes Agent за 60 секунд

Hermes Agent за 60 секунд

Одна блок-схема, один набор цифр, одна сравнительная таблица. После этих трёх вещей ты будешь знать о Hermes всё главное.

Архитектура в одной картинке

Архитектуру Hermes Agent можно описать одной строкой:

—– Начало текста к рисунку —–
Обучающий цикл → Трёхуровневая память → Система навыков → 40+ инструментов →
Мультиплатформенный шлюз
—– Конец текста к рисунку —–

Слева направо, задача каждого модуля в одном предложении:

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

Трёхуровневая память — это мозг Hermes. Память сессии помнит «что только что произошло», персистентная память помнит «кто ты и что тебе нравится», а память навыков помнит «как делать дела». У каждого уровня своя задача; данные хранятся в SQLite + индексах FTS5 и извлекаются по запросу, а не загружаются все сразу.

Система навыков — это библиотека умений Hermes. Каждый навык — отдельный markdown-файл в директории

~/.hermes/skills/. Есть три источника: встроенные в репозиторий, созданные самим агентом или установленные из хаба сообщества. Ключевая особенность: навыки не статичны — они самообучаются через использование.

40+ встроенных инструментов — это руки и ноги Hermes. Пять категорий: исполнение (запуск кода, работа с файлами), информация (поиск, скрапинг), медиа (изображения, видео), память (чтение/запись) и координация (делегирование сабагентам). Плюс интеграция MCP, подключающая 6 000+ внешних приложений.

Мультиплатформенный шлюз — это входная дверь Hermes. Telegram, Discord, Slack, WhatsApp, Signal, CLI — 14 поддерживаемых платформ. Ты можешь написать ему в Telegram, он обрабатывает запрос в фоне на твоём VPS, и разговоры остаются непрерывными на всех платформах.

Ключевые цифры

Версия v0.7.0, выпущена 3 апреля 2026. Несколько цифр, которые стоит отметить:

27 000+ звёзд за два месяца — это быстро. Стоит помнить, что OpenClaw достиг своего нынешнего масштаба благодаря социальной вирусности лобстерной лихорадки. Hermes набрал эти цифры без какого-либо сопоставимого вирусного эффекта, что говорит о том, что сообщество разработчиков искренне считает, что он решает реальную проблему.

Ключевые отличия от OpenClaw

После лобстерной лихорадки вопрос, который задают все: в чём на самом деле разница между Hermes и OpenClaw?

Два самых больших разрыва — способность к обучению и моделирование пользователя. Навыки OpenClaw в основном пишутся и настраиваются вручную — их развитие зависит от сообщества и активного обслуживания пользователем. Чем дольше ты используешь Hermes, тем точнее становятся его навыки, глубже память, плавнее исполнение.

Но у OpenClaw есть то, с чем Hermes пока не может конкурировать: зрелость экосистемы. 5 700+ навыков сообщества на ClawHub с готовыми решениями для самых разных сценариев. Сообщество Hermes ещё на ранней стадии. Сетевой эффект от 26 миллионов пользователей в лобстерной лихорадке дал OpenClaw огромное преимущество, которое невозможно преодолеть одной лишь технологией.

Различие в одной строке: OpenClaw — это лобстер, которого ты растишь сам. Hermes — это лобстер, который растёт сам. Один зависит от твоего тщательного кормления; другой учится на собственном опыте.

$5 — и ты в деле

Стоимость волнует многих. Ответ может тебя удивить.

Сам Hermes бесплатен, MIT с открытым исходным кодом. Ты платишь только за вызовы LLM API. Стоимость развёртывания зависит от выбранного варианта:

Самый дешёвый вариант: любой VPS за $5/месяц (Hetzner CX22 около $4/месяц; DigitalOcean, Vultr тоже подойдут), Ubuntu 22.04. Без запуска локальной LLM потребление памяти остаётся ниже 500 МБ. В паре с OpenRouter и Claude Haiku или DeepSeek затраты на API также остаются низкими.

Ещё дешевле: Serverless. Используй Daytona или Modal в качестве бэкенда — среда засыпает в простое и просыпается автоматически при поступлении сообщения. Затраты между сессиями практически нулевые.

Для конфиденциальности: Запусти Ollama на своём VPS с локальной open-source моделью 8B или 70B. Затраты на API нулевые, но потребуется более мощный VPS (рекомендуется от 16 ГБ ОЗУ).

Независимо от варианта, VPS за $5 + Telegram Bot дают тебе персонального AI-агента, работающего 24/7. Это соотношение цены и производительности на голову выше подписных коммерческих агентских решений.

Ключевой вывод

Для сравнения: подписка Claude Code Pro стоит $20/месяц, Max — $200/месяц. При схеме с VPS за $5 + затраты на API ежемесячные расходы Hermes в большинстве случаев не превышают $10. Разумеется, они позиционируются по-разному, так что прямое сравнение цен не совсем корректно — но порог входа, несомненно, гораздо ниже.

Последний вопрос: эта книга для вас?

Если что-то из перечисленного относится к вам — читайте дальше:

Вы использовали Claude Code или OpenClaw и хотите агента, который умеет выполнять фоновые задачи автономно. Не такого, за которым надо сидеть и следить, — а такого, который продолжает работать, пока вы спите.

Вы знаете о Harness Engineering и хотите посмотреть, как выглядит методология, превращённая в продукт.

Вы хотите развернуть приватного AI-агента на своём VPS, где ваши данные не покидают ваш сервер.

Вам просто интересно, что именно сделал правильно open-source проект, набравший 27 000+ звёзд за два месяца.

В следующих главах мы начнём с обучающего цикла и послойно разберём ключевые механизмы Hermes.

§03 Обучающий цикл: самонастраивающийся агент

Обучающий цикл: самонастраивающийся агент

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

Начнём с реального сценария

Представьте, что вы впервые просите Hermes написать Python-скрипт. Вы говорите: напиши парсер, который забирает заголовки и описания с определённого сайта.

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

К десятому разу всё иначе. Он знает, что вы предпочитаете httpx, а не requests. Он знает, что вы любите писать логи ошибок в файл, а не выводить в терминал. Он знает, что ваш проект обычно организован по модулям внутри src/. Он знает, что вы ненавидите длинные функции.

Никто не учил его всему этому. Он разобрался сам.

Вот что делает обучающий цикл.

Пять шагов, один замкнутый цикл

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

—– Начало текста картинки —– Курировать память → Создать навык → Самоулучшение навыка → FTS5-поиск → Моделирование пользователя —– Конец текста картинки —–

Выглядит как пять независимых функций? На самом деле между ними есть причинно-следственные связи. Память даёт сырой материал для создания навыков. Навыки накапливают обратную связь в процессе использования, что запускает самоулучшение. FTS5 обеспечивает точный поиск по историческому опыту. Моделирование пользователя собирает эти фрагменты в целостную картину. Разберём их по порядку.

Шаг первый: курирование памяти

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

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

Hermes работает скорее как человек, ведущий дневник. После каждого разговора он оглядывается: о чём это было? Были ли новые открытия? Высказал ли пользователь какие-то предпочтения? Затем записывает то, что стоит сохранить, в базу SQLite с полнотекстовым индексированием FTS5.

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

Шаг второй: автономное создание навыков

Когда Hermes завершает достаточно сложную задачу, он задаёт себе вопрос: будет ли это решение полезно снова в будущем?

Если ответ «да», он превращает решение в файл навыка и сохраняет в ~/.hermes/skills/. Этот навык — markdown-файл, содержащий описание задачи, шаги выполнения и то, на что стоит обратить внимание.

Вот пример: вы просите Hermes очистить CSV-файл и импортировать его в базу данных. После выполнения он может создать навык csv-to-database.md, записав туда типичные шаги очистки данных, ваш предпочитаемый способ подключения к БД и правила валидации полей, которые вам обычно нужны.

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

Шаг третий: самоулучшение навыка

Создание навыка — не конец. Каждый раз, когда навык используется и вы даёте обратную связь, Hermes берёт эту обратную связь и изменяет сам навык.

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

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

Ключевое различие: традиционные AI-инструменты имеют память как накопление логов разговоров. Память Hermes — это дистилляция опыта. Одно — видеокассета, другое — записная книжка. Видеокассеты становятся всё длиннее, пока не переполнятся; записной книжкой можно пользоваться бесконечно.

Шаг четвёртый: FTS5-поиск между сессиями

Помнить всё это — одно дело. Настоящий фокус в том, чтобы найти нужный фрагмент в нужный момент.

Hermes использует расширение FTS5 от SQLite для полнотекстового индексирования. Перед каждым новым разговором он ищет в исторической памяти по текущей теме и загружает в контекст только релевантные части. Не всю историю — только то, что нужно.

Это важнее, чем может показаться. Большинство AI-инструментов либо не помнят, что вы говорили в прошлый раз, либо сваливают всё в кучу и замедляются до черепашьей скорости. Подход Hermes: задайте вопрос о базах данных — он ищет воспоминания о БД; спросите о фронтенде — ищет воспоминания о фронтенде. Как хорошо организованная система заметок с оглавлением и указателем — вы ищете то, что нужно.

У FTS5 есть и другое преимущество: он полностью локальный. Ваши данные памяти не нужно загружать на какой-либо сервер — всё хранится в локальном SQLite-файле. При переезде на другую машину просто скопируйте директорию ~/.hermes/.

Шаг пятый: моделирование пользователя

Финальный шаг — моделирование пользователя Honcho, опциональная внешняя интеграция. Она делает нечто большее, чем запоминание того, что вы сказали: она делает выводы о том, что вы за человек.

После каждого разговора Honcho анализирует общение и выводит ваши предпочтения, привычки и цели. Эти выводы — не просто записи того, что вы сказали, — это более глубокие паттерны, обобщённые на основе вашего поведения.

Например, вы ни разу явно не сказали «я предпочитаю лаконичный стиль кода», но Honcho вывел это, анализируя то, как вы правите код во множестве сессий. В следующий раз при генерации кода он по умолчанию использует лаконичный стиль. Мы подробнее рассмотрим 12-уровневую модель идентификации Honcho в следующей главе.

Философия Mitchell Hashimoto в автоматическом режиме

Если вы читали оранжевую книгу Harness Engineering, вы, возможно, помните подход Митчелла Хашимото. При работе с Claude Code у него была привычка: каждый раз, когда агент ошибался, он добавлял правило в CLAUDE.md.

«Не используй тип any в этом проекте».

«Помещай тестовые файлы в директорию __tests__, а не в src».

«Пиши сообщения коммитов на английском, начиная с глагола».

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

Hermes делает по сути то же самое, но автоматически.

Вам не нужно вручную писать CLAUDE.md. Вам не нужно самому обобщать правила после каждой ошибки. Hermes наблюдает сам, обобщает сам, пишет навыки сам и применяет эти правила сам в следующий раз.

Разумеется, автоматический не значит идеальный. Правила, написанные Митчеллом вручную, как правило, точнее, потому что человек яснее понимает свои потребности. Автоматически сгенерированные правила Hermes могут требовать доработки, могут ошибаться. Но в том и дело: это снижает порог входа до нуля. Не у каждого есть терпение Митчелла поддерживать тонко настроенный файл правил. Hermes позволяет тем, кто не хочет возиться с конфигурацией, всё равно получать опыт «становится лучше с использованием».

Эффект ускорения маховика

Ни один из пяти шагов по отдельности не является новым. Память, навыки, поиск, профилирование пользователя — в области AI всё это уже было.

Инновация Hermes в том, что они соединены в замкнутый цикл. Память питает создание навыков. Использование навыков порождает новые воспоминания. Новые воспоминания запускают улучшение навыков. Улучшенные навыки дают лучшие результаты. Лучшие результаты делают моделирование пользователя точнее. Более точное профилирование делает следующий раунд курирования памяти более целенаправленным.

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

Разница в том, что маховик Hermes вращается для одного пользователя. Ему не нужны данные миллионов пользователей, чтобы улучшаться — только ваша собственная история использования. Используйте его три-пять дней, и вы заметите явную разницу.

Ключевой совет

Эффективность обучающего цикла напрямую связана с тем, как часто вы его используете. Если вы пользуетесь им раз-два в неделю, улучшение будет медленным. Но если вы сделаете его своим ежедневным рабочим партнёром и используете каждый день, маховик раскручивается замечательно быстро. Вот почему Hermes особенно хорошо подходит для развёртывания на VPS за $5, работающем 24/7, — пусть он продолжает накапливать опыт.

Что это значит

Вернёмся к заголовку: агент строит свою собственную обвязку.

В Harness Engineering обвязку создаёт человек. Вы пишете CLAUDE.md, настраиваете хуки, проектируете механизмы обратной связи. Всё это требует постоянных человеческих вложений.

Подход Hermes: позволить агенту плести свою обвязку прямо во время работы. Когда он отклоняется от курса — он самокорректируется и запоминает урок. Когда находит хороший метод — превращает его в навык для будущего использования. Когда встречает нового пользователя — строит свою собственную модель понимания.

Это не значит, что человек исключён из процесса. Вы можете вручную редактировать файлы навыков в любое время, удалять неуместные воспоминания, корректировать профиль пользователя. Но по умолчанию система самоуправляема.

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

§04 Трёхуровневая память: от золотой рыбки к старому другу

Трёхуровневая память: от золотой рыбки к старому другу

Большинство AI-инструментов для общения имеют память золотой рыбки — что было сказано в прошлый раз, забывается к следующему. Hermes стремится быть старым другом: тем, кто помнит, что вы говорили, знает, что вы за человек, и усвоил, как вы любите делать дела.

Почему память — самая сложная проблема

Можно подумать, что AI-память — это просто сохранение логов чата. Сохранить их, загрузить в следующий раз, готово.

Не всё так просто. Активный пользователь общается с AI на тысячи слов в день. Это десятки тысяч слов в месяц. Запихнуть всё это в окно контекста — либо не влезет, либо модель станет тормозить от информационной перегрузки. К тому же большая часть лога чата — шум и повторы, по-настоящему ценной информации может быть всего 10%.

Хорошая память — это не про сохранение большего объёма, а про нахождение того, что важно.

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

Уровень первый: сессионная память

Сессионная память отвечает на вопрос: что произошло?

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

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

Преимущества такого подхода:

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

Уровень второй: постоянная память

Постоянная память отвечает на вопрос: кто вы?

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

Технически постоянная память тоже хранится в SQLite и управляется через инструмент memory. Всё решение находится на уровне файлов: никаких внешних серверов, никакой облачной синхронизации, данные живут в директории ~/.hermes/.

Это означает, что вы можете:

• Сделать резервную копию ~/.hermes/ на USB-накопитель и продолжить на другой машине
• При развёртывании через Docker смонтировать директорию /opt/data на хосте для сохранения состояния
• Синхронизировать между устройствами через облачное хранилище (реальная синхронизация SQLite в реальном времени не рекомендуется, но периодическое копирование работает отлично)

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

Память навыков отвечает на вопрос: как делать?

Первые два слоя помнят, что произошло и кто ты такой. Третий слой запоминает методологии и процедуры. Каждый Навык — это markdown-файл в /.hermes/skills/, читаемый и редактируемый человеком.

Эти три слоя соответствуют трём типам памяти в когнитивистике:

Эпизодическая память → Что произошло

—– Начало текста картинки —– Семантическая память → Процедурная память → Как устроен мир → Как делать что-то —– Конец текста картинки —–

Учиться ездить на велосипеде — это работа всех трёх слоёв вместе: ты помнишь, как упал в прошлый раз (эпизодическая), знаешь, что центр тяжести нужно держать низко (семантическая), а тело балансирует автоматически (процедурная). Hermes работает с задачами так же: помнит, как ты правил код в прошлый раз, знает твои предпочтения и держит под рукой проверенный план действий.

Три слоя в действии: ты говоришь «помоги развернуть проект». Hermes сначала ищет в сессионной памяти через FTS5 и находит конфликт портов, который был в прошлый раз (эпизодическая). Потом проверяет persistent-память и выясняет, что ты используешь Alibaba Cloud ECS с Nginx reverse proxy (семантическая). Наконец загружает навык deployment-checklist и выполняет шаги, которые ты уже проверил (процедурная). Каждый слой делает своё дело.

Honcho: Знает тебя лучше, чем ты сам

Помимо трёх локальных слоёв памяти, у Hermes есть опциональная надстройка — система моделирования пользователя Honcho, разработанная Plastic Labs.

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

Что это за 12 слоёв на практике? Давай разберём на примере.

Допустим, ты три недели подряд каждый день просишь Hermes писать Python-скрипты. За это время Honcho может вывести:

• Технический уровень: ты не полный новичок, но и не эксперт. Код читаешь, но с нуля писать пока тяжеловато

• Рабочий ритм: активен обычно с 9 до 11 вечера, вероятно — личный проект после работы

• Стиль общения: предпочитаешь сначала видеть результат, а потом спрашивать о принципах; не любишь долгих объяснений

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

• Эмоциональные паттерны: когда код падает с ошибками, немного раздражаешься; в такие моменты лучше отвечать коротко и по делу

• Противоречия в предпочтениях: ты говоришь, что хочешь подробные комментарии, но при беглом просмотре кода их никогда не читаешь

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

Эти выводы вплетаются в следующие промпты как невидимый контекст. Ты не видишь эту информацию, но чувствуешь, что Hermes лучше тебя понимает.

Сравнение с авто-памятью Claude Code

У Claude Code тоже есть система памяти: файлы CLAUDE.md и авто-память. Как они соотносятся с памятью Hermes?

У них разные философии. CLAUDE.md от Claude Code работает по модели «человек пишет — ИИ выполняет»: плюс в полном контроле человека, минус — требует постоянного поддержания. Hermes работает по модели «ИИ пишет — человек проверяет»: плюс в низком пороге входа и высокой автоматизации, минус — автогенерированный контент не всегда точен.

Что лучше — зависит от сценария. Если ты активный пользователь Claude Code и неделями аккуратно выстраивал свой CLAUDE.md, твоя ручная настройка может быть точнее того, что генерирует Hermes. Но если ты не хочешь тратить время на правку конфигов — полностью автоматический подход Hermes действительно проще.

Память — не серебряная пуля

После всего хорошего — поговорим об ограничениях.

Что стоит помнить:

• Предпочтения и привычки пользователя (стиль кода, выбор инструментов, стиль общения)

• Контекст проекта (архитектурные решения, стек технологий, структура файлов)

• Проверенные решения (Навыки)

• Повторяющиеся паттерны (например, как обрабатывать определённые типы ошибок)

Что не стоит помнить:

• Детали разовых задач (напиши поздравление с днём рождения — это запоминать не нужно)

• Устаревшую информацию (номер версии API трёхмесячной давности, который наверняка изменился)

• Неверные выводы (Hermes может ошибиться в оценке твоих предпочтений — такое нужно чистить)

• Чувствительную информацию (пароли, ключи, личные данные не должны попадать в хранилище памяти)

Внимание

У системы памяти Hermes пока нет механизма автоматического устаревания. При долгом использовании база памяти будет расти. Стоит периодически проверять размер папки /.hermes/ и чистить устаревшие файлы Навыков. Это известная область для улучшения.

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

Так что периодический аудит памяти — дело полезное. Проверь, какие Навыки лежат в ~/.hermes/skills/, удали те, что не подходят. Просмотри persistent-память, исправь неверные выводы. Как с блокнотом — время от времени пролистать, и находится куча всего, что нужно обновить.

От хранения к пониманию

Вернёмся к заголовку: от золотой рыбки к старому другу.

Проблема золотой рыбки не в том, что у неё нет глаз, — в том, что у неё нет памяти. Каждый раз, когда она тебя видит, — как в первый раз. Большинство AI-инструментов именно такие: открываешь новый диалог — всё начинается с нуля.

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

Трёхслойная память Hermes вместе с моделированием пользователя Honcho идёт по этому пути. Сессионная память даёт сырой материал, persistent-память — профиль, память навыков — методологию, а Honcho собирает эти фрагменты в целостное понимание тебя.

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

В следующей главе посмотрим на ещё один ключевой механизм Hermes: систему Навыков. Если память — это «знать», то Навыки — это «уметь».

§05 Система Навыков: способности, которые развиваются сами

Навыки: самообучающиеся способности

Навыки OpenClaw нужно писать и поддерживать вручную. Навыки Hermes растут сами и со временем становятся лучше. Эта разница определяет два совершенно разных пользовательских опыта.

Что такое Навык

В Hermes каждый Навык — это отдельный markdown-файл в папке /.hermes/skills/. Он хранит процедурную память Агента о том, как что-то делать.

Представь: ты учишь нового коллегу писать еженедельные отчёты. В первый раз ты проходишь с ним каждый шаг. Во второй — он ещё задаёт вопросы. К третьему разу — уже освоился. Навык — это то самое «состояние после третьего раза»: Агент закрепляет метод в виде переиспользуемого документа.

Навыки бывают из трёх источников:

Эти три источника неравнозначны. Встроенные Навыки — это отправная точка, Skills Hub — ускоритель, но созданные Агентом Навыки — вот настоящая killer-фича Hermes.

agentskills.io: универсальный язык для Навыков

Навыки Hermes — не запертый сад. Они следуют стандарту agentskills.io, который уже поддерживается 30+ инструментами: Claude Code, Cursor, Copilot, Codex CLI, Gemini CLI.

Навыки, которые ты написал для Claude Code, работают напрямую в Hermes. И наоборот.

Это отличается от модели App Store. App Store означает одну экосистему на платформу, разработчики вынуждены собирать под каждую. agentskills.io больше похож на USB-порт — один Навык подключается куда угодно и работает.

Для тех, кто уже активно пользуется Claude Code: твои накопленные Навыки не заперты в одном инструменте. Переходи на Hermes, или пользуйся обоими — Навыки мигрируют без проблем.

Самообучение: Навыки становятся лучше с использованием

Это ключевое отличие Hermes от любой другой системы Навыков.

Традиционные Навыки требуют ручного ухода. Ты пишешь Навык для код-ревью, и он в точности выполняет твои шаги. Обнаружил, что какой-то шаг на практике работает плохо? Придётся лезть и править вручную. Примерно так работают 5 700+ Навыков сообщества OpenClaw.

Навыки Hermes — живые. Они работают внутри обучающего цикла, автоматически оптимизируясь на основе реальной обратной связи.

Механизм такой:

—– Начало текста картинки —– 1 —– Конец текста картинки —–

Выполнить Навык

Агент следует шагам, записанным в Навыке, и выполняет задачу

—– Начало текста картинки —– 2 —– Конец текста картинки —–

Собрать обратную связь

Реакция пользователя (доволен / не доволен / исправления) записывается в сессионную память

—– Начало текста картинки —– 3 Обновить Навык —– Конец текста картинки —–

Агент анализирует обратную связь и автоматически изменяет соответствующие шаги в файле Навыка

4 Следующее выполнение использует новую версию

Улучшенный Навык вступает в силу автоматически в следующих задачах

Звучит идеалистично? Отчасти да — результат зависит от возможностей LLM и качества обратной связи. Но направление верное: позволить Агенту учиться на опыте, вместо того чтобы ждать, пока кто-то будет поддерживать Навык вручную.

Параллель с Митчеллом Хасимото: Митчелл говорил, что, используя Claude Code, он «добавляет правило в CLAUDE.md каждый раз, когда тот совершает ошибку». Hermes автоматизирует этот процесс. Тебе не нужно добавлять правила самому — Агент наблюдает, обобщает и записывает их в Навыки. Плата за это — некоторая потеря контроля над правилами.

Ключевые отличия от Навыков OpenClaw

В ClawHub от OpenClaw 5 700+ Навыков — намного больше, чем у Hermes. Но философии у них принципиально разные:

Сила OpenClaw — в масштабе и прозрачности. Один взгляд на SOUL.md — и ты точно знаешь, что делает Навык: каждый шаг ты написал сам, так что всё понятно.

Сила Hermes — в адаптивности. Один и тот же Навык «писать код» после трёх недель использования Python-разработчиком и Rust-разработчиком превратится в две совершенно разные версии. Не универсальный шаблон — а индивидуальная настройка.

Они не исключают друг друга. Стандарт agentskills.io позволяет перемещать Навыки между ними. Ты можешь спокойно установить Навык из ClawHub в Hermes, а затем позволить Hermes улучшать его через использование.

На практике: как Hermes сам создаёт Навык

Хватит о механике — давай посмотрим на конкретный пример.

Допустим, каждое утро тебе нужно, чтобы Hermes разбирал вчерашние GitHub-уведомления и выжимал из них важные PR и Issues. Первые несколько раз приходится каждый чётко формулировать запрос:

«Просмотри мои GitHub-уведомления со вчерашнего дня, отсортируй по важности, раздели PR и Issues, игнорируй автоматические уведомления ботов.»

После третьего-четвёртого раза Hermes делает кое-что в фоне: он извлекает этот повторяющийся паттерн в файл Навыка. В /.hermes/skills/ появится новый markdown-файл, который выглядит примерно так:

GitHub Daily Digest

Условия запуска

Пользователь говорит «GitHub-уведомления», «ежедневная сводка» и т.п.

Шаги

1. Вызвать GitHub MCP, чтобы получить уведомления за последние 24 часа

2. Отфильтровать автоматические уведомления от ботов

3. Сгруппировать по типу (PR / Issue / Discussion)

4. Отсортировать по важности (упоминание > запрос ревью > остальное)

5. Представить в виде краткого списка

Предпочтения пользователя

• Нужны только заголовки и статус, без детального содержания

• PR и Issues показывать раздельно

С этого момента ты просто говоришь «проверь GitHub» — и Hermes знает, что делать.

Что ещё интереснее — что будет дальше. Однажды ты говоришь: «В этот раз добавь ещё Discussions». Hermes не просто выполняет это для одного запроса — он обновляет правила в файле Навыка. В следующий раз Discussion будут включены, даже если ты не просил.

Вот что значит «самообучение» на практике. Никакого таинственного прорыва в ИИ — просто автоматический цикл «пользователь исправляет → правила обновляются → следующее выполнение применяет изменения».

Внимание

Самообучение Навыков требует, чтобы обратная связь была достаточно чёткой. Если ты просто чувствуешь, что «что-то не так», но не говоришь, что именно, Агент не сможет точно улучшиться. Хорошая обратная связь = правильное направление эволюции.

§06 40+ Инструментов и MCP: подключи всё

40+ Инструментов и MCP: подключи всё

Каким бы умным ни был Агент, без инструментов он не сможет сделать реальную работу. Hermes поставляется с 40+ встроенными инструментами: от запуска кода до отправки сообщений. MCP расширяет его возможности до 6 000+ внешних приложений.

Инструменты Hermes делятся на пять категорий. Запоминать их все не нужно — достаточно знать, что такие возможности существуют, и обращаться к ним по мере необходимости.

Некоторые инструменты стоит выделить отдельно.

session_search — довольно уникальная возможность Hermes. Она использует полнотекстовый индекс FTS5 для поиска по истории разговоров в паре с LLM-суммаризацией, позволяя агенту быстро вспомнить «тот подход, который мы обсуждали на прошлой неделе». У большинства агентов этого нет — каждый разговор начинается с нуля.

moa (Multi-model Orchestrated Answering) позволяет Hermes одновременно обращаться к нескольким LLM, синтезируя их ответы в финальный результат. Полезно в сценариях, требующих высокой надёжности: проверка фактов, технические решения.

cronjob задаёт запланированные задачи на естественном языке. Скажите «проверяй уведомления GitHub каждое утро в 9 утра» — и будет создан временной триггер. Никаких cron-выражений, никакой настройки планировщика.

Тулсеты: не всё сразу, а по требованию

Держать все 40+ инструментов включёнными одновременно не имеет смысла. Агенту, который помогает писать код, не нужны права на Home Assistant, а агенту для управления календарём — код execution.

Hermes решает это механизмом Тулсетов. Инструменты сгруппированы по функциям и включаются/отключаются в config.yaml по необходимости:

# Пример config.yaml
toolsets:
  - web            # веб-поиск
  - terminal       # команды терминала
  - file           # операции с файлами
  - skills         # управление навыками
  - delegation     # делегирование под-агентам
  # - homeassistant  # закомментируйте то, что не нужно
  # - rl            # обучение с подкреплением, большинству не понадобится

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

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

MCP: единый интерфейс к 6000+ приложений

40+ встроенных инструментов покрывают общие сценарии. Но у каждого свой набор инструментов — кто-то использует Jira для управления проектами, Notion для документов, Slack для коммуникации. Как заставить Hermes работать с ними?

MCP (Model Context Protocol).

MCP — это открытый протокол, задающий стандарт коммуникации между AI-агентами и внешними инструментами. Hermes поддерживает подключение к любому MCP-серверу через stdio или HTTP. Экосистема MCP на данный момент охватывает 6000+ приложений — GitHub, Slack, Jira, Google Drive, базы данных, и так далее.

Интеграция прямая — добавьте блок конфигурации в config.yaml:

# Подключение к MCP-серверу GitHub
mcp_servers:
  github:
    command: npx
    args: ["-y", "@modelcontextprotocol/server-github"]
    env:
      GITHUB_PERSONAL_ACCESS_TOKEN: ${GITHUB_TOKEN}

После настройки Hermes может использовать возможности GitHub: создавать Issues, просматривать PR, проверять статус репозитория. Никакого кода писать не нужно, никаких кастомных инструментов — MCP-серверы работают по принципу «включи и пользуйся».

Hermes также поддерживает фильтрацию инструментов на уровне сервера. MCP-сервер может предоставлять 20 инструментов, но вам может потребоваться, чтобы агент использовал только 3 из них. Фильтрация даёт точный контроль над тем, какие возможности доступны агенту.

Делегирование под-агентам: три лошади бегут одновременно

Делегирование — самый мощный координационный инструмент Hermes. Агент может порождать экземпляры под-агентов, распределяя задачи для параллельного выполнения.

Изолированный контекст. У каждого под-агента свой собственный контекст беседы, изолированный от остальных. Главный агент передаёт необходимый контекст при назначении задач, и каждый под-агент работает в своём пространстве.

Ограниченные тулсеты. Можно указать, какие инструменты может использовать каждый под-агент. Исследователю нужны только web и browser; кодеру — только terminal и file. Это одновременно и оптимизация эффективности, и мера безопасности.

Максимум 3 одновременно. Это ограничение осознанное. Три конкурентных под-агента покрывают большинство параллельных сценариев (исследование, разработка и тестирование одновременно), а больше уже сложно координировать.

—– Начало текста на картинке —– Основной агент Под-агент A Под-агент B Под-агент C → → → Декомпозиция задач Исследование Код Тестирование —– Конец текста на картинке —–

Если вы пользовались многозадачностью Claude Code, это покажется знакомым. Разница в том, что несколько экземпляров Claude Code вы открываете вручную, и координации между ними нет. Делегирование под-агентов в Hermes — это когда агент самостоятельно решает, когда распределять задачи и как собирать результаты.

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

Разрешения инструментов и песочница: слой ограничений в действии

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

Hermes реализует три уровня ограничений на уровне инструментов:

Контроль тулсетов. Агент может вызывать только те инструменты, которые включены в config.yaml — самый грубый переключатель.

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

Ограниченные тулсеты под-агентов. При делегировании под-агенту можно указать подмножество инструментов, которые ему разрешено использовать. Под-агенту, отвечающему за поиск, не нужен — и не должен быть — доступ к терминалу.

Если вы читали оранжевую книгу по Harness Engineering, вы узнаете — именно так слой ограничений (хуки/линтер) реализован в Hermes. Тот же принцип: дать агенту достаточно возможностей для выполнения задач, но не передавать ненужных разрешений.

Ключевая рекомендация

Для сценариев, чувствительных к безопасности (например, работа на продакшн-серверах), включайте только необходимые тулсеты и используйте по-серверную фильтрацию MCP, чтобы дополнительно ограничить инструменты, доступные агенту. Лучше пусть агент спросит «мне нужно разрешение XX», чем держать всё открытым по умолчанию.

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

§07 Установка и настройка: три подхода

Установка и настройка

От нуля до работающего агента за 5 минут. В этом разделе — три способа установки: от локальной разработки до круглосуточного сервера. Выберите подходящий.

Вариант 1: Локальная установка (5 минут до старта)

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

—– Начало текста на картинке —– 1 Запустите однострочный установщик —– Конец текста на картинке —–

Откройте терминал и вставьте:

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

Установщик автоматически настраивает Python, Node.js и все зависимости. Работает на macOS, Linux и WSL2.

2 Настройте LLM-бэкенд

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

# Расположение конфига
~/.hermes/config.yaml

Введите ваш API-ключ модели (о том, как выбрать модель — чуть позже).

3 Запустите Hermes

hermes

Всё — одно слово. Если увидели приветственное сообщение — всё работает.

Ключевая рекомендация

Если вы управляете Python через uv, можно также склонировать репозиторий и установить через uv pip install -e ".[all]". Результат тот же — используйте то, что удобнее.

Вариант 2: Docker (чистая изоляция)

Не хотите устанавливать кучу зависимостей на свою машину? Docker — самое чистое решение.

docker pull nousresearch/hermes-agent:latest
docker run -v ~/.hermes:/opt/data nousresearch/hermes-agent:latest

Ключевой флаг: -v ~/.hermes:/opt/data — монтирует том данных контейнера к вашей хост-машине. Всё состояние Hermes (память, навыки, конфиг) живёт в /opt/data — одна-единственная директория. Можете удалить и пересобрать контейнер — ваши данные сохранятся.

Это продуманное решение. В отличие от некоторых инструментов, разбрасывающих состояние по разным путям, в Hermes всё живёт в ~/.hermes/. Когда придёт время мигрировать — просто упакуйте эту директорию.

Вариант 3: VPS за $5 для круглосуточной работы

Если хотите, чтобы Hermes был всегда онлайн, независимо от того, включён ли ваш компьютер, — хватит VPS за $5 в месяц.

Рекомендуемые варианты:

Выберите Ubuntu 22.04 LTS, зайдите по SSH, запустите скрипт установки — идентично локальной установке. Если вы не запускаете локальные модели, потребление памяти остаётся ниже 500MB, так что VPS за $5 справляется с запасом.

В паре с Telegram-шлюзом (рассмотрено в §09) вы можете писать Hermes в любое время с телефона, а он отвечает с VPS. Цена чашки кофе — и у вас круглосуточный AI-помощник.

Бессерверный вариант: Hermes также поддерживает Daytona и Modal в качестве serverless-бэкендов. Окружение засыпает в простое и просыпается при входящих сообщениях, сводя затраты между сессиями к нулю. Отлично подходит для нечастого использования, когда вы всё ещё хотите оставаться на связи. Укажите terminal: daytona или terminal: modal в config.yaml.

config.yaml: глубокое погружение

Независимо от способа установки, вся основная конфигурация живёт в одном файле: ~/.hermes/config.yaml.

Минимальная рабочая конфигурация выглядит так:

# ~/.hermes/config.yaml
model:
  provider: openrouter        # Поставщик модели
  api_key: sk-or-xxxxx        # Ваш API-ключ
  model: anthropic/claude-sonnet-4  # Используемая модель
terminal: local               # Бэкенд терминала (local/docker/ssh/daytona/modal)
gateway:                      # Мессенджер-шлюз (опционально, подробнее в §09)
  telegram:
    token: YOUR_BOT_TOKEN
  discord:
    token: YOUR_BOT_TOKEN

Полей немного — разберём каждое.

provider и model

Hermes поддерживает широкий спектр источников моделей:

Важно

На апрель 2026 года Anthropic запретил сторонним инструментам доступ к Claude через подписки Pro/Max. Это затронуло Hermes, OpenClaw и все остальные Agent-фреймворки. Вы всё ещё можете использовать Claude через API-ключи (оплата по мере использования), но это обходится значительно дороже. Рассмотрите OpenRouter или серию Hermes 3 от Nous Portal в качестве основных вариантов.

Моя рекомендация: начните с OpenRouter, чтобы свободно переключать модели и понять, что вам подходит. Когда определитесь с основной моделью — подключайтесь напрямую к API этого провайдера, чтобы сэкономить на комиссии посредника.

terminal

Шесть бэкендов определяют, где Hermes выполняет код:

• local: Запускается прямо на вашей машине, самый простой вариант
• docker: Выполняется внутри контейнера, изолированно и безопасно
• ssh: Подключается к удалённому серверу
• daytona / modal: Serverless, запускается по требованию
• singularity: Для HPC-кластеров

Большинству достаточно local. Если вас беспокоит безопасность выполнения кода агентом на вашей машине — Docker будет хорошим компромиссом.

Частые проблемы

Важно

Скрипт установки завис? Проверьте сетевое подключение. Скрипту нужно скачать зависимости с GitHub и PyPI. Если вы находитесь в регионе с ограниченным доступом, возможно, понадобится настроить прокси или использовать зеркала.

Важно

Команда hermes не найдена? Скрипт установки добавляет команду в PATH, но если у вас нестандартная конфигурация оболочки (например, fish), может потребоваться вручную выполнить source ~/.bashrc или переоткрыть терминал.

Ключевая рекомендация

Хотите проверить установку? Выполните hermes --version — если увидели номер версии, всё готово. Последняя версия — v0.7.0.

Важно

Docker-контейнер запускается, но ничего не происходит? Убедитесь, что ~/.hermes/config.yaml существует и содержит информацию о модели. Контейнер читает конфиг, смонтированный с хоста. Если config.yaml не существует, Hermes предложит его создать при запуске.

Ключевая рекомендация

Заметка по безопасности для VPS: если запускаете на VPS, рассмотрите terminal: docker, чтобы код выполнялся внутри контейнера, а не напрямую на файловой системе хоста. VPS за $5 имеет достаточно мощности для запуска контейнеров.

На этом с конфигурацией всё. Философия дизайна Hermes — минимализм: один config.yaml управляет всем. Никаких разбросанных переменных окружения, никаких многослойных конфигов. Для такого функционально насыщенного агента сохранять конфигурацию такой простой — впечатляющая сдержанность.

Дальше — начинаем разговор. Hermes не требует настроить всё до того, как начать пользоваться — установите, добавьте API-ключ, запустите — и вы готовы к первому разговору.

§08 Ваш первый разговор: знакомство с Hermes

Первый разговор

Установили и запустили — что теперь? Этот раздел проведёт вас через первый разговор. Фокус не на том, что вы говорите, а на том, что Hermes делает за кулисами.

Начало с чистого листа

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

Скажите что угодно:

Привет, я Хуашу. Веду AI-блог в WeChat. Много пользовался Claude Code и хочу попробовать...

Hermes ответит как обычно. Но самое интересное происходит там, где вы этого не видите.

Память тихо записывается

После первого обмена взгляните на директорию ~/.hermes/:

~/.hermes/
├── config.yaml          # Ваша конфигурация
├── state.db             # SQLite-база (история разговоров + FTS5-индекс)
├── skills/              # Директория навыков (пока пуста)
│   └── bundled/         # Встроенные навыки
└── memories/            # Постоянная память (MEMORY.md + USER.md)

В state.db уже есть данные. Ваше представление и ответ Hermes записаны в SQLite-базу с полнотекстовым индексом FTS5. В следующий раз, когда вы запустите Hermes, он не начнёт с нуля — он сможет найти и использовать этот разговор.

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

Поболтай ещё несколько раундов. Расскажи о своих рабочих привычках, например:

Я на macOS, мой основной редактор — Cursor. Пишу статьи в Markdown и предпочитаю угловые кавычки вместо звёздочек.

Hermes запишет это в свой слой постоянной памяти. Соответствие трёхуровневой памяти из S04: содержание разговора — это сессионная память (что произошло), а твои предпочтения и привычки — постоянная память (кто ты есть).

Не нужно специальной команды вроде «запомни это». Hermes сам решает, какую информацию стоит сохранять. Если ты пользовался авто-памятью Claude Code, ощущение будет знакомым. Но Hermes действует агрессивнее — он proactively выбирает стратегию запоминания.

Запуск Первого Создания Навыка

Дай Hermes задачу чуть сложнее:

Сконвертируй этот Markdown в HTML, совместимый с блогами WeChat, сохранив форматирование жирного текста и блоков кода.

В первый раз Hermes разберётся по ходу дела. Он может запустить скрипт через терминал или сгенерировать HTML прямо в диалоге.

После завершения начинается самое интересное. Загляни в ~/.hermes/skills/ снова:

~/.hermes/skills/
├── bundled/          # Встроенные навыки
└── markdown-to-wechat.md  # Это новый!

Hermes автоматически извлёк решение в Навык. Открой этот markdown-файл — ты увидишь, что там записаны формат входных данных, правила конвертации и требования к выходу. В следующий раз, когда попросишь о чём-то похожем, он задействует этот Навык напрямую, вместо того чтобы разбираться с нуля.

Это и есть обучающий цикл из S03 в действии. Ты не учил его, как делать — он сам кристаллизовал выполненную работу в переиспользуемую способность.

Самоулучшение Навыка: Если результат тебя не устраивает, скажи, что нужно поправить. Hermes не просто исправит текущий вывод — он обновит и файл Навыка. В следующий раз улучшенная версия сработает автоматически.

Не Нужно Настраивать — Просто Используй

Давай подведём итог того, что произошло:

—– Начало текста с картинки —– Ты casually поболтал → Hermes построил твой профиль → Ты дал задачу → Hermes автоматически создал Навык —– Конец текста с картинки —–

На протяжении всего процесса ты не написал ни строчки конфига, не отредактировал ни одного файла, не задал ни одного правила. Это кардинально другой опыт по сравнению с тем, как Claude Code просит вручную написать CLAUDE.md, или OpenClaw требует настраивать yaml.

Разумеется, ты можешь редактировать файлы Навыков вручную (об этом в S10), но на старте это совершенно не обязательно. Просто используй — Hermes сам примет форму, которая тебе подходит.

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

Следующий раздел — давай выведем Hermes за пределы терминала, прямо в твой телефон.

§09 Многоплатформенный Доступ: Дотянись Откуда Угодно

Многоплатформенный Доступ

Hermes живёт не только в терминале. Настрой Telegram-бота — и пользуйся им с телефона в любое время. Добавь Discord и Slack — и твоя команда сможет его использовать. Главное: все платформы разделяют один и тот же мозг.

Gateway: Один Процесс, Все Платформы

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

—– Начало текста с картинки —– Telegram → Messaging Gateway ← Discord —– Конец текста с картинки —–

Под капотом Gateway находится тот же экземпляр Hermes Agent, та же память, тот же набор Навыков. Сообщение из Telegram и команда из CLI неразличимы для Hermes.

Настройка Telegram-бота (Рекомендуемая Точка Входа)

Почему Telegram? Он проще всего настраивается и даёт лучший мобильный опыт. Создание бота не требует одобрения — токен выдаётся мгновенно.

1. Создай Telegram-бота

Найди @BotFather в Telegram, отправь /newbot и следуй подсказкам, чтобы дать имя. BotFather выдаст токен, который выглядит так:

123456789:ABCdefGhIJKlmNoPQRsTUVwxyz

2. Добавь его в config.yaml

# ~/.hermes/config.yaml
gateway:
  telegram:
    token: 123456789:ABCdefGhIJKlmNoPQRsTUVwxyz

3. Запусти Hermes

hermes

Hermes автоматически подключается к Telegram Gateway при запуске. Отправь своему боту сообщение в Telegram — он ответит.

Три шага, меньше двух минут. Если Hermes запущен на VPS (конфигурация за $5 из S07), ты получаешь круглосуточного, всегда доступного, с постоянной памятью персонального AI-ассистента. $5/месяц + стоимость API модели.

Telegram также поддерживает голосовые сообщения. Отправь голосовую заметку — Hermes автоматически расшифрует её в текст перед обработкой. Пришла идея по дороге? Просто скажи её — печатать не нужно.

Интеграция Discord и Slack

Процесс аналогичен Telegram, различия в основном в способе получения токена.

Discord

Перейди в Discord Developer Portal, создай Application и возьми токен со страницы Bot:

gateway:
  discord:
    token: YOUR_DISCORD_BOT_TOKEN

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

Slack

gateway:
  slack:
    token: xoxb-YOUR-SLACK-BOT-TOKEN

Понадобится создать App на странице управления Slack-приложениями и установить его в свою рабочую область. Настройка разрешений чуть сложнее, чем в Telegram, но это более корпоративный вариант, с которым комфортно работают IT-отделы.

Доступно больше платформ: Hermes также поддерживает WhatsApp, Signal, Email, SMS (Twilio), Home Assistant, Mattermost, Matrix, DingTalk, Feishu/Lark, WeCom и Open WebUI — всего 14 платформ. Полный список — на странице Messaging в официальной документации. Для большинства нужен только соответствующий токен в config.yaml.

Сквозная Непрерывность Разговора

Это самая практичная особенность многоплатформенной архитектуры Hermes.

Представь: утром по дороге на работу ты пишешь Hermes в Telegram:

Исследуй варианты развёртывания Hermes Agent и подготовь мне документ.

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

Как продвигается исследование? Покажи, что получилось.

Hermes точно знает, о чём ты говоришь. Ему не важно, с какой платформы пришло сообщение — все платформы используют один экземпляр агента и одну память. То, что ты сказал в Telegram, можно продолжить в CLI. То, что обсуждалось в канале Discord, можно упомянуть из Slack.

Это совершенно не похоже на разные окна ChatGPT на разных устройствах, где каждый раз приходится заново объяснять контекст. У Hermes один мозг, независимо от того, через какую дверь ты входишь.

Практическая Конфигурация Развёртывания

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

$5 VPS (Ubuntu 22.04)
├── Hermes Agent Core
├── Messaging Gateway
│   ├── Telegram Bot (доступен с телефона)
│   ├── Discord Bot (командная коллаборация)
│   └── Slack App (корпоративное использование)
├── ~/.hermes/
│   ├── state.db (вся история разговоров)
│   ├── skills/ (способности, накапливаемые автоматически)
│   └── config.yaml (один файл, всё настроено)
└── Model calls → OpenRouter API

Итоговая стоимость: VPS $5/месяц + плата за API модели (при лёгком использовании — $2-5/месяц). Меньше, чем чашка дорогого кофе в месяц, за AI-ассистента с памятью, реальными возможностями и доступностью 24/7.

По стоимости API моделей: если хочешь ещё больше сэкономить, можно запускать открытые модели на VPS через Ollama (например, Hermes 3 13B). VPS за $5 может не хватить RAM для больших моделей, но VPS за $10-15/месяц справится с 13B, и после этого вызовы моделей становятся полностью бесплатными.

Автоматические Задачи по Расписанию

Помимо пассивного ответа на сообщения, Gateway также поддерживает cron-планировщик. Ты можешь настроить Hermes на автоматическую отправку утреннего дайджеста новостей каждый день в 8 утра или автоматическое обобщение GitHub-коммитов за неделю каждую пятницу.

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

На этом этапе у тебя есть работающая конфигурация Hermes: установленная локально или на VPS, с настроенной моделью, доступная с телефона. Дальше: как вручную создавать и оптимизировать Навыки (S10) и как подключать больше инструментов через MCP (S11), чтобы сделать ассистента ещё более мощным.

§10 Пользовательские Навыки: Обучаем Hermes Новым Фокусам

Пользовательские Навыки: Обучаем Hermes Новым Фокусам

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

Что Такое Навык

В Hermes Навык — это просто markdown-файл. Никаких фреймворков для изучения, никаких API-вызовов — просто текст, который объясняет Hermes, что делать в конкретном сценарии.

Идея та же, что и у CLAUDE.md: определить поведение на естественном языке. Разница в том, что CLAUDE.md применяется глобально, а Навыки активируются по запросу. Попроси Hermes написать еженедельный отчёт — он загрузит Навык «еженедельный отчёт»; попроси сделать ревью кода — загрузит другой.

Каждый Навык живёт в своей папке в ~/.hermes/skills/, с файлом SKILL.md в качестве точки входа. Папка Навыка также может содержать поддиректории references/, templates/ и scripts/ для вспомогательных файлов.

Создание Навыка Вручную

Давай напишем Навык, который действительно полезен: заставим Hermes соблюдать единый формат сообщений Git-коммитов.

Создай папку git-commit-style/ в ~/.hermes/skills/, а внутри неё — файл SKILL.md:

___
name: git-commit-style
description: Enforce a consistent Git commit message format
version: "1.0.0"
___

# Git Commit Style

## Trigger

Activate when the user asks me to commit code, write a commit message, or review commit history.

## Rules

### Commit Message Format
- First line: type(scope): summary (50 chars max)
- Blank line
- Body: explain WHY, not WHAT

### Type Enum
- feat: new feature
- fix: bug fix
- refactor: restructure (no behavior change)
- docs: documentation
- test: tests
- chore: build/toolchain

### Constraints
- Body in plain language, types in English
- Don't write "modified XX file" — that's noise
- One commit, one thing

## Example

feat(auth): add WeChat QR code login

Previously users could only log in with a phone number, which meant WeChat users had to bind a phone first. Now they scan a QR code and they’re in — unbound users get an account created automatically.

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

Срабатывание Навыка происходит автоматически. Не нужно говорить «используй Навык такой-то» — Hermes сам подбирает наиболее подходящий Навык под твой запрос. Под капотом используется полнотекстовый поиск FTS5 плюс семантическое понимание.

Анатомия Хорошего Навыка

После написания десятков Навыков я обнаружил, что у них общая структура:

Чем конкретнее триггер, тем выше точность срабатывания. «Когда пользователь упоминает код» — слишком размыто; «Когда пользователь просит закоммитить код, написать сообщение коммита или просмотреть историю коммитов» — гораздо лучше.

Установка Навыков из Skills Hub

У Hermes есть встроенный Skills Hub, где разработчики из сообщества делятся готовыми Навыками. Установка проста:

1. Просмотр доступных Навыков

Просто спроси Hermes в разговоре: «Какие Навыки сообщества доступны?» Он перечислит популярные Навыки из Hub, сгруппированные по категориям. Можно и уточнить: «Есть что-нибудь связанное с Python?»

2. Установка

Нашёл тот, что нравится? Скажи Hermes «Установи Навык такой-то». Он скачает папку Навыка в ~/.hermes/skills/, и он вступит в силу немедленно. Перезагрузка не требуется.

3. Настройка

Установленный Навык — это просто папка с файлом SKILL.md: открой и редактируй. Навыки сообщества — это отправная точка; сделать их своими — вот цель.

Hermes поставляется с 40+ встроенными Навыками, охватывающими MLOps, рабочие процессы GitHub, помощь в исследованиях и многое другое. Они встроенные — дополнительной установки не требуется.

Отладка Навыков

Ты написал Навык — как узнать, срабатывает ли он?

Просто спроси. Скажи «Какие Навыки у тебя сейчас загружены?» — и Hermes скажет, какие активны. Если ожидаемого нет, значит твой триггер слишком узкий.

Проверь логи. Лог-файлы записывают, какие Навыки сопоставились с каждым запросом, почему они были выбраны и почему другие были пропущены. Логи живут в ~/.hermes/logs/.

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

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

Практический Пример: Перенос Навыка из Claude Code в Hermes

Вот очень практичная задача: ты накопил отличную коллекцию Навыков в Claude Code и не хочешь начинать с нуля после перехода на Hermes. Стандарт agentskills.io делает Навыки переносимыми между Агентами, так что затраты на миграцию невелики.

Позволь показать реальный пример. У меня был Навык «WeChat blog proofreading» в Claude Code — его основная логика выполняет три прохода вычитки (факты, стиль, детали). SKILL.md выглядел примерно так:

___
name: proofreading
description: Three-pass proofreading for articles
version: "1.0.0"
___

# Article Proofreading

## Trigger
Activate when the user mentions "proofread," "reduce AI tone," "too AI-like," or "polish."

## Proofreading Flow
### Pass 1: Fact Check
- Verify all data, dates, product names
- Flag anything uncertain

### Pass 2: Style Check
- Remove AI-favorite phrases (firstly/secondly/in conclusion)
- Break up AI sentence patterns
- Replace formal vocabulary with conversational language

### Pass 3: Detail Polish
- Keep sentences to 15-25 words
- Keep paragraphs to 3-5 lines on a phone screen
- Bold ~10 key sentences for scanability

Скопируй этот файл в ~/.hermes/skills/proofreading/SKILL.md, и Hermes сможет использовать его немедленно. Никаких изменений формата, никаких API-адаптеров — все используют markdown с одинаковой семантической структурой.

Если твой Навык ссылается на инструменты, специфичные для Claude Code (например, на определённый MCP-сервер), их придётся заменить на эквиваленты Hermes. Но основная логика, триггеры и правила — всё переносимо.

Почему важен agentskills.io: Навыки больше не привязаны к одному Агенту. Навыки, созданные тобой в Claude Code, Cursor или Gemini CLI, работают в Hermes. И наоборот. Ты можешь менять Агентов, не беспокоясь о затратах на миграцию.

Дальше: интеграция MCP. Навыки учат Hermes, что делать; MCP позволяет ему подключаться к внешним инструментам. Соедини их вместе — и диапазон сценариев, которые ты можешь охватить, становится очень широким.

§11 MCP Интеграция: Подключаем Свой Инструментарий

MCP Интеграция: Подключаем Свой Инструментарий

40+ встроенных инструментов Hermes уже довольно мощные, но реальные рабочие процессы уходят далеко за их пределы. MCP позволяет Hermes подключаться к GitHub, базам данных, Slack, Jira и тысячам других внешних сервисов — без написания ни строчки кода-адаптера.

MCP расшифровывается как Model Context Protocol — открытый стандарт, предложенный Anthropic в конце 2024 года. Представьте его как USB-порт в мире AI-инструментов: пока MCP-сервер реализует этот протокол, любой совместимый с MCP Агент может вызывать предоставляемые им инструменты.

Для Hermes MCP означает, что не нужно писать кастомный инструмент под каждый внешний сервис. Хотите подключиться к GitHub? Установите MCP-сервер GitHub. Нужно выполнить запрос к базе данных? Установите MCP-сервер базы данных. В сообществе уже тысячи готовых серверов.

Два режима подключения: stdio и HTTP

Hermes поддерживает два способа подключения к MCP-серверам — в зависимости от того, где запущен сервер.

Для большинства случаев достаточно stdio. MCP-сервер запускается как подпроцесс Hermes, общаясь через stdin/stdout — быстро и просто в настройке. HTTP нужен, когда сервер должен быть развёрнут независимо или доступен нескольким Агентам одновременно.

Конфигурация задаётся в секции mcp_servers файла config.yaml:

# stdio mode
mcp_servers:
  github:
    command: "npx"
    args: ["-y", "@modelcontextprotocol/server-github"]
    env:
      GITHUB_PERSONAL_ACCESS_TOKEN: "ghp_xxxxx"

# HTTP mode
mcp_servers:
  remote-tools:
    url: "https://your-server.com/mcp"
    transport: "streamable-http"

Практика: подключаем GitHub MCP

GitHub — одна из самых частых интеграций MCP. После подключения Hermes может создавать Issues, открывать PR, ревьюить код и управлять досками проекта напрямую.

1 Создайте токен GitHub

Перейдите в GitHub Settings → Developer settings → Personal access tokens и сгенерируйте токен. Как минимум отметьте repo и read:org. Если хотите управлять Issues и PR, включите также права на запись для issues и pull_requests.

2 Настройте config.yaml

Добавьте MCP-сервер GitHub в config.yaml:

mcp_servers:
  github:
    command: "npx"
    args: ["-y", "@modelcontextprotocol/server-github"]
    env:
      GITHUB_PERSONAL_ACCESS_TOKEN: "ghp_your_token_here"

Совет: храните токен в переменной окружения вместо жёсткой вставки. Его можно подставить через ${GITHUB_TOKEN}.

3 Перезапустите Hermes и проверьте

После перезапуска спросите Hermes: «Список моих GitHub-репозиториев» или «Покажи последние Issues в репозитории XX». Если приходят корректные данные — подключение работает.

4 Ежедневное использование

После подключения вы можете работать с GitHub на естественном языке. Например:

«Создай Issue в alchaincyf/my-app с заголовком “Исправить баг редиректа на странице входа”» «Посмотри изменения в этом PR и сделай код-ревью» «Какие новые Issues открыты за последнюю неделю? Сгруппируй по меткам»

GitHub MCP предоставляет инструменты для управления репозиториями, работы с Issues, ревью PR, поиска кода, управления ветками и многого другого. Вам не нужно запоминать названия инструментов — просто опишите, что нужно, обычным языком, и Hermes выберет правильный инструмент.

Практика: подключаем базу данных

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

На примере PostgreSQL:

mcp_servers:
  postgres:
    command: "npx"
    args: ["-y", "@modelcontextprotocol/server-postgres"]
    env:
      POSTGRES_CONNECTION_STRING: "postgresql://user:pass@localhost:5432/mydb"

После настройки вы можете спросить Hermes: «Сколько пользователей зарегистрировалось в этом месяце?» или «Покажи ежедневную выручку по заказам за последние 30 дней» — он сгенерирует SQL, выполнит его и вернёт результат.

Внимание

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

У SQLite и MySQL тоже есть свои MCP-серверы. Конфигурация почти идентична — достаточно заменить имя пакета сервера и строку подключения.

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

Когда вы подключаете несколько MCP-серверов, список доступных инструментов быстро растёт. Один только GitHub-сервер предоставляет дюжину с лишним инструментов; добавьте базы данных, файловую систему и Slack — и получите пятьдесят-сто инструментов.

Слишком много инструментов снижает качество решений Агента. Точность выбора при 100 инструментах ниже, чем при 20. А некоторые инструменты вы вообще не хотите, чтобы Агент трогал.

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

mcp_servers:
  github:
    command: "npx"
    args: ["-y", "@modelcontextprotocol/server-github"]
    env:
      GITHUB_PERSONAL_ACCESS_TOKEN: "ghp_xxxxx"
    allowed_tools:
      - "list_issues"
      - "create_issue"
      - "get_pull_request"
      - "create_pull_request_review"

Так, даже если MCP-сервер GitHub предлагает высокопривилегированные инструменты (вроде удаления репозиториев или изменения настроек), Hermes не сможет ими воспользоваться. Принцип минимальных привилегий в эпоху Агентов важен как никогда.

Когда использовать MCP, а когда встроенные инструменты

У Hermes более 40 встроенных инструментов, а MCP открывает ещё тысячи. Как выбирать?

Простое практическое правило: если у Hermes уже есть встроенная возможность — используйте встроенную; если нужно взаимодействие с внешним сервисом — используйте MCP.

Некоторые сценарии работают и так, и так — например, Git-операции. Инструмент терминала может выполнять git-команды напрямую, а GitHub MCP тоже может работать с репозиториями. Разница в том, что терминал работает локально — отлично подходит для повседневных коммитов и пущей в вашем текущем репозитории; а GitHub MCP работает через API — лучше подходит для кросс-репозиторного управления, массовых операций с Issues и ревью PR, которым нужны возможности на уровне платформы.

Практический совет: не подключайте дюжину MCP-серверов в первый же день. Начните с одного-двух, которые используете чаще всего (GitHub, база данных), освоитесь, а затем добавляйте остальные. Каждый дополнительный сервер расширяет пространство выбора инструментов и удлиняет путь принятия решений.

MCP + Навыки: комбо

MCP отвечает на вопрос «к чему я могу подключиться», а Навыки — «как это использовать». Вместе они работают лучше.

Пример: вы подключаете GitHub MCP и создаёте Навык «Код-ревью». Навык определяет критерии проверки (соглашения об именовании, обработка ошибок, покрытие тестами), а MCP предоставляет возможность читать диффы PR. Вместе Hermes может автоматически ревьюить код по вашим стандартам.

Другой пример: MCP базы данных позволяет Hermes выполнять SQL, а Навык «Еженедельный отчёт» задаёт формат отчёта и ключевые метрики. Добавьте к этому крону по пятницам после обеда — и Hermes автоматически запросит данные, сформирует отчёт и отправит его в Slack. MCP, Навыки и встроенные инструменты, работающие сообща — вот где настоящая сила.

На этом вы знаете все ключевые возможности Hermes. Следующая часть переходит к реальным сценариям, показывая, как эти возможности выглядят в комбинации.

§12 Личный ассистент знаний: сила кросс-сессионной памяти

Личный ассистент знаний: сила кросс-сессионной памяти

Насколько велика разница между AI-ассистентом, который действительно помнит, и тем, кому приходится каждый день заново представляться? Давайте разберёмся на примере проекта, растянувшегося на три недели.

Три недели исследований, каждый раз с нуля

Представьте, что вы исследуете новую область. Вы независимый разработчик, пытающийся разобраться с вариантами развёртывания AI-Агентов в 2026 году: локально, в облаке, Serverless — какие подводные камни у каждого подхода.

Первая неделя: вы задаёте три-четыре вопроса — про потребление памяти при Docker-развёртывании, цены на VPS, ограничения бесплатного тарифа Daytona. Эта информация оказывается размазанной по разным диалогам.

Вторая неделя: вы хотите глубже изучить Serverless. Вы открываете ChatGPT или Claude — и что первым делом делаете? Заново объясняете, над чем работаете.

«Я исследую варианты развёртывания AI-Агентов. На прошлой неделе смотрел Docker и VPS, теперь хочу разобраться с Serverless. Выяснил, что у Daytona есть бесплатный тариф, но с ограничениями…»

Каждый новый диалог стоит 3–5 минут на восстановление контекста. Это не проблема возможностей AI — это архитектурная проблема: у традиционного AI нет кросс-сессионной памяти, поэтому каждый разговор начинается с чистого листа.

Что помнит Hermes

Тот же сценарий, но с Hermes.

После разговоров первой недели три уровня памяти Hermes записали разную информацию:

Вторая неделя: вы открываете Hermes и просто говорите: «Давай продолжим с Serverless-вариантами». Не нужно ничего объяснять заново — постоянная память уже знает, чем вы занимаетесь. Она может даже проактивно напомнить: «На прошлой неделе вы упомянули, что у Daytona есть ограничения бесплатного тарифа — проверить, не обновилась ли политика?»

Это не магия — это работа полнотекстового поиска FTS5. Hermes не пихает все прошлые диалоги целиком в контекст (это было бы пустой тратой токенов). Вместо этого он извлекает наиболее релевантные исторические фрагменты на основе вашего текущего вопроса.

Извлечение против полной загрузки контекста

Этот архитектурный выбор стоит разобрать подробнее.

Многие думают, что «память» означает запихивание всей истории переписки в промпт. Automemory в Claude Code работает именно так: ключевая информация записывается в MEMORY.md, который при старте грузится целиком. Для кодинга это нормально.

Но сценарий ассистента знаний — другой. Три недели исследовательских диалогов — это десятки тысяч слов. Загрузка всего вызывает две проблемы: взрыв стоимости токенов и ухудшение качества ответов из-за информационной перегрузки. У больших моделей неравномерное распределение внимания по очень длинным контекстам, и ключевая информация тонет.

Подход Hermes: постоянная память хранит краткие сводки (несколько сотен слов), а когда нужны детали — FTS5 ищет по сырым диалогам, внедряя в контекст только самые релевантные фрагменты. Это как носить с собой шпаргалку на одну страницу и возвращаться к картотеке только когда понадобятся подробности.

Honcho: знает вас лучше, чем вы сами

Если включить пользовательское моделирование Honcho, глубина памяти выходит на новый уровень.

Honcho не просто записывает то, что вы сказали — он делает выводы о том, чего вы не сказали. Например, если вы последовательно выбираете самый дешёвый вариант в трёх исследовательских сессиях, Honcho заключает: «этот пользователь чувствителен к стоимости». В следующий раз, когда он что-то рекомендует, информация о цене будет показана в первую очередь.

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

Опыт HuaShu: через две недели Hermes начал автоматически давать мне более короткие и ёмкие ответы — потому что заметил, что я склонен хотеть выводы, а не пространные рассуждения. Эта адаптация происходит постепенно; вам не нужно ничего явно настраивать.

Разница в опыте по сравнению с традиционным AI

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

Если говорить конкретно о сценарии ассистента знаний, разница проявляется в трёх вещах:

Нулевая стоимость входа

Не нужно каждый раз восстанавливать контекст. Скажите «продолжим» — и продолжаете.

Исследование имеет непрерывность

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

Методология накапливается

Подход, который Hermes вырабатывает, помогая вам с первым исследовательским проектом (определить измерения, погрузиться в каждое, подвести итог по раунду), сохраняется как Навык. Второй исследовательский проект использует его автоматически — не нужно учить заново.

Ключевая рекомендация: Кросс-сессионная память — не серебряная пуля. Если задача одноразовая — например, «переведи этот абзац» — система памяти Hermes не даёт никакого преимущества. Ценность памяти масштабируется с длительностью задачи. Чем задача длиннее и контекстно-насыщеннее, тем больше выигрыш в эффективности от памяти.

§13 Автоматизация разработки: от код-ревью до деплоя

Автоматизация разработки: от код-ревью до деплоя

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

Утро разработчика

9 утра, вы открываете ноутбук. Три сообщения в Telegram. Не от коллеги — от Hermes:

«Прошлой ночью в 23:17 PR был влит в main — 387 новых строк кода. Я провёл ревью и нашёл две проблемы: логика истечения токенов в модуле аутентификации не обрабатывает граничный случай, а покрытие тестами упало с 82% до 76%. Полный отчёт сохранён в Навык проекта.»

«В 2:40 ночи CI-пайплайн прогнал регрессионные тесты. 3 кейса упали. 2 внесены вчерашним PR, 1 — известный флакающий тест.»

«Черновик ежедневного стендапа подготовлен на основе вчерашних 4 коммитов и 2 PR. Нужна ваша подпись перед отправкой.»

Это не гипотетика. Cron-планировщик Hermes + GitHub MCP + система памяти позволяют ему работать, пока вы спите.

Автоматизированное код-ревью

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

Настройка автоматического код-ревью с Hermes проста:

1 Подключите GitHub MCP

Настройте MCP-сервер GitHub в config.yaml, чтобы Hermes мог читать PR, диффы и Issues вашего репозитория.

2 Настройте cron-расписание

Скажите Hermes на обычном языке: «Проверяй новую ветку main на новые PR каждые 6 часов и делай код-ревью.» Он автоматически создаст cron-задачу.

3 Определите стандарты ревью

Опишите ваши стандарты кодирования как Навык. Например: «Функции не должны превышать 50 строк», «Обработка ошибок должна использовать кастомные типы», «У всех API-эндпоинтов должны быть тесты». Hermes проверяет каждый PR на соответствие этим стандартам.

Третий шаг — ключевой. Стандарты ревью — это Навык, и он развивается автоматически на основе вашей обратной связи. Вы указываете на проблему, которую Hermes пропустил — и в следующий раз он отслеживает этот паттерн. Традиционные линтер-правила статичны; стандарты ревью Hermes — живые.

Не выбор — комбинация

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

За последний год экосистема AI-агентов породила невероятное количество инструментов. Но три, на мой взгляд, действительно заслуживают пристального внимания — это Claude Code, OpenClaw и Hermes Agent.

Не потому что они самые разрекламированные, а потому что они представляют три принципиально разных подхода к архитектуре.

Claude Code — интерактивный инструмент для программирования. Ты сидишь в терминале, ставишь задачу, и он пишет код, запускает тесты, коммитит в git. Ты присутствуешь всё время — как парное программирование с очень способным инженером. Ключевая ценность — продуктивность написания кода в реальном времени.

OpenClaw — это фреймворк «конфигурация как поведение». Ты определяешь личность, знания и навыки агента целиком через файлы SOUL.md и Skill. Конфигурационные файлы определяют, чем является агент. Ключевая ценность — предсказуемость, аудируемость и воспроизводимость.

Hermes Agent — это автономный фоновый движок. Ты разворачиваешь его на сервере, и он работает 24/7 — запоминает, создаёт Навыки, самосовершенствуется. Ключевая ценность — автономность и самоулучшение.

Чувствуешь разницу? Эти три инструмента даже не решают одну и ту же задачу.

Какой инструмент для какого сценария

Я полгода пользовался Claude Code, несколько месяцев — OpenClaw, а последнее время экспериментирую с Hermes. Мой вывод: выбор инструмента не в том, какой мощнее, а в том, какая модель взаимодействия подходит твоему сценарию.

Последняя строка важна. Многие сценарии не закрыть одним инструментом. В долгосрочном контент-проекте Hermes занимается ежедневным автоматическим сбором информации и накоплением памяти, а Claude Code садится и пишет текст. Каждый владеет своим этапом эстафеты.

Конвергенция или дивергенция

Вот интересная закономерность: эти три инструмента учатся друг у друга.

Claude Code добавил авто-память, двигаясь к Hermes-стилю постоянной памяти. В ClawHub от OpenClaw — 5700+ навыков сообщества; Hermes строит свой собственный Skill Hub. Hermes поддерживает стандарт agentskills.io, то есть может напрямую использовать навыки из экосистемы Claude Code.

Похоже на конвергенцию. Но я думаю, что фундаментальная дивергенция на самом деле усиливается.

Claude Code — это по сути диалог человека и ИИ в реальном времени. Сколько бы памяти и автоматизации ни добавляли, факт что ты сидишь и смотришь, как он работает, не изменится. Эту модель диктует бизнес-модель Anthropic: подписка, оплата от времени использования.

Hermes — это по сути ИИ, работающий автономно в фоне. Сколько бы интерактивных интерфейсов ни добавляли, его ключевая ценность — что он продолжает работать, когда тебя нет. Это диктует модель MIT-открытого исходника + самостоятельное развёртывание.

OpenClaw стоит посередине. Он не делает упор на реальное время, как Claude Code, ни на автономную работу, как Hermes. Его уникальная ценность — «прозрачность и управляемость». SOUL.md позволяет с одного взгляда понять, что агент будет и не будет делать. Для корпоративных сценариев с требованиями комплаенса это свойство незаменимо.

agentskills.io: почему совместимость навыков важна

В начале 2026 года стандарт agentskills.io начал набирать поддержку среди множества инструментов. Сейчас его поддерживают 16+ инструментов, включая Claude Code, Cursor, OpenAI Codex, Gemini CLI и Hermes.

Что это значит?

Это значит, что навык, написанный для Claude Code, можно напрямую использовать в Hermes. Навык, созданный внутри Hermes, можно перенести в Claude Code. Навыки больше не привязаны к конкретному инструменту — они становятся переносимыми единицами возможностей.

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

Время, вложенное в написание навыков, не пропадёт при смене инструмента. Твоя библиотека навыков — твой собственный актив, а не придаток платформы.

В ClawHub от OpenClaw — 5700+ навыков. Если эти навыки можно вызывать напрямую из Hermes через стандарт agentskills.io, границы возможностей Hermes расширяются мгновенно. И наоборот, навыки, которые Hermes создаёт и улучшает автоматически, могут поступать обратно в более широкую экосистему.

Не выбор — а комбинация

Написав три оранжевые книги (Claude Code, Harness Engineering, OpenClaw), я вынес главный урок: победителем будет не какой-то один инструмент — а те, кто умеет их комбинировать.

Мой собственный рабочий процесс — уже комбинация. Claude Code делает всё, что требует моего присутствия: написание статей, написание кода, продуктовые решения. Это моя «дневная смена».

Hermes (или аналогичные автономные агенты) делает то, что не требует моего присутствия: мониторинг репозиториев, запуск плановых исследований, поддержание баз знаний. Это моя «ночная смена».

SOUL.md и система навыков OpenClaw дают мне стандартизированный язык конфигурации. Независимо от того, работает ли под капотом Claude Code или Hermes, поведенческие ограничения прописываются одинаково.

Мнение Хуашу: не «выбирай» между этими тремя инструментами. Задай себе три вопроса: какие задачи требуют моего наблюдения? Какие задачи могут работать в фоне? Какие сценарии требуют прозрачной аудируемости? Ответы сами расставят инструменты по своим местам.

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

Действительно интересный вопрос не «какой лучше», а «как заставить их сотрудничать». agentskills.io уже прокладывает эту дорогу.

§17 Границы самосовершенствующихся агентов: как далеко они могут зайти

Границы самосовершенствующихся агентов

Самая захватывающая возможность Hermes — она же и самая тревожная.

Возвращаясь к той диаграмме

В финальной главе оранжевой книги Harness Engineering я писал о диаграмме, которую нарисовал Киф Моррис. Три слоя: в петле (in the loop), над петлёй (on the loop), вне петли (out of the loop).

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

Мой вывод тогда был, что «над петлёй», вероятно, лучший баланс. Ты не дублируешь усилия, но всё ещё присутствуешь.

Hermes Agent выводит эту дискуссию на новый уровень.

Его цикл обучения автоматический. Он сам создаёт навыки, сам улучшает навыки, сам решает, что запомнить. После развёртывания он становится сильнее. Это уже не «над петлёй». Тебе даже не нужно настраивать поводья — поводья растут сами.

Это прогресс или риск?

Может ли самоулучшение навыков выйти из-под контроля

Давайте начнём с технического уровня. У самоулучшения навыков Hermes есть несколько ограничений.

Файлы навыков — читаемый markdown. Не чёрные ящики весов нейросети — это текст, который можно открыть и прочитать. Что изменилось — видно в diff-е.

Данные памяти — локальные. Построены на SQLite + FTS5, данные лежат на твоём локальном диске. Можно просмотреть и удалить напрямую. Нет ситуации «агент тайно выучил то, о чём ты не знаешь».

Разрешения инструментов изолированы. Агент не может произвольно получать новые системные разрешения; набор инструментов должен быть явно сконфигурирован.

Технически самоулучшение Hermes контролируемо и аудируемо. Ты видишь, что изменилось, можешь откатить, удалить.

Но техническая контролируемость не означает практическую.

Проблема на стороне человека.

Ты действительно будешь каждый день проверять, какие навыки изменил агент? Аудировать базу памяти? Скорее всего, нет. Весь смысл развёртывания Hermes в том, чтобы «не сидеть с ним». Если бы нужно было ежедневно проверять результаты самоулучшения — чем это отличается от ручного поддержания навыков?

Это фундаментальное противоречие: ценность автономного агента в том, что за ним не надо следить, но безопасность требует следить.

Проницательность Кифа Морриса снова работает: разница между «в петле» и «над петлёй» становится наиболее очевидной, когда тебя не устраивает результат. Но если агент самоулучшил навык, а ты никогда не заметил ничего плохого — когда ты вообще это поймаешь?

Выбор Nous Research

Команда-основатель Nous Research сделала чёткий выбор в этом вопросе: приоритет пользовательского контроля.

Они прямо заявили, что модели должны быть «управляемыми» (steerable) — пользователь может настраивать поведение по необходимости, без ограничений корпоративной политики контента.

Это не просто слова. MIT-лицензия Hermes Agent означает, что ты владеешь всем исходным кодом. Ты можешь аудировать каждый шаг логики цикла обучения, изменять пороги, частоту и масштаб самоулучшения, или отключить автоматическое создание навыков вовсе.

По сравнению с закрытыми агентами, эта прозрачность даёт тебе фундамент: в худшем случае ты видишь, что делает весь код.

Но скажу неудобную вещь.

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

Open source vs закрытый код: разные формы доверия

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

Интуитивный ответ — открытый. Прозрачный код, аудит сообщества, MIT-лицензия.

Но реальность тоньше интуиции.

Claude Code — закрытый. Ты не знаешь, что внутри у агента Anthropic. Но у Anthropic есть чёткий коммерческий стимул держать поведение агента предсказуемым: если агент выйдет из-под контроля и навредит кодовой базе пользователя, они потеряют подписчиков. Бизнес-давление — это форма ограничения.

Hermes — открытый. Ты видишь весь код. Но если самоулучшение агента создаст проблему, у Nous Research нет коммерческого обязательства это исправлять. Обратная сторона MIT-лицензии: ты несёшь последствия.

Две формы доверия: одна — «я доверяю твоим бизнес-стимулам», другая — «я доверяю своей способности аудировать».

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

Где потолок самоулучшения

Вернёмся к главному вопросу: как далеко могут зайти самосовершенствующиеся агенты?

Моя оценка: потолок не технический — это сигнал обратной связи.

Цикл самоулучшения Hermes полагается на ключевое допущение: он может судить, хороши или плохи его собственные улучшения. Он изменяет навык — следующая задача выполняется лучше. Это положительная обратная связь. Но кто определяет «лучше»?

Если ты здесь и даёшь обратную связь, цикл работает. Ты говоришь «это неправильно» — он корректируется. Это улучшение под наблюдением.

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

В книге Harness Engineering я писал: Митчелл Хашимото мог написать отличную обвязку для Ghostty, потому что понимал каждую деталь работы терминальных эмуляторов. У самосовершенствующегося агента нет предметных знаний Митчелла. Он может оптимизировать эффективность выполнения, но не может судить, правильное ли направление.

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

Вопросы к тебе

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

Но я хочу предложить несколько вопросов, над которыми стоит подумать со временем.

Какой уровень автономного самоулучшения для тебя комфортен?

Перезапись файлов навыков? Нормально. Автосоздание новых навыков? Вероятно, нормально. Изменение собственной основной конфигурации? Пожалуй, нет. Изменение логики собственного цикла обучения? Определённо нет. Где ты проводишь черту?

Кто аудирует результаты самоулучшения?

Ты сам — как часто? Сообщество аудирует — доверяешь ли ты суждению сообщества? Никто не аудирует — устраивает ли тебя такой риск?

Нужен ли самосовершенствующимся агентам механизм «забывания»?

Люди забывают, и это не баг — это фича. Устаревший опыт уходит, чтобы не засорять текущие суждения. Память агента только растёт; паттерны, выученные три месяца назад, могут быть уже неактуальны. Кто скажет агенту «это нужно забыть»?

Как выглядит опасение Кифа Морриса в контексте Hermes?

Моррис беспокоился: если младшие разработчики никогда не касаются деталей кода, кто будет проектировать обвязку в будущем? В контексте Hermes вопрос становится: если агент сам проектирует свои поводья, кто судит, правильно ли спроектированы поводья?

Возможно, ответ: на каком-то уровне всегда нужен человек в петле. Не проверяющий каждую строку кода, но понимающий, что система делает и почему.

Возможно, ответ: мы пока не знаем.

Мнение Хуашу: Самосовершенствующиеся агенты — самое захватывающее направление в этой области, но их потолок определяется степенью человеческого участия. Полностью автономный самоулучшающийся агент выиграет в эффективности, но проиграет в направлении. Оптимальная точка: позволить агенту самоулучшаться в «как», а тебе владеть «что» и «не надо». Это не лень — это другой вид «над петлёй».

Hermes Agent: Полное руководство

Серия оранжевых книг

Хуашу · AI进化论-花生

Практическое руководство по open-source AI Agent фреймворку Nous Research

От установки до мульти-агентной оркестрации

Все оранжевые книги → huasheng.ai

Bilibili · WeChat: 花叔 · X/Twitter · YouTube · Xiaohongshu · Сайт

Создано Хуашу · v260408 · Апрель 2026. Только для образовательных целей. AI-инструменты быстро развиваются — обращайся к официальной документации.