MAX
← Все материалы AI Playbook← All AI Playbook articles
AI native personal playbook

Herdr, Firstmate, T3 Code, cmux, Hermes и Paperclip: что выбрать для работы с агентамиHerdr, Firstmate, T3 Code, cmux, Hermes and Paperclip: what to choose for working with agents

Что делает каждый инструмент, когда добавлять его в свой стек и как устроена работа с агентом-координатором в связке Herdr + Firstmate.What each tool does, when to add it to your stack and how a coordinating agent works with Herdr and Firstmate.

Максим ТолмачёвMaxim Tolmachev~8 мин чтения~8 min read

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

С этим запросом я и пошёл разбираться в Herdr, Firstmate, T3 Code, cmux, Hermes и Paperclip. Названий дофига, а по описаниям каждый будто бы решает всё. Поэтому разложил их по задачам: где я общаюсь с агентом, где он работает, кто следит за исполнителями и куда вообще складываются результаты.

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

Что ты хочешь поручить агенту

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

На поручение “улучши проект” несколько агентов могут принести несколько несовместимых решений. Начать проще с одного исполнителя и задачи, у которой понятно, что считать завершением.

Я разделяю стек на такие уровни:

Уровень На какой вопрос отвечает Примеры
Исполнение Кто читает файлы, использует инструменты и делает работу? Coding agent, универсальный агент
Рабочий интерфейс Где я вижу диалог, терминал, изменения и результат? T3 Code, cmux
Жизнь сессий Где работают процессы и как к ним вернуться? Herdr, терминальные сессии
Координация Кто разбивает задачу, запускает исполнителей и собирает результат? Firstmate
Управление регулярной работой Где цели, ответственные, бюджет и история запусков? Paperclip
Личный контекст Что система знает о моих проектах и договорённостях? Документы, инструкции, skills, память

Некоторые продукты закрывают сразу несколько строк. Здесь я выделяю ту роль, ради которой стал бы их выбирать.

T3 Code: управлять агентами через desktop, браузер и телефон

T3 Code описывает себя как интерфейс управления агентскими средами. У него есть desktop, web и мобильные клиенты; в текущем README перечислены Codex, Claude, Cursor, Grok Build, OpenCode и Antigravity.

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

А вот поручение “раздай задачи исполнителям и собери их изменения” нужно проверять отдельно. Несколько вкладок ещё не говорят о том, что кто-то следит за общим результатом.

cmux: терминалы, браузер и уведомления в одном окне

В cmux собраны терминалы, рабочие пространства, уведомления и встроенный браузер. Это приложение для macOS, в README также описаны работа через SSH и управление через CLI и socket API.

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

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

Herdr: оставить агентов работать и вернуться к их сессиям

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

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

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

Herdr + Firstmate: поручить одному агенту управлять остальными

С Firstmate ты становишься капитаном: задаёшь направление и решаешь, что команде разрешено. Агент играет роль первого помощника и координирует исполнителей. Именно такую работу я имел в виду под captain mode.

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

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

До запуска ему нужно объяснить, какие репозитории можно менять, что разрешено интегрировать самостоятельно и когда пора звать тебя. Иначе координатор будет угадывать свои полномочия.

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

Hermes: помощник с памятью, расписанием и доступом из Telegram

Hermes Agent описывает постоянную память, skills, поиск по прошлым разговорам, задания по расписанию и общение через мессенджеры. В том числе можно обращаться к агенту через Telegram, пока он работает на сервере.

Здесь мне интересны повторяющиеся задачи: утренняя сводка, поиск прежнего решения, отчёт по выбранным данным. Хочется один раз договориться о формате и дальше получать результат в привычном мессенджере.

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

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

Paperclip: цели, задачи и бюджеты для постоянной работы агентов

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

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

У каждой задачи должен быть один источник статуса. Если Paperclip хранит её статус, а Firstmate координирует исполнение, нужно определить, кто меняет статус, куда возвращается результат и кто имеет право повторить запуск. Без этого легко получить две попытки выполнить одну и ту же работу.

Три конфигурации, с которых можно начать

