muxel Multi-Agent Workspace
Run, monitor, and schedule multiple coding agents in one native desktop workspace.
Per-dimension scores and reasoning
The evidence openly identifies high-impact capabilities including PTYs, agent processes, environment variables, Git worktrees, the gh CLI, SSH, roaming-layout synchronization, shared MEMORY.md, scheduled runs, and in-app updates. Release write permission is scoped to the release job, and the Windows installer is described as per-user and non-admin. Deductions apply because there is no evidence of agent sandboxing, per-operation confirmations, precise remote-sync data boundaries, or protection for sensitive environment variables and SSH credentials. Dependency controls include a stated Cargo.lock pin and versioned CI actions, but the root GPUI Git dependencies lack explicit rev fields and no audit, vulnerability-response, or supply-chain verification policy is shown. The worktree review/dispose flow offers limited recovery context, but no general undo or backup design is documented. ProjectHax LLC, the repository, and major upstreams are attributed, though the publisher is unverified and no complete third-party attribution inventory is present.
The README, Cargo workspace, and CI/release workflows are broadly consistent about platforms, builds, package formats, and release mechanics. CI includes formatting, Clippy, builds, and tests, while release jobs contain explicit failures or warnings for unresolved AppImage dependencies, missing artifacts, and absent changelog sections. Deductions apply because most product capabilities are asserted in the README without the corresponding implementation or tests in the supplied evidence; availability still depends on Git upstreams, system libraries, package managers, and network-fetched installers. Visible failure handling is concentrated in packaging rather than user-facing runtime failures involving SSH, PTYs, updates, scheduling, or persistence.
The audience and scenarios are exceptionally clear: concurrent coding agents and shells, cross-project monitoring, local and remote development, worktrees, scheduling, and cross-platform desktop operation. Editable presets cover programs, arguments, models, system prompts, environments, and status markers, while environment guidance distinguishes operating systems, architectures, graphics stacks, and native-build constraints. Deductions apply because capability boundaries are incomplete: Windows tmux limitations and signing fallback are stated, but supported agent protocols, remote security boundaries, and degradation behavior are not. Loop timing is described at a useful high level, yet concurrency, missed-run, timezone, and duplicate-prevention semantics are absent.
The README has clear feature, installation, source-build, CI, release, and licensing sections. Product and crate naming is consistent, workspace version 0.2.0 aligns with a vX.Y.Z tagging scheme, and installation covers three operating systems, package choices, source commands, and Linux dependencies. GPL-3.0-only is consistent between Cargo metadata and the full license, the dual-license arrangement is plainly explained, and releases derive notes from versioned CHANGELOG sections. Deductions apply because FEATURES.md, LICENSING.md, CONTRIBUTING.md, CHANGELOG.md, and the toolchain pin are referenced but not supplied; routine usage examples and an FAQ are absent; limitations are concrete but not comprehensive. ProjectHax LLC is identified as author and commercial licensor, but no maintainer contact, support expectation, response policy, or security-reporting path is shown.
The described output is a directly usable native workspace combining real terminals, status displays, notifications, editing, diff viewing, worktrees, and persistence, offering credible marginal value for managing multiple coding agents. GPL use is available without a license fee, prebuilt packages are broad, and the costly first GPUI build plus platform dependencies are disclosed. Deductions apply because there are no demonstrated end-to-end workflows, substantive examples, benchmarks, or user evidence establishing usability or status-detection quality. Most differentiated value remains a README claim, and ongoing CPU, memory, network, remote-host, notification, and multi-agent service costs are not quantified.
Version, license, authorship, workspace structure, platform matrix, package formats, signing conditions, and release rules can be traced across Cargo metadata and both workflows. The release workflow also documents a concrete AppImage compatibility failure and associated regression guards. Deductions apply because central claims such as status detection, shared memory, SSH roaming layouts, editor behavior, and worktree interactions appear only in the README, with no supplied implementation or focused tests for corroboration; statements such as “verified locally” lack accompanying static evidence. Facts and caveats are generally distinguished, but feature marketing does not systematically separate implemented behavior, design intent, and platform exceptions.
- The recommended install commands pipe remote shell or PowerShell scripts directly into an interpreter; download, inspect, and verify scripts and release artifacts before use.
- The application can launch arbitrary agents and shells, pass environment variables, manipulate worktrees, invoke gh, connect over SSH, and schedule jobs. Confirm each agent's filesystem, network, credential, and remote-host permissions first.
- Roaming layouts, persistent tmux sessions, and shared .muxel/MEMORY.md may propagate project paths, prompts, or work information. The supplied material does not define synchronization contents, encryption, retention, or deletion behavior.
- macOS packaging falls back to ad-hoc signing when secrets are absent, while Windows signing occurs in a separate post-release step. Verify that the particular downloaded artifact is signed.
- GPL-3.0-only plus commercial dual licensing affects redistribution and closed-source embedding; review the unavailable LICENSING.md and CONTRIBUTING.md before integration.
What does this agent do, and when should you use it?
muxel is a native, GPU-accelerated terminal multiplexer built in Rust on GPUI for developers who run several AI coding agents and shells at once. Its tiled and tabbed panes contain real terminal emulators connected through PTYs, with support for splitting, re-docking, pop-out windows, maximization, and restored layouts. Built-in presets cover Claude, opencode, Amp, and other programs, while their commands, arguments, models, system prompts, environment variables, and status markers remain editable. Beyond terminal organization, muxel includes Git worktrees, agent-state notifications, scheduled Loops, shared MEMORY.md files, an editor, a diff viewer, and GitHub PR helpers. Projects can run locally or on a remote host over multiplexed SSH; packages are documented for Linux, macOS, and Windows, although persistent tmux sessions are Unix-only.
A user selects or creates a preset containing a program, args, model, system prompt, env, and status markers, then launches the agent or shell in a tabbed terminal pane. muxel runs each process through a PTY, examines terminal output to classify it as running, working, awaiting-input, or done, and emits in-app and desktop notifications when that state changes. Panes can share named, color-coded Git worktrees and pass through a review/dispose flow, with GitHub PR assistance provided through the gh CLI. A prompt and agent can be stored as a runner for manual reuse or turned into a Loop scheduled every N minutes or hours, or at a daily time. When shared memory is enabled, runs read from and append lessons to .muxel/MEMORY.md. For remote projects, shells, agents, Git operations, and file browsing execute over one multiplexed SSH connection, with persistent tmux sessions and roaming layout restoration.
- A developer handling several feature branches can place separate coding agents in isolated Git worktrees and monitor them side by side.
- An engineer supervising long-running coding tasks can use live states, the cross-project dashboard, and completion or input-needed notifications instead of checking every terminal.
- A team with recurring maintenance prompts can save each prompt-agent pairing as a runner and schedule it with a minute, hourly, or daily Loop.
- A developer whose source lives on a remote server can run agents, browse files, and use remote Git through multiplexed SSH while synchronizing the pane layout.
- A user moving among Claude, opencode, Amp, and ordinary shells can standardize commands, model choices, prompts, and environment variables with editable presets.
- A maintainer reviewing agent-generated changes can combine the worktree review/dispose flow with the built-in diff viewer and GitHub PR helpers.
What are this agent's strengths and limitations?
- It provides a native GPUI workspace with splits, re-docking, pop-out windows, maximization, and persisted layouts rather than merely listing spawned processes.
- Agent activity is derived from terminal output and surfaced as working, awaiting-input, and completion states through notifications and a cross-project dashboard.
- Git worktrees are first-class, named, color-coded resources with sharing, review, and disposal flows plus optional
gh-based PR assistance. - Editable presets and named support for multiple agent programs avoid tying the core workspace to a single model provider.
- The same interface covers local and SSH-hosted projects, including remote Git, file browsing, persistent tmux sessions, and roaming layouts.
- The first source build compiles GPUI and is explicitly expected to take time; Linux builds also need a sizable collection of Wayland/X11, Vulkan, font, and D-Bus development libraries.
- GPUI cannot be cross-compiled across the supported operating systems, so releases require native Linux, macOS, and Windows runners.
- Persistent tmux sessions are Unix-only and disabled on Windows.
- GitHub PR helpers depend on the external
ghCLI, while remote development adds an SSH host and authentication dependency. - Distributed modifications must remain under GPL-3.0; closed-source embedding that cannot comply requires a separate commercial license from ProjectHax LLC.
How do you install or deploy this agent?
Linux or macOS: curl -fsSL https://muxel.sh/install.sh | sh
Windows PowerShell: irm https://muxel.sh/install.ps1 | iex
Packages are also available from GitHub Releases: .deb, .rpm, .AppImage, or portable .tar.gz for Linux; universal .dmg or .zip for macOS; and a signed per-user .exe installer or portable .zip for Windows x64 and arm64.
To run from source, install the recent stable Rust toolchain pinned by the repository and execute cargo run -p muxel. The first build compiles GPUI from its Zed Git dependency. Debian and Ubuntu source builds also require the documented clang, lld, cmake, pkg-config, font, Wayland/X11, ALSA, Vulkan, and D-Bus development packages. No credentials are documented as mandatory for local terminal use, and the supplied material does not specify SSH or GitHub CLI authentication setup.
How do you use this agent?
The documented first invocation from a source checkout is cargo run -p muxel. Once the application is open, create or open a project and launch a Claude, opencode, Amp, or shell pane from a built-in or custom preset; presets can define the program, arguments, model, system prompt, environment, and status markers. Arrange work with horizontal or vertical splits and tabs, and assign named Git worktrees where branch isolation is needed. Save repeatable prompt-agent combinations as runners, or create a Loop for execution every N minutes or hours, or at a daily time. Enable .muxel/MEMORY.md when agents should share lessons across runs. Remote projects can be placed on an SSH host, but the source material does not document the exact host fields, key setup, or authentication commands.
How does this agent compare with similar options?
Compared with terminal multiplexers such as tmux, muxel is a native desktop GUI that combines panes with coding-agent status, Git worktrees, scheduled runs, notifications, editing, and remote layout restoration; its own persistent tmux-session feature remains Unix-only. Compared with a general-purpose terminal app, it is positioned as an agent manager whose presets include models, system prompts, and status markers and whose output tracking recognizes agent states.
FAQ
Is it limited to Claude Code?
Does local use require a cloud account or API key?
gh features depend on separately configured external services.