# Herdr, Firstmate, T3 Code, cmux, Hermes and Paperclip: what to choose for working with agents

What each tool does, when to add it to your stack and how a coordinating agent works with Herdr and Firstmate.

Author: Maxim Tolmachev
Published: 2026-10-04
Language: en
Canonical: https://maximtolmachev.com/en/ai-playbook/personal/agent-stack/

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](https://github.com/pingdotgg/t3code) 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](https://github.com/manaflow-ai/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](https://herdr.dev/), 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](https://github.com/kunchenguid/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](https://github.com/NousResearch/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](https://github.com/paperclipai/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](/ai-playbook/company/operating-model/).
