---
import SiteLayout from '../components/SiteLayout.astro';
---

<SiteLayout
  title="Compare Herdr vs tmux, Zellij, cmux, Warp & agent managers"
  description="Compare Herdr with tmux, Zellij, cmux, Warp, Solo, Conductor, Emdash, and Superset. Multiplexers persist terminals and apps manage agents. Herdr is the runtime agents live on, with clients on top."
  canonicalPath="/compare/"
>
  <main>
    <header class="ph ph-split">
      <div>
        <div class="hd-eyebrow"><s></s>compare</div>
        <h1>Apps manage the herd. Herdr <em>runs</em> it.</h1>
        <p>
          Most tools Herdr gets compared to are apps: a window you open to
          manage coding agents, and a window the work depends on. Herdr is a
          different kind of thing: a runtime. A server holds real terminals
          open on the machine, the agents live in those, and every UI, ours
          included, is just a client that attaches. Keep that split in mind
          and the matrix below mostly explains itself.
        </p>
      </div>
      <aside class="ph-side">
        <b>9</b>
        <span>tools compared · one runtime</span>
      </aside>
    </header>

    <section class="cmp" id="matrix">
      <div class="fighd">
        <span>herdr against the field</span>
        <span class="r">scrolls sideways on a phone</span>
      </div>
      <div class="cmp-scroll">
        <table>
          <thead>
            <tr>
              <th>capability</th>
              <th class="h">herdr</th>
              <th>tmux · zellij</th>
              <th>cmux · warp</th>
              <th>solo</th>
              <th>conductor · emdash · superset</th>
            </tr>
          </thead>
          <tbody>
            <tr>
              <th scope="row">Kind of thing</th>
              <td class="h">runtime + clients</td>
              <td>terminal multiplexer</td>
              <td>terminal app</td>
              <td>process dashboard</td>
              <td>manager app</td>
            </tr>
            <tr>
              <th scope="row">Work survives its own UI closing</th>
              <td class="h">yes, the server owns the terminals</td>
              <td>yes, detach</td>
              <td>session restore</td>
              <td>while the app is open</td>
              <td>while the app is open</td>
            </tr>
            <tr>
              <th scope="row">Runs inside your existing terminal</th>
              <td class="h">yes</td>
              <td>yes</td>
              <td>replaces it</td>
              <td class="no">no, desktop app</td>
              <td class="no">no, desktop app</td>
            </tr>
            <tr>
              <th scope="row">Semantic agent state</th>
              <td class="h">blocked · working · done · idle</td>
              <td class="no">—</td>
              <td>attention cues</td>
              <td>process status</td>
              <td>workspace status</td>
            </tr>
            <tr>
              <th scope="row">Detach, reattach, SSH in</th>
              <td class="h">yes, any tty</td>
              <td>yes</td>
              <td>partial</td>
              <td class="no">—</td>
              <td>remote projects</td>
            </tr>
            <tr>
              <th scope="row">Direct attach to one agent</th>
              <td class="h">yes</td>
              <td class="no">—</td>
              <td class="no">—</td>
              <td class="no">—</td>
              <td class="no">—</td>
            </tr>
            <tr>
              <th scope="row">API agents drive themselves</th>
              <td class="h">read · send · wait · split · attach</td>
              <td>terminal scripting</td>
              <td>app APIs</td>
              <td>MCP for processes</td>
              <td>workflow APIs</td>
            </tr>
            <tr>
              <th scope="row">Worktree and diff review flow</th>
              <td class="h">pairs with it</td>
              <td class="no">—</td>
              <td>partial</td>
              <td class="no">—</td>
              <td>yes, their core</td>
            </tr>
            <tr>
              <th scope="row">Clients on the same runtime</th>
              <td class="h">TUI · CLI · plain SSH, more coming</td>
              <td>its own client</td>
              <td>the app only</td>
              <td>the app only</td>
              <td>the app only</td>
            </tr>
          </tbody>
        </table>
      </div>
      <p class="figcap">
        The columns are categories, not enemies: Herdr pairs happily with a
        worktree manager and runs fine inside a fancy terminal.
        <b>The row that sorts the field is the second one:</b> what happens to
        the agents when the thing you're looking at goes away.
      </p>
    </section>

    <div class="caps">
      <div class="cap cap-flat">
        <div class="n"><span>01</span></div>
        <div class="cap-in">
          <h3>Herdr is the runtime.</h3>
          <p>
            A server owns the terminals; every UI is a client of it. The TUI in
            the screenshots attaches, detaches and even crashes without the
            agents noticing. Same for the CLI, plain SSH, and whatever
            attaches next. The TUI is the first client, not the last.
          </p>
        </div>
        <div class="ev" aria-hidden="true">
          <div class="ev-row"><span>herdr-server</span><b><i class="beat"></i>up</b></div>
          <div class="ev-note">4 agents · 0 clients attached · still working</div>
        </div>
      </div>
      <div class="cap cap-flat">
        <div class="n"><span>02</span></div>
        <div class="cap-in">
          <h3>Multiplexers persist terminals, not agents.</h3>
          <p>
            tmux gave humans persistence, and Herdr keeps that whole
            inheritance: real PTYs, detach, SSH. What it adds is the part
            multiplexers never had: knowing which pane is an agent, whether
            it's blocked, and how to wait on it instead of polling it.
          </p>
        </div>
        <div class="ev" aria-hidden="true">
          <div class="ev-row"><span>tmux ls</span><b>3 sessions</b></div>
          <div class="ev-note">which one is waiting on you? no idea</div>
        </div>
      </div>
      <div class="cap cap-flat">
        <div class="n"><span>03</span></div>
        <div class="cap-in">
          <h3>Terminal apps replace your terminal.</h3>
          <p>
            cmux and Warp can be genuinely polished, but the deal is that the
            work moves into their window, with their renderer, on the machines
            they support. Herdr changes nothing about your terminal. It runs
            inside it, wherever a terminal and SSH already reach.
          </p>
        </div>
        <div class="ev" aria-hidden="true">
          <div class="ev-row"><span>ghostty · kitty · iterm · alacritty</span><b>kept</b></div>
          <div class="ev-note">herdr runs in the one you already chose</div>
        </div>
      </div>
      <div class="cap cap-flat">
        <div class="n"><span>04</span></div>
        <div class="cap-in">
          <h3>Manager apps are clients without a runtime.</h3>
          <p>
            Conductor, Emdash and Superset manage a herd from a window:
            worktrees, diffs, review queues. Useful, and Herdr pairs fine with
            that flow. But a window that manages agents is not a place agents
            live: quit the app and the herd goes with it.
          </p>
        </div>
        <div class="ev" aria-hidden="true">
          <div class="ev-row"><span>their app quits</span><b>agents stop</b></div>
          <div class="ev-row"><span>every herdr client quits</span><b>agents keep going</b></div>
        </div>
      </div>
      <div class="cap cap-flat">
        <div class="n"><span>05</span></div>
        <div class="cap-in">
          <h3>Dashboards watch processes.</h3>
          <p>
            Solo supervises a dev stack: health, restarts, logs. Herdr's job
            is different: interactive agent terminals that stay open, hold
            scrollback and state, and stay yours whether or not anything is
            watching them.
          </p>
        </div>
        <div class="ev" aria-hidden="true">
          <div class="ev-row"><span>process status</span><b>up / down</b></div>
          <div class="ev-row"><span>agent state</span><b>blocked · working · idle</b></div>
        </div>
      </div>
    </div>

    <section class="vs">
      <div class="fighd">
        <span>one-liners, for deciding fast</span>
      </div>
      <div class="vs-list">
        <article>
          <b>herdr vs tmux</b>
          <p>tmux keeps terminals alive; so does Herdr. The difference is Herdr knows which terminals are agents, what state each one is in, and how to wait on them. tmux sees panes.</p>
        </article>
        <article>
          <b>herdr vs zellij</b>
          <p>Zellij is a friendlier workspace for humans in terminals. Herdr is a runtime for agents in terminals: state, waits, direct attach, and an API.</p>
        </article>
        <article>
          <b>herdr vs cmux</b>
          <p>cmux is a Mac terminal app built around agents. Herdr isn't an app: it's the runtime underneath, in whatever terminal you already use, reachable over SSH.</p>
        </article>
        <article>
          <b>herdr vs warp</b>
          <p>Warp wants to be your terminal and your platform. Herdr keeps your terminal and owns what runs inside it.</p>
        </article>
        <article>
          <b>herdr vs opencode web</b>
          <p>opencode's web mode serves one agent over HTTP. Herdr runs the whole herd: any agent CLI, many at once, from any tty.</p>
        </article>
        <article>
          <b>herdr vs solo</b>
          <p>Solo is a dashboard that supervises your dev processes. Herdr holds interactive agent terminals open whether or not anything is watching them.</p>
        </article>
        <article>
          <b>herdr vs conductor, emdash, superset</b>
          <p>Manager apps put worktrees, diffs and review queues in a window. Herdr is the layer under that kind of window: quit their app and the agents stop; detach every Herdr client and they don't.</p>
        </article>
      </div>
    </section>

    <section class="end">
      <span class="ram"></span>
      <div class="in">
        <h2>A runtime, not another window.</h2>
        <p>
          Install it and nothing about your setup changes: same terminal, same
          agent CLIs. They just stop dying when a window does.
        </p>
        <div class="ph-actions">
          <a class="btn-solid" href="/docs/install/">Install Herdr</a>
          <a class="btn-ghost" href="/docs/quick-start/">Quick start</a>
        </div>
      </div>
    </section>
  </main>
</SiteLayout>
