muster

agent
Security Audit
Fail
Health Warn
  • License — License: MIT
  • Description — Repository has a description
  • Active repo — Last push 0 days ago
  • Low visibility — Only 5 GitHub stars
Code Fail
  • rm -rf — Recursive force deletion command in .github/scripts/release-publish.sh
  • network request — Outbound network request in .github/scripts/tag_gate.py
Permissions Pass
  • Permissions — No dangerous permissions requested

No AI report is available for this listing yet.

SUMMARY

Every coding agent on every machine, in one list on your phone. Self-hosted.

README.md

muster

Every coding agent on every machine, in one list on your phone.

Claude Code · Codex · opencode (any model, incl. OpenRouter) · anything else you run in tmux.

When a Claude Code session needs you, you get a push, answer from your phone, and it carries on.

Self-hosted: start on this machine at http://localhost, then add your phone over your own Tailscale network.

Latest release
License: MIT
Self-hosted with Docker Compose
Runs on your tailnet

On a phone: the sidebar lists every session on two machines, called by their work. Searching 'opencode' finds the opencode session and 'codex' finds the two Codex windows; one Codex window opens as a live terminal. The Claude Code session 'Rate-limit the public API' then asks whether to limit per API key or per client IP, and its question shows on the Asks page with a count; one tap opens its chat, Per API key and Submit answer it, the session runs its tests and says it is done, and the list ends with nothing waiting

Quick start

Two ways in. Both start on this machine, at a http://localhost address,
with nothing to fill in; your phone and your other machines come after, in one
step, over Tailscale.

(a) Let your agent install it. Paste this one prompt into the coding agent
(Claude Code, Codex, opencode, Gemini CLI, …) on the machine that should run
muster:

Set up muster for me. Download its install guide with `curl -fsSL -o muster-install.md https://github.com/ZacxDev/muster/releases/latest/download/INSTALL.md`, read that whole file and follow it step by step. If that download fails, stop and tell me what it printed; never work from another copy of the guide, such as the one on the main branch, or from memory. Ask me everything you need in one go up front, then do the rest yourself. Where the guide and the machine disagree, trust `muster doctor`, each command's `--help` and the code at https://github.com/ZacxDev/muster over memory.

The agent downloads INSTALL.md, a guide written for agents to
execute, from the newest release, asks its questions once, up front, installs
muster with the one-liner below, and finishes with muster doctor. If you
want the phone and your other machines, it adds Tailscale; on each further
machine, paste the same prompt and tell the agent muster already runs. More in
docs/onboarding.md.

(b) Install it yourself, in one line (Docker with Compose v2, and tmux):

curl -fsSL https://github.com/ZacxDev/muster/releases/latest/download/install.sh | sh

It starts muster in Docker with every secret generated, shows this machine's
tmux sessions, and runs muster doctor; adding your phone is one section of
docs/quickstart-local.md.
On Kubernetes (the advanced path, which also runs dispatched agents): the
Helm chart, docs/kubernetes.md.

What you get

The sidebar on a phone: every session on two machines and the dispatched agents, like channels in a chat app. Claude Code sessions are called by their work ('Speed up the task-list endpoint', with its current focus under it); a Codex window, an opencode window and shells by their machines' labels ('web-lint:1', 'csv-import:1', 'api-logs:1'); the open session is marked
Every session, one list
Every tmux window on every machine, Claude Code, Codex, opencode and shells alike, with the ones waiting on you first.
A Claude Code session, 'Write the 2.4 release notes', on a phone: its question, whether to tag and publish v2.4.0 now, drawn as a form with Publish now, Hold for review and Other, and a Submit answers button
Agents ask instead of stopping
A Claude Code question becomes a form on your phone, pushed with its text; answer it and the session carries on. One-time setup per machine.
A Claude Code session, 'Speed up the task-list endpoint', rendered as a chat on a phone; each of its three tool calls shows how much context it added
A chat, not a terminal
A Claude Code session reads as a chat, with the message box under your thumb and the context each tool call added.
A Claude Code session's message box on a phone, the microphone recording
Talk instead of typing
Optional dictation: tap the mic and speak, and read the transcript in the box before you press Send.
A busy Claude Code session, 'Migrate billing to Stripe webhooks', on a phone, with two messages queued above its box: the queue sends one at a time, each when Claude Code has been idle a while
Queue the next message
Queue messages while the agent works: the server sends each one once Claude Code has been idle for 30 s, even with your phone closed.
The Asks page on a phone: an officer asks whether to write up a proposal, with three options to tap
Officers and a chief
Optional: standing agents with a job, which can ask you on the Asks page, and a chief you can ask what every session is on.