Для старта я вижу такие варианты:

Ситуация Начальная конфигурация Что проверить до расширения
Работаю над одним продуктом и сам направляю агента Один coding agent и T3 Code либо cmux как основной интерфейс Понимаю изменения, могу проверить результат и вернуться к задаче
Веду несколько независимых задач, устал переключаться Исполнители, Herdr и Firstmate для координации Изоляция рабочих копий, сбор результатов, восстановление после прерывания
Нужны постоянные исследования, сводки и другие повторяющиеся задачи Hermes; отдельный учёт задач по мере необходимости, например Paperclip Расписание, доставка, лимиты, отсутствие дублей и потерянных запусков

Я бы выбрал один основной интерфейс, а дальше добавлял инструменты под конкретную проблему: “теряю сессии”, “забываю проверить результаты”, “не вижу стоимость”, “запуски дублируются”.

Что записать, чтобы не объяснять задачу заново

Меня в такой системе волнует ещё одна вещь: сколько раз придётся объяснять одно и то же. Поэтому в проекте нужны записанные решения и команды проверки, повторяющиеся действия можно оформить в skill. Если задача не закончена, следующий запуск должен увидеть, что уже сделано и на чём остановились.

Перед запуском стоит записать:

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

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

Как проверить, что этот стек экономит моё время

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

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

Если собираешь такую систему для команды, придётся договориться об общей стратегии, ответственности и правилах выпуска. Это разбираю в AI native company playbook.

I want to run agents on a server, control them from my MacBook and close the laptop while they keep working. I also want to talk to one agent that assigns work to the others and comes back with a result, including when the workers run on different devices.

That is what sent me looking into Herdr, Firstmate, T3 Code, cmux, Hermes and Paperclip. There are a lot of names, and their descriptions make each one sound like it does everything. So I sorted them by the jobs I need done: where I talk to an agent, where it runs, who watches the workers and where the results go.

The features below were checked against project documentation on October 4, 2026. I have not tested these combinations end to end, so treat them as options to try on your own tasks.

What do you want to delegate?

I find it easier to choose tools when the task is clear. I might want research with conclusions linked to sources, or a bug fix verified in the running product. From there, I can build a process and decide where it needs me.

Tell several agents to “improve the project” and they may bring back incompatible solutions. Start with one worker and a task whose definition of done you understand.

I separate the stack into these layers:

Layer Question it answers Examples
Execution Who reads files, uses tools and does the work? Coding agent, general-purpose agent
Working interface Where do I see the conversation, terminal, changes and result? T3 Code, cmux
Session lifecycle Where do processes run, and how do I return to them? Herdr, terminal sessions
Coordination Who splits the task, starts workers and collects results? Firstmate
Recurring work management Where are goals, owners, budgets and run history? Paperclip
Personal context What does the system know about my projects and agreements? Documents, instructions, skills, memory

Some products cover several rows. I am highlighting the role I would choose each one for.

T3 Code: work with agents from desktop, browser and phone

T3 Code describes itself as an interface for agent environments. It has desktop, web and mobile clients. Its current README lists Codex, Claude, Cursor, Grok Build, OpenCode and Antigravity.

I see it as a main working window when I want to talk to an agent and return to the work from different devices. With remote access, establish where the server runs and where project files live. The window is on my MacBook, but the work may happen on another machine.

Check the ability to assign work and collect changes separately. Several tabs do not tell you whether anyone is watching the combined result.

cmux: terminals, browser and notifications in one window

cmux brings together terminals, workspaces, notifications and an embedded browser. It is a macOS application. Its README also describes SSH workflows and control through a CLI and socket API.

I like having the agent and its work side by side. The work runs on the left, and I can open the application next to it to inspect the result. Notifications help me see which agent needs me.

You can manage sessions yourself or delegate that to a coordinating agent. In the latter case, agree separately on who accepts results and resolves conflicts between tasks.

Herdr: leave agents working and return to their sessions

In Herdr, agent terminal sessions live in a server process and can be accessed from different machines. This matters for my original request: I want to return to the same work and see what happened while I was away.

