Agent Parallelization & Session Management

Overview

Category maturity: Emerging. The git-worktree-plus-tmux isolation model has become a settled standard, commercial launches and YC-backed entrants signal real monetization intent, and platform-native features are shipping at speed. Community fragmentation remains high — over a dozen distinct tools compete on overlapping feature sets — and enterprise-grade governance is still the exception rather than the rule.

Direction of travel: Over the next 6-12 months, the standalone tool market will bifurcate:

Polished products with governance, audit trails, and review workflow integration (Conductor, Superset) will compete for team-scale adoption
Terminal-native tools (dmux, amux, claude-squad, Agent of Empires) will retain a strong developer community following, differentiating on agent breadth and extensibility
Platform-native features (Cursor 2.5 async subagents, Claude Code Agent Teams, Codex Desktop) will absorb the "just run a few more agents" use case from solo developers, narrowing the addressable market for lightweight tools that offer no governance advantage

The remaining question is whether any standalone tool achieves sufficient scale or enterprise differentiation to defend against platform encroachment in the team-scale segment.

Coalesced patterns: The category has settled on three reliable foundations:

Git worktrees provide the isolation model: each agent session works in its own directory and branch, eliminating merge conflicts mid-run
Tmux provides the coordination substrate: persistent sessions survive disconnects, panes map naturally to agents, and the model is well understood by engineering teams
A kanban-style task dispatch layer (present in amux, agtx, and now Superset's dashboard) is emerging as the standard interface for assigning work to agents, monitoring status, and routing completed work to review

Teams adopting any tool in this landscape can move with confidence on these three foundations — they are well-trodden paths with broad community support.

Unsolved problems: Several gaps remain material:

Governance over agent-written code entering a production codebase is embryonic: Conductor's checkpoint model and diff-first review come closest, but formal approval gates and audit trails are not yet standard
Cost visibility across many parallel sessions is a gap across almost every tool; amux's token spend dashboard is the most developed treatment
Reliable context handoff between agents remains genuinely difficult: automated handoff without human review still produces integration errors at a meaningful rate
Merge conflict resolution at scale is unsolved — none of the tools profiled here automate conflict resolution when multiple agents modify overlapping files, constraining parallelism on interconnected codebases
Windows support remains limited to WSL; teams on Windows-native developer environments should budget for environment setup overhead

Recommendations

1. Evaluate Superset before committing to a commercial tool. Superset launched March 1, 2026 and reached 8,300+ GitHub stars in under four weeks. It combines the review-centric workflow of Conductor with an open-source license and broader agent support. Run a two-week trial before signing a commercial agreement with an alternative. Confirm the license type (Apache 2.0 vs. ELv2) before deploying at scale, as ELv2 restricts commercial SaaS use.

2. Prioritize agent breadth when evaluating tools. The agent landscape is consolidating, but cost and capability differences between Claude, Codex, Gemini, and OpenCode will persist for at least the next 12 months. Tools that support 5+ agents (dmux at 11, Agent of Empires at 8, CCManager at 8) give teams flexibility to shift agent providers as pricing or model capability changes. Tools that focus narrowly on Claude Code or Claude plus Codex carry provider lock-in risk.

3. Plan for a parallelism ceiling of 5-7 concurrent agents on a laptop. Developer community consensus ("agentmaxxing" discussions on HN and r/ClaudeAI) converges on this figure before rate limits and merge conflict risk erode the throughput gain. For larger-scale parallelism (10+ agents), remote or cloud-based execution (Cursor Background Agents, amux's unattended mode) is more reliable than local tmux farms. Evaluate cloud execution options alongside local tools from the start if you plan to scale beyond 7.

Trends and Strategic Signals

1. Superset's breakout launch reshapes the new entrant landscape. Superset (superset.sh) launched March 1, 2026, and reached 8,300+ GitHub stars within roughly four weeks — the fastest star velocity observed in this category to date. The tool takes a desktop-app approach to multi-agent orchestration: a unified dashboard, built-in diff viewer, git worktree isolation, and one-click merge. This positions it as the most direct challenger to Conductor among polished products, and its open-source licensing (Apache 2.0 or ELv2 — confirm before procurement) removes the paywall friction that has slowed enterprise evaluation of commercial tools. The launch confirms developer appetite for a more visual, review-centric workflow atop tmux-and-worktree infrastructure.

2. Platform-native parallelization is accelerating, compressing the differentiation window for standalone tools. Cursor 2.5 (late February 2026) shipped async subagents that can spawn their own subagents, creating a tree of coordinated work with up to 8 parallel background agents per session. The OpenAI Codex Desktop App launched for macOS on February 2 and Windows on March 4, functioning as a native "command center for agents" with worktree isolation and tasks that run autonomously for up to 30 minutes. Combined with Claude Code Agent Teams (shipped in February as a research preview requiring Opus 4.6), all three major coding-agent platforms now have native or near-native parallelization surfaces. The competitive question for standalone tools shifts from "can you run agents in parallel" to "what governance, cross-agent breadth, and review workflow integration can you add that the platforms cannot?" For teams standardized on a single agent and running fewer than 8 parallel tasks, a standalone tool may add more overhead than value; the case for standalone strengthens when you need cross-agent breadth, formal approval gates, audit trails, or on-premise execution.

3. Agent breadth beyond Claude Code is becoming the primary differentiator between utility tools and platform-agnostic infrastructure. Tools covering five or more agents (dmux at 11, Agent of Empires at 8, CCManager at 8, Agent Deck at 4+) are signaling readiness for teams running heterogeneous agent stacks. Conductor focuses primarily on Claude Code and Codex; its differentiation is UI polish and review workflow quality, not breadth. For PE-portfolio companies that may move between agent providers as cost or capability shifts, agent-breadth is the single strongest proxy for tool longevity.

4. New community entrants are appearing at an accelerating pace, with two notable additions this week. Seshions (HN Show, ~mid-March 2026) offers a single terminal dashboard for launching and routing prompts to parallel agents via tmux. Tmux-IDE (wavyrai, HN Show, ~late March 2026) introduces a declarative ide.yml config for scaffolding agent-team layouts and integrates Claude Code Agent Teams natively. Neither has reached production maturity, but both signal that the developer community is converging on similar patterns — spec-driven orchestration, tmux as substrate, and config-file-first setup.

5. Review workflow integration is maturing from nice-to-have to table stakes. A diff-first review UI was Conductor's point of differentiation at launch. That capability is now present across Superset (built-in diff viewer with side-by-side syntax highlighting), Agent Deck (git integration and PR support), and claude-tmux (git worktree and PR support). Teams evaluating tools should treat review workflow integration as a baseline expectation, then evaluate on governance controls, agent breadth, and operational reliability.

Tools

Superset

Maker: superset-sh (independent team: Avi, Kiet, Satya)
Agent support: Claude Code, OpenAI Codex CLI, Cursor Agent, Gemini CLI, GitHub Copilot, OpenCode, Pi, Amp — any terminal-based coding agent
Isolation model: Git worktrees per task; each agent runs in its own branch and working directory
Interface: Desktop application (Electron + React); macOS only (Windows/Linux untested)
Access: Free; source-available under Elastic License 2.0 (ELv2). Download from GitHub releases
Strengths:
- Broadest agent support among polished desktop tools — works with any CLI agent, not just Claude Code and Codex
- Built-in diff viewer with side-by-side syntax highlighting and one-click merge makes reviewing agent output fast and low-friction
- Workspace monitoring dashboard shows all running agents, their status, and output in a unified view
- 8,300+ GitHub stars in under four weeks — the fastest launch traction in the category, signaling strong developer appetite for a visual orchestration layer
- Automated workspace setup/teardown scripts reduce the operational overhead of managing multiple worktrees
Limitations:
- macOS only today; Windows and Linux are untested according to the project documentation
- Elastic License 2.0 (ELv2) restricts commercial SaaS use; confirm license compatibility before deploying in a product or managed service context
- Requires Bun v1.0+, Git 2.20+, GitHub CLI, and Caddy as prerequisites; the dependency surface is larger than terminal-native tools
- No governance layer or audit trail beyond the built-in diff review; formal approval gates are not yet standard
Enterprise readiness: Developing. The review workflow and agent breadth are strong foundations; ELv2 licensing and macOS-only support are the primary enterprise adoption constraints today.
Best for: Engineering teams on macOS who want a polished visual interface for running multiple CLI agents in parallel with built-in diff review, especially teams evaluating across agent providers.
This week: No new release signals. The March 1 launch remains the most recent major event; active development continues with 2,139 commits and regular changelog updates.

Conductor

Maker: Melty Labs (YC S24); founders Charlie Holtz and Jackson de Campos, San Francisco
Agent support: Claude Code, OpenAI Codex (primary); multi-model comparison mode runs both on the same prompt
Isolation model: Git worktrees per agent; automatic checkpoint snapshots for rollback
Interface: Native macOS desktop app
Access: Commercial (pricing not publicly listed); YC-backed
Strengths:
- Diff-first review UI makes it practical for a non-agent developer to oversee multiple parallel runs and merge selectively
- Checkpoints (automatic repo snapshots) and Spotlight testing (sync back to main repo for immediate test runs) address two of the most common failure modes in parallel agent workflows
- Linear and GitHub integration makes task discovery fit existing project management workflows without a new layer of tooling
- Multi-model mode supports direct A/B comparison across Claude and Codex on the same task
Limitations:
- Mac-only today; teams on Linux or mixed environments will need a secondary workflow; check conductor.build changelog for Linux roadmap
- Agent support focuses on Claude Code and Codex; teams running Gemini, OpenCode, or other CLI agents will find a narrower surface until breadth expands
- Commercial pricing not transparent; budget planning requires a direct conversation with the team
Enterprise readiness: Developing. Checkpoint model and diff review provide lightweight governance, but formal audit trails and access controls are not yet documented publicly.
Best for: Mac-based engineering teams wanting a polished, review-centric experience for Claude Code and Codex parallelization without terminal configuration overhead.
This week: No new release signals. Conductor continues active changelog iteration; check conductor.build/changelog for latest.

claude-squad

Maker: smtg-ai (open-source community)
Agent support: Claude Code, OpenAI Codex, OpenCode, Amp; Gemini support in prior versions; community-maintained agent configs
Isolation model: Git worktrees per session; tmux for session management
Interface: Terminal TUI (polished, Bubble Tea-based)
Access: Free, open-source (MIT); install via Homebrew or Go
Strengths:
- Most mature open-source TUI in the category with the largest documented community; strong GitHub star base and active issue tracker
- Clean, polished terminal interface that lowers the barrier for developers new to tmux-based multi-agent workflows
- Git worktree isolation is well-implemented; Unicode and international character support added in recent releases
- Broad installation options (Homebrew, Go install, binary) suit diverse team environments
Limitations:
- Agent breadth (4 primary agents) is narrower than dmux, CCManager, or Agent of Empires; teams running Gemini CLI, Cline, or Cursor agent workflows will need supplementary tooling
- Worktree environment setup hooks (managing deps, env files, port isolation per worktree) are an open feature request as of March 2026; teams with complex environment requirements should track that issue
- No web dashboard or remote monitoring; all oversight happens in the terminal session
Enterprise readiness: Early. Community-driven project with good reliability for engineering teams comfortable with open-source dependencies; no governance or audit features.
Best for: Engineering teams wanting a reliable, zero-cost terminal UI for Claude Code and Codex parallelization with a proven community behind it.
This week: Feature request for worktree environment setup hooks opened March 5, 2026, indicating active community discussion around production-readiness gaps.

dmux

Maker: Standard Agents (standardagents; FormKit team)
Agent support: Claude Code, OpenAI Codex, OpenCode, Cline CLI, Gemini CLI, Qwen CLI, Amp CLI, Pi CLI, Cursor CLI, Copilot CLI, Crush CLI (11 agents)
Isolation model: Git worktrees per pane; tmux pane per task
Interface: CLI with multi-select TUI for agent/task dispatch
Access: Free, open-source; standardagents/dmux on GitHub
Strengths:
- Broadest agent support in the category at 11 agents, making it the most defensible choice for teams that may shift agent providers over time or run heterogeneous stacks
- Multi-select dispatch lets you launch multiple agents on the same prompt simultaneously for comparison, a unique capability at this price point
- Intelligent automation generates semantic branch names and commit messages automatically (with optional OpenRouter API key), reducing cognitive load on the reviewing engineer
- Proven open-source maintainer track record via FormKit; suggests long-term maintenance commitment
Limitations:
- CLI-first interface has a steeper learning curve than Conductor or Superset; teams without tmux familiarity should plan for an onboarding session
- No governance layer, approval gates, or audit trail; operates on the assumption that engineers review output before merging
- Web or remote monitoring is not available; oversight requires local terminal access
Enterprise readiness: Early. Excellent technical foundation with broad agent support, but no governance controls.
Best for: Polyglot teams or platform-agnostic infrastructure investors who need the broadest agent support and are comfortable with terminal-native workflows.
This week: Blog post coverage on March 21, 2026 (BrightCoding.dev); 1,000+ stars with active daily commits as of March 11, 2026.

amux

Maker: Mixpeek (open-source)
Agent support: Claude Code (primary; other agents supportable via tmux sessions)
Isolation model: Git worktrees per session; tmux for session management; SQLite CAS kanban board prevents duplicate task assignment
Interface: Terminal (tmux-based) plus web dashboard for live terminal peeking and kanban; mobile PWA for remote monitoring
Access: Free, open-source (MIT + Commons Clause); self-host via single Python file
Strengths:
- Self-healing watchdog (auto-compacts context when below 20%, restarts on corruption, auto-responds when stuck) is the most operationally robust unattended-agent capability in the category
- SQLite kanban with atomic task claiming prevents two agents from picking up the same task, a fundamental coordination problem most other tools leave to the engineer
- Shared global memory file and REST API allow agents to delegate work to each other in natural language, enabling genuine multi-agent coordination rather than just parallelism
- Web dashboard and mobile PWA support remote oversight, valuable for teams running long overnight batch jobs
Limitations:
- Primary agent support is Claude Code; teams running heterogeneous agent stacks will find the kanban and delegation features are most mature for Claude-only workflows
- MIT + Commons Clause license prohibits commercial resale; confirm license compatibility with your internal tooling policies before deployment at scale
- Single-file architecture (amux-server.py) is elegantly simple for deployment but may require customization for complex enterprise environments
Enterprise readiness: Early. Best-in-class operational resilience for unattended runs, but no formal access controls or audit trail beyond the kanban log.
Best for: Teams wanting to run large numbers of parallel Claude Code agents unattended overnight or over weekends, with remote monitoring from a phone or browser.
This week: Two separate HN Show launches with active community discussion; no new release signals this week specifically.

CMCCManager

Maker: kbwo (Kodai Kabasawa, independent)
Agent support: Claude Code, Gemini CLI, Codex CLI, Cursor Agent, Copilot CLI, Cline CLI, OpenCode, Kimi CLI (8 agents)
Isolation model: Git worktrees per session; tmux-adjacent process management
Interface: Terminal TUI (CLI app with text UI)
Access: Free, open-source; kbwo/ccmanager on GitHub
Strengths:
- Eight-agent support including Kimi CLI and Cursor Agent covers use cases dmux and claude-squad do not address
- State detection strategy properly tracks the status of different CLI tools by recognizing their unique output patterns, enabling automation workflows (notifications, logging, integrations) that other tools cannot reliably trigger
- Devcontainer support with host-level notification bridges isolated sandbox environments with engineering team workflows
- Auto-approve policies for non-sensitive prompts reduce manual intervention without removing human oversight for sensitive operations
Limitations:
- Individual maintainer project; teams should evaluate bus-factor risk and plan for potential maintenance gaps; the project is actively maintained as of 2026 but has no organizational backing
- No governance layer or audit trail beyond what devcontainer and CI pipelines provide externally
- Less community visibility than claude-squad or dmux; fewer public tutorials and integration guides
Enterprise readiness: Early. Technically capable with good agent breadth, but individual maintainer and limited governance documentation require additional diligence.
Best for: Teams running a mixed set of agents including Cursor Agent, Copilot CLI, or Kimi CLI who need a unified session manager with reliable state detection.
This week: No new release signals.

AEAgent of Empires

Maker: njbrake (independent)
Agent support: Claude Code, OpenCode, Mistral Vibe, Codex CLI, Gemini CLI, Pi.dev, Copilot CLI, Factory Droid (8 agents); Cursor CLI also listed in README
Isolation model: Git worktrees per session; tmux sessions per agent; optional Docker sandboxing for process-level isolation
Interface: Terminal TUI (Rust-based); agents persist in tmux when TUI is closed
Access: Free, open-source; install via Homebrew, Nix, quick-install script, or build from source
Strengths:
- Optional Docker sandboxing is unique in this category and provides process-level isolation beyond git worktrees, relevant for teams with security requirements around agent file system access
- Support for Factory Droid and Mistral Vibe extends coverage to commercial and European-hosted agents not found in most competitors
- Rust implementation provides low overhead; agents continue running after TUI is closed, making it suitable for long-running unattended workflows
- Multiple install paths (Homebrew, Nix, script, source) suit diverse enterprise environments
Limitations:
- Linux and macOS only; Docker sandboxing requires Docker Desktop or Docker Engine installed; teams on Windows need WSL plus Docker
- Individual maintainer; evaluate long-term maintenance commitment before team-scale adoption
- No governance layer or review workflow integration beyond terminal inspection; teams need external PR review tooling
Enterprise readiness: Early. Docker sandboxing is a meaningful differentiator for security-conscious teams, but no audit trail or access controls.
Best for: Security-conscious teams or teams running agents that require process-level isolation, especially those using Mistral Vibe or Factory Droid alongside mainstream agents.
This week: No new release signals this week. HN Show launch for agent-of-empires was January 2026.

AXagtx

Maker: fynnfluegge (independent)
Agent support: Claude Code, OpenAI Codex, Gemini CLI, OpenCode, Cursor, GitHub Copilot (via orchestrator)
Isolation model: Git worktrees per task; tmux window per task session; MCP server for orchestrator-to-kanban communication
Interface: Terminal TUI with kanban dashboard mode; orchestrator mode for autonomous AI-driven task management
Access: Free, open-source; fynnfluegge/agtx on GitHub
Strengths:
- Per-phase agent configuration (e.g., Gemini for planning, Claude for implementation, Codex for review) is the most sophisticated task-level agent routing in the terminal tool category
- Built-in MCP server exposes the kanban board as tooling for an orchestrator agent, enabling genuine AI-driven task dispatch without manual assignment
- Backlog through Done kanban workflow (Backlog/Research, Planning, Running, Review, Done) maps cleanly onto engineering sprint structures
- Both manual dashboard mode and fully autonomous orchestrator mode give teams flexibility in how much control they delegate
Limitations:
- Autonomous orchestrator mode requires careful specification authoring; teams should plan for a prompt engineering investment before deploying at scale
- Individual maintainer project; the MCP server dependency adds an integration surface that requires maintenance as the MCP spec evolves
- Less community visibility than claude-squad or dmux; fewer published tutorials; budget time for self-guided setup
Enterprise readiness: Early. Most architecturally sophisticated approach to multi-agent coordination in the terminal category, but no governance or audit controls.
Best for: Teams that want AI-driven task dispatch and orchestration across multiple agent types, and have the prompt engineering capability to author task specifications.
This week: No new release signals.

CTclaude-tmux

Maker: Niels Groeneveld (nielsgroen, independent)
Agent support: Claude Code (primary; tmux-based design supports other agents via configuration)
Isolation model: Git worktrees per session; tmux for session management
Interface: Terminal TUI (Rust, Bubble Tea); invoked as a tmux popup via keybinding
Access: Free, open-source (AGPL-3.0); install via cargo install claude-tmux
Strengths:
- Lightweight and focused: provides live preview of running Claude Code sessions with ANSI color, session creation/kill/rename, and PR support without adding orchestration complexity
- Rust implementation ensures fast startup and low resource overhead; sub-50ms launch is achievable
- Git worktree and PR support make it a complete lightweight toolchain for solo developers or small teams running 2 to 5 parallel Claude Code sessions
- Fuzzy session filtering speeds navigation across many concurrent sessions
Limitations:
- Narrowest scope in the category: designed for Claude Code monitoring and switching, not multi-agent dispatch or coordination; teams needing broader agent support should evaluate Agent Deck or ccmanager
- AGPL-3.0 license has copyleft implications for teams embedding it in proprietary internal tooling; review with your legal team
- No web dashboard or remote monitoring; oversight is terminal-local
Enterprise readiness: Early. Reliable for small-team Claude Code workflows; too narrow in scope for enterprise multi-agent needs.
Best for: Individual developers or very small teams who want a fast, lightweight Claude Code session monitor inside an existing tmux workflow.
This week: No new release signals. Listed as a resource in the awesome-claude-code community list.

ADAgent Deck

Maker: asheshgoplani (independent; community fork at starascendin/agent-deck-webui adds web UI)
Agent support: Claude Code, Gemini CLI, OpenCode, Codex, and others via tmux configuration
Isolation model: Git worktrees per agent; tmux-based session management
Interface: Terminal TUI (Go, Bubble Tea); macOS, Linux, Windows (WSL) via single install command
Access: Free, open-source; asheshgoplani/agent-deck on GitHub
Strengths:
- Token usage and cost tracking across all sessions via Claude Code hook integration addresses the cost visibility gap present in virtually every other tool
- Conductor sessions (persistent Claude Code instances that monitor and orchestrate other sessions) enable lightweight automated oversight with Telegram and Slack escalation
- Session forking with context inheritance and global search across conversations reduce repeated context-setting overhead
- Windows WSL support broadens the platform footprint beyond most terminal tools
Limitations:
- Individual maintainer project with a community fork already diverging (webui fork); teams should clarify which branch to follow before building internal workflows on top of it
- Conductor sessions (the orchestrator feature) require prompt engineering to configure reliably; plan for setup time
- Agent breadth is functional but less documented than dmux or CCManager; verify support for specific agents before committing
Enterprise readiness: Early. Token cost tracking and Slack/Telegram escalation are distinctive features for teams managing API spend; no formal governance or access controls.
Best for: Teams that want built-in cost visibility across parallel sessions and lightweight automated oversight via a persistent orchestrator Claude instance.
This week: No new release signals. Community fork (agent-deck-webui) active, suggesting growing interest in a web-based monitoring layer.

NTNTM (Named Tmux Manager)

Maker: Dicklesworthstone (independent; also author of the agentic_coding_flywheel_setup bootstrapping project)
Agent support: Claude Code, OpenAI Codex, Gemini CLI (primary three; tmux-based design supports others via config)
Isolation model: tmux panes per agent; configurable safety policies; git worktrees via underlying agent configuration
Interface: Terminal TUI (Go CLI); TUI command palette with broadcast prompts and conflict tracking
Access: Free, open-source; Dicklesworthstone/ntm on GitHub
Strengths:
- TUI command palette with broadcast prompts (send the same instruction to all agents simultaneously) is a distinctive capability for coordination-heavy workflows
- Configurable safety policies provide a governance-adjacent feature not commonly found in terminal tools
- Context monitoring and conflict tracking surface operational problems before they compound
- Roadmap includes REST/WebSocket API and a Next.js 16 web UI, which would meaningfully expand enterprise surface area if delivered
Limitations:
- Agent support is currently documented for three agents (Claude, Codex, Gemini); teams running broader agent stacks should verify before adopting
- The web UI and REST API are roadmap items, not shipped; evaluate against current capabilities, not planned ones
- Individual maintainer project with an ambitious roadmap; assess maintenance bandwidth before team-scale adoption
Enterprise readiness: Early. Safety policies and conflict tracking are meaningful steps toward governance; full enterprise readiness depends on the API and web UI roadmap shipping.
Best for: Teams that want broadcast prompt coordination across Claude, Codex, and Gemini with a Go-based terminal tool and are willing to invest in contributing to an actively evolving project.
This week: No new release signals. Roadmap for REST/WebSocket API and web UI documented in the repository.

Platform Convergence Signals

Claude Code Agent Teams (Anthropic)

Status: Research preview, shipped with Claude Code v2.1.32, February 2026. Disabled by default; enable via CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 in settings.json. Requires Opus 4.6.
Capability: One Claude Code session acts as team lead, coordinating sub-sessions that work independently with their own context windows and communicate directly with each other. Strongest use cases: parallel research, new module development, debugging with competing hypotheses, cross-layer coordination.
Implication for standalone tools: Closes the "run a few agents in parallel" use case for teams already standardized on Claude Code and willing to use Opus 4.6 pricing. Does not address cross-agent heterogeneity, governance pipelines, or non-Claude agent stacks. Standalone tools with strong governance or agent breadth retain differentiation.

Cursor Background Agents / Cursor 2.5

Status: Generally available; Cursor 2.5 shipped late February 2026 with async subagents and subagent-spawning capability.
Capability: Up to 8 parallel background agents, each in its own cloud-isolated workspace (git worktrees or remote machines). Cursor 2.5 added async subagents that can spawn their own subagents, creating a coordinated work tree. Completed work opens a PR for human review.
Implication for standalone tools: Closes parallel agent execution for Cursor-committed teams. Teams running Cursor as their primary IDE have less reason to adopt a standalone multiplexer. Standalone tools retain advantage for teams running heterogeneous agent environments or requiring on-premise execution.

OpenAI Codex Desktop App

Status: macOS launch February 2, 2026; Windows launch March 4, 2026. Over 1 million developers using Codex as of launch announcement.
Capability: Native macOS and Windows app functioning as a command center for multiple parallel Codex agents. Git worktree isolation, tasks run autonomously up to 30 minutes, organized by project. Complements but does not replace IDE-level tooling for developers who use multiple agents.
Implication for standalone tools: Closes the native Codex parallelization use case on both major desktop platforms. Reduces the value of standalone tools for teams running Codex exclusively. Reinforces the multi-agent heterogeneity argument for tools like dmux and Agent of Empires that support 8+ agents.

Adoption and Traction

Superset: Launched March 1, 2026; reached 8,300+ GitHub stars in under four weeks. Trending #8 on GitHub at launch. Open-source. Fastest new-entrant star velocity in this category to date. Sources: GitHub (superset-sh/superset), byteiota.com review.
Conductor: YC S24 (Melty Labs). HN Show thread ("Show HN: Conductor, a Mac app that lets you run a bunch of Claude Codes at once") active with positive developer reception. Changelog at conductor.build shows active release cadence. Sources: ycombinator.com, conductor.build/changelog.
dmux: 1,000+ GitHub stars as of March 11, 2026, with daily commits and responsive maintainers noted. BrightCoding.dev review published March 21, 2026. Source: github.com/standardagents/dmux, blog.brightcoding.dev.
claude-squad: v1.0.14 released December 24, 2025. Feature request for worktree environment setup hooks opened March 5, 2026, indicating active community engagement. Source: github.com/smtg-ai/claude-squad.
amux: Two separate HN Show launches (different framing: first as "tmux-based multiplexer," second as "single-file agent multiplexer for headless sessions"), both generating discussion. Source: news.ycombinator.com.
Claude Code Agent Teams (Anthropic): Shipped as research preview in Claude Code v2.1.32 (February 2026). Requires Opus 4.6. Multiple blog posts and tutorials published, including Anthropic Engineering's own write-up on building a C compiler with parallel Claudes. Source: code.claude.com/docs/en/agent-teams, anthropic.com/engineering.
Cursor 2.5: Released late February 2026 with async subagents and subagent-spawning-subagents capability. Up to 8 parallel background agents. Source: cursor.com/docs, medium.com toward-data-engineering.
OpenAI Codex Desktop App: macOS launch February 2, 2026 (TechCrunch); Windows launch March 4, 2026 (MEXC News). Over 1 million developers using Codex as of the announcement. Source: openai.com, venturebeat.com.

New Entrants & Watch List

New entrants (standalone parallelization tools):

Superset (superset.sh / superset-sh on GitHub): Open-source (Apache 2.0 or ELv2; verify before procurement). Supports Claude Code, OpenCode, Codex, Cursor Agent, Gemini CLI. Desktop app with unified agent dashboard, built-in diff viewer, git worktree isolation, one-click merge. Launched March 1, 2026. 8,300+ GitHub stars in under 4 weeks — strongest launch traction in this category to date. Warrants immediate addition to the core coverage list: it is the first tool to combine the review workflow quality of Conductor with an open-source license and broader agent support. Watch licensing clarification closely.
Seshions: Terminal UI providing one dashboard for launching, routing prompts to, and monitoring parallel coding agents via tmux. HN Show post ~mid-March 2026. Agent support and isolation model not fully documented yet. Worth tracking for a second week before forming a view on scope fit.
Tmux-IDE (wavyrai/tmux-ide): Declarative, scriptable terminal IDE configured via ide.yml. Launches a tmux session with labeled panes, dev servers, and Claude Code instances. Integrates Claude Code Agent Teams natively (enables CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS automatically). HN Show post ~late March 2026. Narrower in scope than the core coverage list tools but warrants watching as a spec-driven orchestration pattern that other tools may adopt.

Platform convergence signals: See Platform Convergence Signals section above for Claude Code Agent Teams, Cursor Background Agents, and OpenAI Codex Desktop App coverage.