Sessions are called by a name: the one you give with Rename…, or
their first good focus title (focus: optional, needs
an OpenRouter key). Without either, a window shows its tmux session and window
(work:1), or a label you give that tmux session (muster-mirror -labels-file), as the shells, the Codex windows and the opencode window in
these pictures do.

  • A push when a session needs you, and one queue for everything waiting. A
    session's stop is pushed once and never quoted; asks are pushed with their
    text (below). The Asks page
    gathers everything blocked on you. This needs Push, which INSTALL.md turns
    on; on iOS, Add to Home Screen first.
  • Mixed agents in one place. Claude Code renders as a chat; opencode has
    its own read view; Codex, Gemini CLI and plain shells are live terminals.
    Each opens in a Terminal view you can type into, on a machine you let muster
    type into.
  • Everything stays on your machines and your tailnet (unless you turn on
    an optional feature that calls an outside API, such as suggested replies,
    focus or a hosted speech-to-text). The server runs on one of your machines
    and is reached only over Tailscale. Each machine dials
    out to it, so muster opens no network port on them (the optional MCP
    endpoint listens on loopback only). Machines are read-only until you let
    muster type into them, one machine at a time.
More on asks and the chief
  • Agents ask you instead of stopping. A Claude Code session can ask you a
    question with options and wait for your answer, and Claude Code's own
    multiple-choice questions become a form you answer from your phone. Each
    needs a one-time setup per machine.
  • A chief that knows what every session is on. An optional fleet agent
    you chat with: ask it what everyone is working on, who is on what, or what
    needs you, and have it hand a request or a task to the session already on
    it (routing is off until MUSTER_SESSION_ROUTING=1). It sends what it reads of your sessions to its model, and on an
    OpenRouter key muster sets no budget: put a credit limit on the key.
    Finding who is on what, routing and its standups rely on
    focus, which needs an OpenRouter key. What it needs: docs/features.md;
    prompts that work, with real replies:
    docs/chief-cookbook.md.
  • Officers need Kubernetes, or run in the Compose stack as host-spawned
    sessions on one opted-in machine: docs/features.md.

On a phone: the sidebar lists sessions on two machines; 'Write the 2.4 release notes' asks whether to tag and publish the release, and jumps to the top with an Asks count; the Asks page shows the question; in the session, tapping Publish now and Submit answers it, and the agent tags and publishes the release

On a phone: open a session from the bottom bar's search by typing a word of its name, 'task', dictate a reply with the microphone, send it, and watch the session answer

How it works

  1. A server (one Go binary and Postgres, in Docker Compose) runs on one of your
    machines, reached over your tailnet through tailscale serve.
  2. On each machine, muster-mirror dials out to it and mirrors every tmux
    window as a mirrored session; a message from your phone is typed into
    that same session, so it is all there when you are back at the keyboard.
  3. Your phone opens the server as an installable web app (a PWA).

muster sees only sessions inside tmux, and the one-prompt install above sets
up mirrored sessions only. How to bring a session you already have
into tmux, and how mirrored sessions differ from the opt-in dispatched
agents
that muster starts in Kubernetes pods:
docs/mirroring.md.
The components and what each trusts: docs/architecture.md.

Install

What each part needs, and what is optional: Core vs optional.
While there is no session yet, home shows how to start an agent in tmux
(tmux new -A -s work claude) and the same prompt, to connect another machine.

Install from inside Claude Code, or as a skill

The one prompt above is the main path. In Claude Code you can instead add this
repository as a plugin marketplace and install the muster plugin:

/plugin marketplace add ZacxDev/muster
/plugin install muster@muster

Then ask Claude Code to "set up muster". The plugin holds one skill,
muster-setup, which downloads the same INSTALL.md from the
newest release and follows it, so it never carries a copy of the steps.

Other coding agents can install the same skill with the
skills CLI:

npx skills add ZacxDev/muster --skill muster-setup

This is muster by ZacxDev. Other repositories publish unrelated
skills named muster, so install it by this repository's name, not by
searching for the word.

To hack on muster, docs/development.md runs it from source
against a throwaway database.

Notifications: only when you are needed

From v0.146.0 the Compose stack pushes each stop of a session once: when it
waits on you, or when it has sat idle 10 minutes (stalled). The push names the
session and never quotes it. Asks are pushed with their text: an agent's or the
chief's question, muster's own, a Claude Code question held by the ask hook, and
opencode questions and permission requests
(docs/attention.md). Task
events have their own switches under Account → Notifications. Turning
this off: docs/features.md.

Core vs optional

The core runs with no optional dependency: Docker Compose with its bundled
Postgres on one machine, and muster-mirror and tmux on each machine;
Tailscale adds the phone and other machines. Everything else is off until you give it what it needs, and is
turned on with a few lines in .env (and, for some, a Compose profile).