Where the processes run matters. If they run on a laptop, putting it to sleep will interrupt the work. Tasks that need to continue with the lid closed need an always-on machine.

Try Herdr when you lose sessions or find it awkward to return from another device. For browser verification, check the browser connection you need and compatibility with your chosen extensions in advance. Do not choose the whole stack from a screenshot of someone else’s setup.

Herdr + Firstmate: ask one agent to manage the others

With Firstmate, you are the captain: you set direction and decide what the team is allowed to do. The agent acts as first mate and coordinates workers. This is what I meant by captain mode.

Firstmate consists of instructions, skills, scripts and conventions for tracking work state. An agent starts in that environment and takes the coordinator role. The project describes launching workers in separate Git working copies, monitoring them and handing off results. Sessions can be organized through Herdr, though Firstmate supports other options too.

I am particularly interested in testing this combination on several independent tasks. One agent might investigate a bug while another updates documentation for a finished feature. I talk to the coordinator, and it watches the workers and gathers results.

Before starting, tell it which repositories it can change, what it can integrate independently and when to call you. Otherwise it will guess its authority.

I would also check recovery after interruption. If I close the interface, lose the connection or restart the coordinator, does the system know which tasks finished, which are running and which are stuck? I want to leave and return without manually reconstructing every worker’s history.

Hermes: memory, schedules and access through Telegram

Hermes Agent describes persistent memory, skills, search across past conversations, scheduled tasks and messaging integrations. You can talk to an agent through Telegram while it runs on a server.

I am interested in recurring tasks here: a morning briefing, finding a previous decision or reporting on selected data. I want to agree on a format once and then receive the result in the messenger I already use.

Keep personal memory, project data and instructions separate. An agent’s assumption must not become a “fact about me” in the next conversation. Save confirmed decisions and explicit preferences; label guesses.

If the assistant delegates development to a coding agent, they need a clear agreement about the task and result. Installing both products does not create that integration.

Paperclip: goals, tasks and budgets for ongoing agent work

Paperclip connects goals, projects, tasks, agent roles, budgets and approvals. It also describes recurring runs with an owner and execution history. That makes work easier to follow between individual chats.

I can see this making sense for one person who has a product, research, reporting and content running in parallel. For one task, another system to maintain seems excessive.

Each task needs one source of status. If Paperclip holds its status and Firstmate coordinates execution, define who updates the status, where the result returns and who can retry the run. Otherwise you can get two attempts at the same work.

Three starting configurations

These are the starting points I would consider:

Situation Starting configuration What to check before expanding
I work on one product and direct the agent myself One coding agent with T3 Code or cmux as the main interface I understand the changes, can verify the result and return to the task
I handle several independent tasks and am tired of switching Workers, Herdr and Firstmate for coordination Isolated working copies, result collection, recovery after interruption
I need ongoing research, briefings and other recurring work Hermes, with separate task tracking such as Paperclip when needed Scheduling, delivery, limits, duplicate and missing runs

I would pick one main interface, then add tools for a specific problem: “I lose sessions,” “I forget to check results,” “I cannot see costs,” or “runs are duplicated.”

What to write down so you do not have to explain the task again

One more thing concerns me: how often will I have to explain the same thing? Record decisions and verification commands in the project. Repeated actions can become a skill. If a task is unfinished, the next run should see what has been done and where work stopped.

Before starting, write down:

The result I want, the project we are working in and what can change. How we verify the result, where we save it and what remains unresolved. When to stop and call me, and how much time or money can be spent.

Separate branches or worktrees help isolate code. Parallel execution also needs separate ports, test databases and clear rules for external services. Two independent chats can easily change the same external resource.

How to check whether the stack saves my time

I would take one recurring task and run it several times in the chosen setup. Record time to an accepted result, my interventions, cost and rework. Then check behavior after a connection loss and restart.

I want to spend less attention getting to a finished result. If I have more agents but spend all day reading their messages, passing context and resolving conflicts, I take that as a reason to simplify the stack.

For a team, you will also need agreements on shared strategy, ownership and release rules. I cover those in the AI native company playbook.