Every feature, what it needs, and its default
feature needs default
Core: mirrored sessions, chat and Terminal views, typing into sessions, sidebar and search, the Asks page, tasks, the installable app, the CLI and muster doctor Compose and its Postgres; muster-mirror and tmux on each machine; Tailscale on
Push keys the Compose stack generates; HTTPS (Tailscale) for the phone on
One push per stop Push (above) on in the Compose stack, from v0.146.0
Dictation --profile stt (bundled, CPU), --profile stt-cohere (GPU), or your own OpenAI-compatible speech-to-text off (the agent install asks)
Attachments --profile s3, or your own S3-compatible store off
Suggested replies and focus an OpenRouter key off until the key is set; suggested replies then stay off for each user until they turn them on in Account (with no database, until MUSTER_SUGGEST=on)
Agent ask tool and ask cards a one-time setup on each machine off
Accounts (per-user sign-in, passkeys) a GoTrue server you run off (one shared password)
Chief --profile chief (amd64 hosts), the connector store's key, and a Claude subscription token or an OpenRouter key; routing work to sessions also needs MUSTER_SESSION_ROUTING=1 off (routing too)
Dispatch Kubernetes off; not in the Compose stack
Officers Kubernetes (pods), or in the Compose stack as host-spawned sessions on one opted-in machine (built-in backend only; outbound drafts and connectors work, HQ, ship gates, tiers, transcripts and the LLM proxy do not; the sessions run as that machine's user with no pod isolation, so muster's approval of their posts is the sanctioned path, not a boundary) off
Approval router an external permission router you run (advanced) off

Every other optional feature, what it needs and the .env lines that turn it
on: docs/features.md. muster doctor checks the install
end to end and says how to fix what fails
(docs/cli.md); each section of docs/features.md
ends with how to check that feature is on.

A guide per feature

Set up the core first, then add one optional dependency at a time, each with a
short guide (what it adds, what it needs, the settings, how muster doctor
confirms it, how to turn it off). The guides:
docs/README.md.
The words muster uses: docs/glossary.md.

muster vs Remote Control

If you use only Claude Code on a paid Claude plan, Remote Control is less
work
: nothing to install or host, a native app with its own push for
permission prompts and questions, those prompts answered in the app,
first-party support, deeper Claude Code integration (subagent progress,
compaction), and Trusted Devices.

muster is for what it does not cover: agents other than Claude Code, Claude
Code on an API key, Bedrock, Google Cloud, Microsoft Foundry or a custom
ANTHROPIC_BASE_URL, every tmux session on every machine in one list, and a
session that stays on your own machines and tailnet instead of going through
Anthropic's servers. muster also picks up every session already in tmux on
its own, with nothing to run inside each one, and reads the session on your
own machine.

The full comparison, with Happy and SSH + tmux too and the sources for every
cell, plus a line each on herdr and Paseo citing their READMEs:
docs/comparison.md.

Limits

  • Linux. macOS hosts are experimental: the Terminal view cannot attach on
    macOS yet (internal/mirrorhost/pty_other.go), so there only a Claude Code
    window whose Rendered view resolves can be viewed, and Rendered-view
    detection is unverified on a real Mac. No Windows.
  • muster assumes sessions run without permission prompts. Start your own
    Claude Code sessions in bypassPermissions or auto mode; the agents a host
    starts for your chief are started without them by default, so they run
    their tools without asking (-agent-spawn-skip-permissions=false turns that
    off: docs/mirroring.md).
    A Claude Code permission prompt that does appear is answered in the Terminal
    view: the chat view refuses to type into a waiting prompt, and there is no
    one-tap approve (docs/sending-and-step-up.md).
  • Codex and Gemini CLI get no waiting push and no ask tool: they are
    terminal views. The message box sends to opencode only on an opted-in host
    (docs/mirroring.md).
  • It needs Docker on one machine and tmux on every machine, and Tailscale
    for your phone and other machines; what each machine needs is checked by
    INSTALL.md, "Preflight (every machine)". muster sees
    only sessions inside tmux.
  • It is a PWA, not a native app. On iOS, install it to the Home Screen
    before it can receive push.
  • Run one replica. Some background loops and the mirror tunnel keep their
    state in memory.
  • An interactive mirror is a shell on that host. Anyone who can type into
    that host's Terminal view (after a recent sign-in) can run commands as the
    user muster-mirror runs as.
  • Agent dispatch is opt-in and only lightly proven. It needs Kubernetes:
    the Helm chart in charts/muster installs it (docs/kubernetes.md).

The full list is in docs/limits.md.

Features

Every feature, what it needs and how to turn it on: docs/features.md.
The full documentation index: docs/README.md.

A mirrored Claude Code session, 'Speed up the task-list endpoint', at a desktop size, with its tool calls, context badges and the session switcher

The name

Not to be confused with two other apps called Muster: the Mac menu-bar app
(agentmuster.app) and the desktop app for running
parallel agents in git worktrees (musterup.dev). This
muster is the self-hosted one, for your phone and every machine you run agents
on.

To muster is to assemble a force for duty. A muster roll is the register of who
is present and what each is assigned.

Licence

MIT. See LICENSE.

Reviews (0)

No results found