HarnessMatch

Search 73 product records by name, workflow, interface, or documented capability.

Quick access
Use ↑ ↓ to move, Enter to open, Esc to close.

Quick access links shown.

Menu

Interface layer

Coding-agent GUI landscape.

Inspect source-separated public activity, platform support, workflow fit, and documented mechanisms. Popularity and quality remain separate.

Daily source refresh

Public activity signals

Distribution and repository activity in source-native units. These signals provide context, not quality or workflow-fit scores.

Browse interfaces

Start from the complete catalog. Select a workflow only when you want evidence-backed fit groups.

20 interfaces shown

All documented interfaces

20 products · alphabetical

Agetor

Code inspected

A local kanban control plane for parallel Claude Code, Codex, experimental Cursor Agent, and Gemini CLI tasks, isolated worktrees, structured approvals, and review.

Multi-harness workspaceOpen sourcemacOS
Product details and evidence
Best for
macOS developers coordinating several local tasks or accounts across repositories while keeping each task on its own branch and worktree.
Check first
The packaged app is Apple-silicon macOS only, Codex support is newer than the public-site copy, and the product explicitly provides no cloud relay or remote sandbox.
Harness coverage
Claude Code, Codex + 2 moreThe pinned source implements Claude Code and Codex. Release 0.0.18 adds experimental, disabled-by-default Cursor Agent, while 0.1.0 adds Gemini CLI as a built-in harness; account or binary aliases do not establish additional integrations.
Capability claims
  • documented
    parallel sessions

    Independent harness tasks can run in parallel across repositories, worktrees, and account-specific homes.

  • documented
    workspace isolation

    Git repositories use a pinned base commit and a dedicated branch and worktree per task by default.

  • documented
    visual review

    The desktop board exposes task diffs in a dedicated dialog alongside run output and approval cards.

  • contradicted
    remote execution or access

    The current product record says execution stays on the local machine and provides no cloud relay or remote sandbox.

  • unknown
    shared team access

    The current first-party record does not establish teammates entering the same live Agetor workspace.

First-party sources
  • Agetor 0.1.0 Gemini CLI release

    Built-in Gemini CLI harness support alongside saved prompts, message reuse, task-stream tool-call folding, and Cursor plan approval handling.

  • Agetor 0.0.18 Cursor Agent release

    Experimental Cursor Agent integration through cursor-agent CLI, disabled by default, alongside worktree cleanup, PR workflow, diff-review, and background-agent lifecycle changes.

  • Agetor pinned product and architecture record

    Current Claude Code and Codex drivers, parallel task model, worktree isolation, local-only boundary, packaging, and license.

  • Agetor task diff dialog

    Dedicated visual diff loading, file navigation, hunk rendering, and review states in the desktop UI.

  • Agetor product site

    Packaged macOS availability and the older public harness copy that still describes Codex as forthcoming.

Code audit

Inspected commit 03b2328009b6.

  • The pinned runtime implements separate Claude Code and Codex harness kinds, including account and binary aliases.
  • Task creation and cleanup implement dedicated Git branches and worktrees.
  • The desktop client implements a structured task-diff dialog and local approval flow.
Inspected paths
  • README.md
  • src/shared/types.ts
  • src/bun/codex-tmux.ts
  • src/bun/worktree.ts
  • src/mainview/components/kanban/DiffDialog.tsx

The audit establishes implementation presence at the pinned commit, not integration reliability, usability, security, or task quality.

AionUi

Code inspected

A cross-platform Cowork app for many named coding agents, parallel sessions, visual file changes, automation, and browser access.

Multi-harness workspaceOpen sourcemacOS · Windows · Linux · Browser
Product details and evidence
Best for
Users who want broad named-agent coverage, a built-in agent, desktop and browser surfaces, and remote access from their own machine or server.
Check first
Its Team Mode coordinates agents rather than human teammates, and the documented shared-folder model does not establish per-session worktree isolation.
Harness coverage
Aion CLI, Antigravity + 18 moreThe pinned product record, 2.1.46 release, and 2.1.57–2.1.60 changelog establish 20 external CLI integrations plus a built-in agent. Additional backends must speak its supported ACP path; that is not evidence that an arbitrary CLI can be launched.
Capability claims
  • documented
    parallel sessions

    Multi-Agent Mode runs multiple agents simultaneously with independent conversation context.

  • unknown
    workspace isolation

    Current first-party sources do not establish automatic branch or worktree isolation; Team Mode explicitly uses one shared folder.

  • documented
    visual review

    The desktop implementation renders file-change summaries and a dedicated side-by-side or line diff viewer.

  • documented
    remote execution or access

    WebUI mode exposes the application in a browser, supports remote devices on the network, and can run headlessly on a server.

  • unknown
    shared team access

    Agent-to-agent Team Mode does not establish multiple human teammates entering the same live workspace.

First-party sources
  • AionUi 2.1.46 release

    Antigravity as a working built-in direct-CLI integration through the ACP chat surface; no capability of the underlying harness is transferred to AionUi.

  • AionUi 2.1.57–2.1.60 changelog

    Direct local-CLI launch for OMP, mid-turn interjection, cross-conversation context delivery, archive and remount controls, bounded runtime locks, and path-traversal hardening without transferring harness capabilities to AionUi.

  • AionUi pinned product record

    Named CLI integrations other than the separately released Antigravity addition, parallel sessions, agent Team Mode, platforms, distribution, and license.

  • AionUi WebUI guide

    Browser, LAN, remote-device, headless-server, and platform-specific WebUI startup paths.

  • AionUi diff viewer implementation

    Visual diff rendering used by the conversation preview surface.

Code audit

Inspected commit 0f7635b2f8a6.

  • The pinned product record plus the 2.1.46 release establish 19 external CLI integrations and separate them from its built-in agent.
  • The pinned Antigravity E2E path exercises selection, direct-CLI startup, first-turn delivery, model options, and reported token usage without transferring Antigravity capability claims to AionUi.
  • Multi-Agent and Team Mode surfaces are implemented, with Team Mode coordinating agents over a shared folder.
  • The desktop client implements file-change and visual-diff surfaces, while WebUI supports browser and headless-server access.
Inspected paths
  • readme.md
  • docs/guides/webui.md
  • packages/desktop/src/renderer/components/base/FileChangesPanel.tsx
  • packages/desktop/src/renderer/pages/conversation/Preview/components/viewers/DiffViewer.tsx
  • packages/desktop/src/renderer/pages/team/TeamPage.tsx
  • tests/e2e/features/conversations/antigravity/basic-flow.e2e.ts

Agent-to-agent Team Mode is not evidence of human-team collaboration, and implementation presence does not establish integration parity or reliability.

AQ

Documented

A browser-based, multiplayer workspace that runs agent CLIs on a team runner.

Multi-harness workspaceProprietaryBrowser · macOS · Windows · Linux
Product details and evidence
Best for
Teams that need shared terminals, previews, review comments, and persistent remote sessions.
Check first
Execution depends on a connected self-managed or AQ-managed runner, and the GUI implementation is not public.
Harness coverage
Antigravity, Claude Code + 4 moreSix named agent CLIs plus plain shells. Each user signs in with their own CLI account or subscription; AQ does not resell agent usage.
Capability claims
  • documented
    parallel sessions

    Multiple workspaces and agents can run concurrently.

  • documented
    workspace isolation

    Each workspace receives its own Git worktree and branch.

  • documented
    visual review

    The browser workspace includes an editor, live previews, comments, and PR state.

  • documented
    remote execution or access

    Persistent sessions run on a runner VM and survive browser or laptop disconnects.

  • documented
    shared team access

    Teammates can enter the same live terminal, editor, and preview.

First-party sources
  • How AQ works

    Worktrees, persistent sessions, supported agents, shared access, previews, and runners.

  • AQ product surface

    Browser workspace, team access, agent CLIs, previews, runner choices, and bring-your-own credentials.

  • Parallel Claude Code sessions

    Per-task worktrees, persistent tmux sessions, automatic setup, preview ports, collaboration, and cleanup.

  • Persistent remote sessions

    Runner custody, persistent terminals, remote reconnection, per-user authentication, worktrees, and shared steering.

Blackcrab

Code inspected

A native Claude Code workspace with searchable local history, up to six live panels, worktree-aware grids, diffs, terminal, and preview.

Harness-native GUIOpen sourcemacOS · Windows · Linux
Product details and evidence
Best for
Claude Code users who want several local sessions visible together with transcript inspection, Git context, usage reporting, and verification tools.
Check first
The project calls itself early and macOS-first even though official downloads cover three desktop platforms; mobile remote work is still described as an unfinished companion path.
Harness coverage
Claude CodeBlackcrab wraps the locally installed Claude Code CLI and indexes its saved sessions. It does not establish support for another harness.
Capability claims
  • documented
    parallel sessions

    The tileable grid can run and retain up to six live Claude Code panels with separate subprocess and UI state.

  • documented
    workspace isolation

    New grid panels can use Claude Code worktree mode so parallel work receives a separate checkout.

  • documented
    visual review

    Structured transcripts render diffs and the workspace keeps a terminal and native preview beside the task.

  • unknown
    remote execution or access

    The pinned repository contains an experimental mobile-remote path, but its own product record says the companion is not yet connected to a host.

  • unknown
    shared team access

    Current first-party sources do not establish teammates sharing one live Blackcrab workspace.

First-party sources
Code audit

Inspected commit 6ab00e0a286e.

  • The native process boundary launches and resumes locally installed Claude Code sessions.
  • The desktop grid implements multiple live panels, worktree-aware state, terminal, preview, and structured transcript views.
  • The mobile-remote document describes an experimental companion path and explicitly records incomplete host connectivity.
Inspected paths
  • README.md
  • src/App.tsx
  • src/LivePanel.tsx
  • src-tauri/src/lib.rs
  • docs/mobile-remote.md

The audit establishes mechanisms in an early, macOS-first codebase; it does not establish cross-platform reliability or a production-ready remote path.

Claude Code Desktop

Documented

The Code tab in Claude Desktop, using the Claude Code engine with dedicated developer panes.

Harness-native GUIProprietarymacOS · Windows
Product details and evidence
Best for
Claude Code users who want one native surface for chat, diffs, terminals, previews, and remote sessions.
Check first
It is tied to Claude Code and Anthropic account availability; the desktop GUI source is not public.
Harness coverage
Claude CodeClaude Code only. The desktop Code tab requires an eligible Anthropic account or subscription, and cloud sessions count against its usage limits.
Capability claims
  • documented
    parallel sessions

    The session sidebar runs multiple independent sessions in parallel.

  • documented
    workspace isolation

    Parallel sessions use automatic Git worktree isolation.

  • documented
    visual review

    Diff comments, code review, CI monitoring, file editing, terminal, and previews are built in.

  • documented
    remote execution or access

    Sessions can run locally, in Anthropic cloud, or over SSH.

  • unknown
    shared team access

    The current desktop reference does not establish a shared live coding session for multiple teammates.

First-party sources
  • Claude Code desktop application

    macOS and Windows availability, Code-tab scope, parallel sessions, review panes, permissions, cloud, and SSH.

  • Claude Code worktrees

    Automatic desktop worktrees, parallel-session isolation, branch selection, ignored-file handling, and cleanup.

  • Claude Code cloud sessions

    Managed remote execution, repository access, session continuation, parallel usage, and cloud-environment boundaries.

Codeg

Code inspected

A desktop, server, browser, and mobile workspace for many ACP coding agents, delegation, split views, worktrees, Git, and diffs.

Multi-harness workspaceOpen sourcemacOS · Windows · Linux · Browser · iOS · Android
Product details and evidence
Best for
Developers who want broad ACP-agent coverage, searchable cross-agent history, parallel worktrees, and remote control from browser or mobile clients.
Check first
Integration depth and authentication remain agent-specific, custom integrations must implement ACP, and the native iOS and Android clients are described as still in testing.
Harness coverage
Claude Code, Cline + 12 moreTwelve built-in ACP integrations are pinned in the audited registry; releases 0.26.2 and 0.27.0 add DeepSeek Harness and Qoder as the thirteenth and fourteenth bundled agents. Users can register other ACP-compatible agents, but protocol compatibility is distinct from launching an arbitrary CLI.
Capability claims
  • documented
    parallel sessions

    Split views and cross-agent delegation run independent sessions side by side inside one workspace.

  • documented
    workspace isolation

    Built-in Git worktree flows create a separate branch, directory, and conversation for parallel work; repository issues and pull requests can also start isolated agent worktrees.

  • documented
    visual review

    Agent edits appear as live diffs beside conversations, with an editor, Git client, merge-conflict surface, and review flow for repository-issued worktree tasks.

  • documented
    remote execution or access

    A standalone server and Docker mode expose the workspace in a browser, while mobile clients connect to the desktop web service or server.

  • unknown
    shared team access

    Multi-agent delegation does not establish multiple human teammates sharing the same live workspace.

First-party sources
  • Codeg pinned product record

    Twelve named agents, custom ACP registration, delegation, split views, worktrees, diffs, server and mobile surfaces, platforms, and license.

  • Codeg pinned ACP registry

    The exact twelve built-in agent identities and the separation between built-in and custom ACP agents.

  • Codeg 0.26.2 release

    DeepSeek Harness as a bundled agent, session ownership checks, history retention, remote-workspace entry points, and multi-view turn recovery.

  • Codeg 0.27.0 release

    Qoder as a bundled agent and a repository panel that turns GitHub or GitLab issues and pull requests into isolated agent worktrees with review and no automatic merge.

Code audit

Inspected commit d665f7b1f87e.

  • The pinned ACP registry defines 12 built-in agent identities and keeps custom ACP agents on a separate registration path.
  • Git worktree creation, branch assignment, and cleanup are implemented for parallel work tasks.
  • The client implements a visual diff viewer and the backend exposes browser and mobile connection routes.
Inspected paths
  • README.md
  • src-tauri/src/acp/registry.rs
  • src-tauri/src/commands/custom_agents.rs
  • src-tauri/src/work_task/git.rs
  • src/components/diff/diff-viewer.tsx
  • src-tauri/src/web/router.rs

The audit establishes implementation presence, not equal feature depth, authentication compatibility, or reliability across the 12 agent integrations.

Codex in ChatGPT Desktop

Documented

The dedicated Codex coding experience inside the ChatGPT desktop app.

Harness-native GUIProprietarymacOS · Windows
Product details and evidence
Best for
Codex users who want developer details, inline diff editing, PR review, and remote handoff in the first-party app.
Check first
It is a Codex-only GUI; the open Codex CLI repository does not make the proprietary desktop interface code-verifiable.
Harness coverage
CodexCodex only. Local desktop use accepts ChatGPT sign-in or an OpenAI API key, with the corresponding plan or API billing.
Capability claims
  • documented
    parallel sessions

    The desktop Codex experience can run multiple independent chats in one project.

  • documented
    workspace isolation

    Codex can create a managed Git worktree for each independent desktop chat.

  • documented
    visual review

    The coding surface includes inline diff editing and pull-request review.

  • documented
    remote execution or access

    Chat handoff moves a chat and Git state between local and connected remote hosts.

  • unknown
    shared team access

    Current first-party desktop documentation does not establish shared live teammate access to one task.

First-party sources

Conductor

Documented

A Mac control plane for parallel coding agents in local worktrees or isolated cloud microVMs.

Multi-harness workspaceProprietarymacOS
Product details and evidence
Best for
Mac users and teams that want one parallel-agent dashboard across local and persistent cloud workspaces.
Check first
The desktop product is Mac-only, Conductor Cloud requires Pro, and the programmatic API remains beta. Named integrations do not establish arbitrary-CLI support.
Harness coverage
Claude Code, Codex + 2 moreFour documented integrations. Conductor reuses each CLI's existing login, subscription, or provider configuration.
Capability claims
  • documented
    parallel sessions

    The app runs Claude Code, Codex, Cursor Agent, and OpenCode in parallel.

  • documented
    workspace isolation

    Local workspaces use separate Git worktrees for development isolation, not a security boundary; Conductor Cloud uses isolated microVM sandboxes.

  • documented
    visual review

    The product documents agent monitoring followed by review and merge.

  • documented
    remote execution or access

    Cloud workspaces run on isolated microVMs, continue after the Mac app closes, and can be created or steered through the API.

  • documented
    shared team access

    Teammates can open shared workspace links, see who is active, follow work, and prompt agents together in real time.

First-party sources
  • Conductor documentation

    Four supported agents, Mac scope, parallel workspaces, worktrees, review, and merge.

  • Conductor Git worktrees

    Local workspaces use separate Git working trees for development isolation rather than as a security boundary.

  • Conductor 0.78.0 Cloud launch

    Pro cloud workspaces on isolated microVMs, persistent remote execution, shared live workspaces, and a beta management API.

Emdash

Code inspected

A local-first desktop environment for parallel coding agents, review, and issue-to-agent workflows.

Multi-harness workspaceOpen sourcemacOS · Windows · Linux
Product details and evidence
Best for
Developers who need cross-platform local and SSH projects with broad agent and issue-tracker support.
Check first
The supported provider set has provider-specific behavior, and shared teammate access is not established by the current record.
Harness coverage
Amp, Antigravity + 33 moreThe audited registry contains 35 named CLI integrations; the live provider page currently lists 34 because CodeBuddy is present in code but not yet on that page. Capabilities vary by provider, and every CLI needs its own product access.
Capability claims
  • documented
    parallel sessions

    The desktop app runs multiple coding agents in parallel.

  • documented
    workspace isolation

    Each task receives a Git worktree and branch.

  • documented
    visual review

    Diff review, PR creation, CI inspection, and merge are available in one surface.

  • documented
    remote execution or access

    Remote projects run on user-controlled machines over SSH and SFTP.

  • unknown
    shared team access

    The current official record does not establish multiple teammates sharing one live workspace.

First-party sources
  • Emdash provider documentation

    Named CLI integrations, provider-specific capabilities, authentication prerequisites, and unsupported-provider requests.

  • Emdash official repository

    Current provider registry, platforms, worktrees, review, issue integrations, SSH projects, privacy, and license.

Code audit

Inspected commit 5ace464a0c23.

  • Worktree lifecycle and Git review operations are implemented in the desktop app.
  • Local and SSH project providers share the workspace abstraction.
  • The pinned plugin registry registers 35 named CLI providers; integration depth differs by provider and 22 are documented as ACP-capable.
Inspected paths
  • apps/emdash-desktop/src/main/core/projects/worktrees/worktree-service.ts
  • apps/emdash-desktop/src/main/core/projects/create-project-provider.ts
  • apps/emdash-desktop/src/main/core/git/worktree/controller.ts
  • packages/plugins/src/agents/registry.ts
  • agents/integrations/providers.md

The audit establishes implementation presence, not usability, security, or reliable performance under load.

HAPI

Code inspected

A local-first web, PWA, and Telegram control surface for handing off five coding-agent CLIs between terminal and remote devices.

Multi-harness workspaceOpen sourceBrowser
Product details and evidence
Best for
Developers who want to keep agent execution on their workstation while checking sessions, approvals, files, diffs, and terminals from a browser or phone.
Check first
The GUI is browser-based, current sources do not establish automatic worktree isolation, and multi-user shared-workspace behavior is not documented.
Harness coverage
Claude Code, Codex + 3 moreHAPI wraps five named local agent CLIs. Each CLI keeps its own runtime, authentication, history, tools, and provider behavior.
Capability claims
  • documented
    parallel sessions

    The web client groups and tracks independent live sessions across projects and connected machines.

  • unknown
    workspace isolation

    Scoped workspace roots limit browsing and session start directories, but current sources do not establish automatic branch or worktree isolation.

  • documented
    visual review

    The web client renders file changes in an expandable visual diff with line counts and additions and deletions.

  • documented
    remote execution or access

    Web, PWA, and Telegram clients can control the named agents and terminal on the working machine through relay or self-hosted access.

  • unknown
    shared team access

    Current first-party sources do not establish teammates entering the same live HAPI workspace.

First-party sources
Code audit

Inspected commit 9d07857570bb.

  • The shared flavor registry implements five named coding-agent CLI integrations.
  • The web client groups live sessions by project and machine and implements structured visual diffs.
  • The hub implements the browser-facing control surface used for relay and self-hosted access.
Inspected paths
  • README.md
  • shared/src/flavors.ts
  • web/src/components/SessionList.tsx
  • web/src/components/DiffView.tsx
  • hub/src/web/server.ts

Session grouping is evidence of concurrent-session control, not automatic worktree isolation or shared human-team workspaces.

Maestro

Code inspected

An open-source desktop workspace for running and coordinating multiple named coding agents across sessions and worktrees.

Multi-harness workspaceOpen sourcemacOS · Windows · Linux
Product details and evidence
Best for
Linux, Windows, and macOS users who want parallel agent sessions, worktree isolation, visual diffs, agent group chat, and browser-based remote control.
Check first
Group chat coordinates AI agents rather than human teammates, so shared live team operation is not established. Remote access uses a token-bearing URL and an optional Cloudflare tunnel.
Harness coverage
Claude Code, Codex + 7 moreThe compatibility page marks Claude Code, Codex, OpenCode, and Factory Droid fully supported and five more integrations beta. Gemini CLI is planned, not current; integration depth varies by provider.
Capability claims
  • documented
    parallel sessions

    Multiple agent sessions can run simultaneously, including worktree sub-agents with separate branches and directories.

  • documented
    workspace isolation

    Worktree sub-agents operate in isolated directories and branches while the main session remains on its original branch.

  • documented
    visual review

    The Git view provides a syntax-highlighted, side-by-side diff for the main repository and worktrees.

  • documented
    remote execution or access

    A token-protected web interface can view live sessions and send commands from another device, with an optional Cloudflare tunnel for internet access.

  • unknown
    shared team access

    Current sources document multi-agent group chat and single-user remote control, but not multiple people sharing or steering one live workspace.

First-party sources
  • Maestro installation and provider support

    Desktop platforms, supported and beta coding-agent integrations, planned Gemini CLI support, and provider-specific setup.

  • Maestro Git and worktrees

    Parallel worktree sub-agents, isolated branches and directories, worktree lifecycle, and side-by-side Git diffs.

  • Maestro remote control

    Token-based browser access, live session viewing, mobile command input, local-network access, and optional Cloudflare tunneling.

  • Maestro group chat

    Moderated conversations among multiple AI agents, including parallel responses, synthesis, and continued rounds.

  • Maestro repository snapshot

    Pinned implementation snapshot for provider definitions, worktrees, diffs, remote control, group chat, and AGPL licensing.

Code audit

Inspected commit e3479fe05b39.

  • Provider definitions and capability gates implement a named set of coding-agent integrations rather than unrestricted CLI discovery.
  • The renderer implements worktree lifecycle controls and a dedicated Git diff surface.
  • The desktop process exposes token-gated web access to live sessions and command input.
  • Group chat moderates conversations among AI-agent participants, not human collaborators sharing one live workspace.
Inspected paths
  • src/main/agents/definitions.ts
  • src/main/agents/capabilities.ts
  • src/renderer/hooks/worktree/useWorktreeHandlers.ts
  • src/renderer/components/GitDiffViewer.tsx
  • src/main/web-server/WebServer.ts
  • src/main/group-chat/group-chat-moderator.ts

The pinned implementation and live compatibility page do not fully align on every beta integration. This audit therefore does not establish implementation parity across the published provider list or human multi-user collaboration.

Nimbalyst

Code inspected

A visual editor and session manager for agent work across documents, mockups, code, tasks, Git, and shared team artifacts.

Multi-harness workspaceOpen sourcemacOS · Windows · Linux · iOS
Product details and evidence
Best for
Visual workflows that need rich file editors, agent sessions, worktrees, mobile follow-up, and collaborative documents or trackers in one project space.
Check first
OpenCode and Copilot support are marked alpha. Teams Beta documents shared artifacts and agent-visible context, but not teammates sharing or steering the same live coding-agent session.
Harness coverage
Codex, Claude Code + 2 moreCodex and Claude Code are the primary integrations; OpenCode and GitHub Copilot are explicitly marked alpha.
Capability claims
  • documented
    parallel sessions

    Sessions can run in parallel and be managed from a Kanban view.

  • documented
    workspace isolation

    The developer workflow includes worktrees and per-session worktree state.

  • documented
    visual review

    WYSIWYG editors and red/green change review cover code and visual artifacts.

  • documented
    remote execution or access

    The mobile app can monitor and respond to Codex and Claude Code sessions running on the desktop host.

  • unknown
    shared team access

    Teams Beta documents invites, shared documents, spreadsheets, mockups, diagrams, trackers, live editing, presence, structured feedback, and agent access to shared context, but not teammates sharing or steering the same live coding-agent session.

First-party sources
  • Nimbalyst 0.73.2 Teams Beta release

    Organization invites, collaborative documents and trackers, presence, comments, web-console editing, agent-visible shared context, and the unresolved same-session steering boundary.

  • Nimbalyst 0.74.3 collaboration release

    Shared visual artifacts across browser and desktop, presence, structured teammate feedback, collaboration recovery, and the unresolved same-session steering boundary.

  • Nimbalyst official repository

    Visual editors, agent sessions, worktrees, mobile app, supported agents, collaboration client mechanisms, telemetry, and MIT licensing.

  • Nimbalyst quickstart

    Project persistence, Claude Code and Codex setup, visual editors, diff review, parallel windows, and mobile controls.

  • Nimbalyst session manager

    Parallel Claude Code and Codex sessions, status tracking, grouping, and workstream management.

  • Nimbalyst Git tools

    Worktree isolation, per-session file tracking, visual diffs, review, staging, and assisted commits.

  • Nimbalyst mobile agent management

    iOS session monitoring, diff review, prompts, approvals, notifications, and desktop-host execution boundary.

Code audit

Inspected commit d80ecefe0e11.

  • The Electron bridge exposes session, provider, worktree, diff, and terminal operations.
  • CLI discovery covers Codex, Claude Code, and additional providers.
  • Mobile synchronization carries session and worktree state.
  • Team invitations, project sharing, and collaborative-document awareness exist in the client and protocol code.
Inspected paths
  • packages/electron/src/main/services/WorktreeStore.ts
  • packages/electron/src/main/services/CLIManager.ts
  • packages/electron/src/preload/index.ts
  • packages/runtime/src/sync/CollabV3Sync.ts
  • packages/collab-protocol/src/teamRoom.ts
  • docs/COLLABORATION_GUIDE.md
  • LICENSING.md

The repository is MIT licensed, but its collaboration server is a separate project. Client mechanisms do not establish that teammates can share or steer one live coding-agent session.

OpenChamber

Code inspected

An OpenCode-native workspace across desktop, web, editor, and mobile with multi-run worktrees, diff review, previews, GitHub flows, and remote access.

Harness-native GUIOpen sourcemacOS · Windows · Linux · Browser · iOS
Product details and evidence
Best for
OpenCode users who want a cross-device workspace for parallel experiments, visual review, Git operations, scheduling, and private remote access.
Check first
It remains an OpenCode-only control surface, and current sources describe cross-device access for a user but not multiple teammates sharing one live workspace.
Harness coverage
OpenCodeOpenChamber uses the OpenCode SDK and bundles the matching OpenCode CLI in its desktop app. The 1.19.0 Integrations page manages Claude Code, Command Code, and Cursor plugins; it does not establish that OpenChamber launches those coding harnesses.
Capability claims
  • documented
    parallel sessions

    Multi-run gives one task to as many as five model sessions and can compare or fuse their results.

  • documented
    workspace isolation

    Multi-run sessions can receive separate Git worktrees, and worktree management is exposed throughout the workspace.

  • documented
    visual review

    The product site documents visual diff review, and the workspace adds guided change walkthroughs, Git actions, previews, and pull-request flows.

  • documented
    remote execution or access

    Browser, PWA, mobile, private relay, direct, tunnel, LAN or VPN, and SSH paths can revisit and steer work running elsewhere.

  • unknown
    shared team access

    Cross-device access does not by itself establish multiple teammates sharing and steering the same live workspace.

First-party sources
  • OpenChamber product site

    Desktop, browser, mobile, and editor surfaces; diff review; protected remote access; tunnels; and supported platforms.

  • OpenChamber pinned product record

    OpenCode boundary, multi-run sessions, optional per-run worktrees, change walkthroughs, remote mechanisms, distribution, and license.

  • OpenChamber 1.19.0 release

    Project knowledge, file uploads, OpenCode configuration preservation, worktree and session recovery, and the boundary between plugin management and harness support.

Code audit

Inspected commit 4de802a0a1a5.

  • The pinned workspace integrates OpenCode through its SDK and bundled desktop CLI.
  • Multi-run, new-worktree, and mobile change-review surfaces are implemented in the shared UI.
  • The web server implements tunnel-backed remote access in addition to documented direct and private-network paths.
Inspected paths
  • README.md
  • packages/ui/src/apps/MobileChangesSurface.tsx
  • packages/ui/src/components/session/NewWorktreeDialog.tsx
  • packages/web/server/lib/tunnels/index.js
  • packages/electron/resources/icons/app-icon.svg

The audit establishes OpenCode-specific workspace mechanisms, not support for other harnesses or reliable multi-user collaboration.

OpenHands Agent Canvas

Code inspected

A visual OpenHands workspace for parallel agents, per-conversation worktrees, diffs, local or remote backends, automations, and ACP harnesses.

Multi-harness workspaceOpen sourcemacOS · Windows · Linux · Browser
Product details and evidence
Best for
Teams or individuals who want one open interface across OpenHands and three external harnesses, with self-hosted or managed execution backends.
Check first
The pinned testing matrix does not yet cover real external-harness credentials, subscription-login paths, macOS, or Windows in CI, so integration presence is not reliability evidence.
Harness coverage
Claude Code, Codex + 2 moreFour providers are documented directly, and a custom stdio ACP server can be configured. The external harness keeps its own model, tools, execution, and credentials; ACP compatibility is not arbitrary-CLI support.
Capability claims
  • documented
    parallel sessions

    Agent Canvas runs multiple agents simultaneously and keeps their conversations visible in one interface.

  • documented
    workspace isolation

    The product page documents a separate Git worktree for each parallel agent.

  • documented
    visual review

    The current client implements a dedicated Changes route that loads and renders repository diffs for the active conversation.

  • documented
    remote execution or access

    The same frontend switches among local agent servers, self-hosted remote VMs, and OpenHands Cloud backends.

  • documented
    shared team access

    Official sources describe team-shared Agent Server access and team sharing through the managed cloud backend.

First-party sources
Code audit

Inspected commit 1708efc44608.

  • The current Agent Canvas repository documents OpenHands, Claude Code, Codex, Gemini CLI, and custom stdio ACP configuration.
  • The client implements a dedicated repository-changes route backed by a unified Git-diff query.
  • The testing matrix records current credential, subscription-login, and platform coverage gaps for ACP providers.
Inspected paths
  • README.md
  • docs/ACP_AGENTS.md
  • docs/TESTING_MATRIX.md
  • src/routes/changes-tab.tsx
  • src/hooks/query/use-unified-git-diff.ts

The audit establishes integration and review mechanisms at the pinned commit; its own test matrix prevents treating presence as cross-provider reliability evidence.

QM

Code inspected

A self-hosted web and Slack control plane for scoped, durable agent work across four named harnesses.

Multi-harness workspaceOpen sourceBrowser
Product details and evidence
Best for
Startups that need personal and shared agent scopes, background work, policy controls, and isolated cloud workspaces in one deployment.
Check first
QM is early experimental software, requires an operator-owned cloud deployment, documents material security gaps, and does not currently establish an integrated visual code-review surface or arbitrary-CLI support.
Harness coverage
Claude Code, Codex + 2 moreFour named harness adapters drive the same core. Their own access, model routes, capabilities, and security posture remain independent from QM.
Capability claims
  • documented
    parallel sessions

    The official web-UI example shows concurrent sessions, while the core persists and supervises independent session runs.

  • documented
    workspace isolation

    Each person or room receives a scoped durable sandbox, files, memory, keychain view, permissions, and background jobs.

  • unknown
    visual review

    The current first-party record does not establish an integrated diff, code-review, or merge surface.

  • documented
    remote execution or access

    Web and Slack clients steer work in an operator-owned cloud deployment, with durable sandboxes, queues, crons, watches, and background workers.

  • documented
    shared team access

    Personal scopes coexist with shared Slack channels, group messages, projects, shared skills, and organization policy.

First-party sources
  • QM product and architecture overview

    Web and Slack surfaces, scoped workspaces, durable state, background work, collaboration, deployment model, and security postures.

  • QM harness adapters

    Runtime selection across the four named Pi, OpenCode, Codex, and Claude Code adapters without an arbitrary-CLI claim.

  • QM security policy

    Scope isolation goals, sandbox and credential boundaries, approvals, screening, auditing, and explicit known limitations.

  • QM deployment guide

    Operator-owned cloud deployment, web and Slack plugins, persistence, sandbox infrastructure, and live verification.

Code audit

Inspected commit 7f2c916360f1.

  • The core supervises durable session runs and routes them to four named harness adapters.
  • Scope-specific state, policy, persistence, sandbox routing, background workers, and web or Slack surfaces are implemented in the pinned tree.
  • The public code establishes workflow mechanisms but not arbitrary-CLI support, visual-review completeness, security guarantees, or task-success rates.
Inspected paths
  • README.md
  • SECURITY.md
  • deployment.md
  • src/core/orchestrator.ts
  • src/harness/harness-router.ts
  • src/runs/worker.ts
  • src/sandbox/sandbox-routing.ts
  • plugins/web-ui/README.md

QM calls itself early experimental software and documents material gaps in command policy, browser approval coverage, screening, egress enforcement, governance, and data retention. The audit confirms implementation presence rather than operational safety or reliability.

Qwen Code Desktop

Code inspected

The first-party Qwen Code desktop shell with multi-session and split views, optional worktrees, visual Git diffs, and a bundled local runtime.

Harness-native GUIOpen sourcemacOS · Windows · Linux
Product details and evidence
Best for
Qwen Code users who want the first-party visual workflow on macOS, Windows, or Linux without installing the CLI separately.
Check first
The current thin shell is intentionally local, single-window, and single-workspace at a time; remote backends and shared teammate access are not desktop capabilities.
Harness coverage
Qwen CodeThe desktop package embeds the Qwen Code CLI runtime and reuses its Web Shell. Provider breadth inside Qwen Code is model routing, not support for another coding harness.
Capability claims
  • documented
    parallel sessions

    The shared Web Shell can select multiple sessions and display them concurrently in an in-window split view.

  • documented
    workspace isolation

    The new-session Git-mode control can create a named Git worktree and root the session in that checkout.

  • documented
    visual review

    The Web Shell includes a dedicated Git diff dialog with file lists, expandable hunks, additions, deletions, and binary states.

  • contradicted
    remote execution or access

    The current Desktop design starts an authenticated daemon on a random loopback port and intentionally keeps external URLs outside the app.

  • unknown
    shared team access

    Current first-party Desktop sources do not establish multiple teammates entering the same live workspace.

First-party sources
Code audit

Inspected commit e1e5b42ce110.

  • The desktop shell embeds the Qwen Code daemon and reuses the first-party Web Shell.
  • The Web Shell implements multi-session split view, selectable Git-worktree mode, and a structured Git-diff dialog.
  • The desktop design constrains the daemon to loopback and the UI to one window and workspace at a time.
Inspected paths
  • README.md
  • packages/desktop-shell/README.md
  • docs/design/2026-07-31-desktop-web-shell-release.md
  • packages/web-shell/client/components/SplitView.tsx
  • packages/web-shell/client/components/GitModePopover.tsx
  • packages/web-shell/client/components/dialogs/GitDiffDialog.tsx

The audit establishes the current local desktop architecture and UI mechanisms, not task quality, security, or reliable cross-platform behavior.

Superset

Code inspected

A local desktop code editor for many CLI agents running in isolated Git worktrees.

Multi-harness workspaceSource availablemacOS
Product details and evidence
Best for
Mac power users and teams who want high concurrency, arbitrary CLI compatibility, local or cloud workspaces, terminals, diffs, and editor handoff.
Check first
Windows and Linux desktop builds are explicitly untested. Local remote access requires an opted-in host and relay; the separate cloud-workspace path is backed by third-party Blaxel sandboxes.
Harness coverage
Any CLI, with documented presetsFourteen presets are documented, and any other terminal CLI can be configured. Custom agents may have less integrated behavior than built-in presets.
Capability claims
  • documented
    parallel sessions

    The product documents ten or more simultaneous local coding agents.

  • documented
    workspace isolation

    Every task is placed in an isolated Git worktree.

  • documented
    visual review

    A built-in diff viewer, editor, terminal, external-editor handoff, and pull-request split view are implemented.

  • documented
    remote execution or access

    Remote hosts expose full workspaces, terminals, ports, agent runs, and diffs through Superset Relay; version 1.24.0 also exposes cloud-workspace creation, terminals, and agent actions from mobile.

  • documented
    shared team access

    Host owners can grant organization teammates access to the same remote workspaces.

First-party sources
  • Superset agent integration

    Fourteen built-in agent presets, arbitrary terminal agents, launch behavior, parallel tasks, and provider configuration.

  • Superset remote workspaces

    Remote hosts, relay access, organization membership, shared workspaces, terminals, agent runs, ports, and diffs.

  • Superset official repository

    Parallel execution, worktrees, monitoring, review, agent catalog, platform scope, and ELv2 license.

  • Superset Desktop 1.23.0 release

    Blaxel-backed cloud workspaces, relay controls, trigger-based automations, raw-CDP browser control, and idempotent session auto-resume.

  • Superset Desktop 1.24.0 release

    Mobile creation and operation of cloud workspaces, workspace terminals and agent actions, browser-control skills, account profiles, and large-diff reliability fixes.

  • Superset Desktop 1.24.1 release

    Pull-request split-view review with merge, close, and reopen controls.

Code audit

Inspected commit 961322195d80.

  • Workspace creation is backed by Git worktrees.
  • The desktop renderer contains a file-level diff review surface.
  • Fourteen terminal-agent presets are documented, while custom agents can supply their own commands.
  • Remote-host relay and teammate membership flows expose terminals, ports, agent runs, and diffs to authorized organization members.
Inspected paths
  • apps/desktop/src/lib/trpc/routers/workspaces/procedures/create.ts
  • apps/desktop/src/lib/trpc/routers/workspaces/utils/git.ts
  • apps/desktop/src/renderer/screens/main/components/WorkspaceView/ChangesContent/components/FileDiffSection/FileDiffSection.tsx
  • packages/shared/src/agent-catalog.ts
  • packages/shared/src/builtin-terminal-agents.ts
  • apps/docs/content/docs/remote-workspaces.mdx

The repository is source-available under Elastic License 2.0, not OSI open source; Windows and Linux desktop builds remain explicitly untested.

T3 Code

Code inspected

A minimal web and desktop GUI that presents five coding harnesses through one session model.

Multi-harness workspaceOpen sourcemacOS · Windows · Linux · Browser · iOS
Product details and evidence
Best for
People who want a lightweight multi-harness interface with worktrees, diffs, checkpoints, and remote access.
Check first
The project calls itself early-stage, and current first-party evidence does not establish live multi-user collaboration.
Harness coverage
Claude Code, Codex + 3 moreFive built-in drivers. You bring the existing subscriptions and credentials for each provider; T3 Code does not resell keys or tokens.
Capability claims
  • documented
    parallel sessions

    The orchestration contracts model multiple threads and independent provider runtimes.

  • documented
    workspace isolation

    The server creates and removes Git worktrees for threads.

  • documented
    visual review

    Checkpoint diffs and Git review operations are part of the GUI workflow.

  • documented
    remote execution or access

    Official user documentation covers remote access, relay connections, and mobile clients.

  • unknown
    shared team access

    The current official record does not establish shared live teammate access to one thread.

First-party sources
Code audit

Inspected commit 887dd6e455bb.

  • The server registers five built-in provider drivers: Codex, Claude Code, Cursor Agent, Grok, and OpenCode.
  • Git worktree creation, removal, checkpoint diffs, and remote access are implemented.
  • The GUI supervises external coding harnesses rather than replacing their agent loops.
Inspected paths
  • apps/server/src/provider/builtInDrivers.ts
  • apps/server/src/provider/Drivers/GrokDriver.ts
  • apps/server/src/provider/Drivers/OpenCodeDriver.ts
  • apps/server/src/vcs/GitVcsDriverCore.ts
  • apps/server/src/checkpointing/CheckpointDiffQuery.ts
  • docs/user/remote-access.md

The project describes itself as early-stage; inspected mechanisms do not establish product stability or parity across every client.

Traycer

Code inspected

An open-source desktop control plane for multi-provider agent tasks with shared context, worktrees, diffs, remote hosts, and team access.

Multi-harness workspaceOpen sourcemacOS · Windows · Linux
Product details and evidence
Best for
Teams that need shared agent tasks, agent-to-agent delegation, isolated worktrees, visual review, and access to a reachable execution host.
Check first
Most named integrations are chat-only, and agent-to-agent delivery varies by interface. Live terminals, files, diffs, and agent processes remain on the original Host; cross-device Hosts are marked coming soon.
Harness coverage
Claude Code, Codex + 14 moreSixteen named coding-agent paths are listed in the chat interface. Only Claude Code, Codex, and OpenCode are also listed for the terminal interface, with different agent-to-agent message support.
Capability claims
  • documented
    parallel sessions

    A Task can contain parent and child agents with independent sessions and run state, including parallel fire-and-forget instructions.

  • documented
    workspace isolation

    Agents can use separate Git worktrees, each with its own checkout, directory, branch, and diff scope.

  • documented
    visual review

    The Git Diff panel shows changed files for the selected worktree with search, summaries, grouping, and explicit loading or error states.

  • documented
    remote execution or access

    The desktop client can connect to a reachable Host that owns the workspace, terminal, files, diffs, and agent processes.

  • documented
    shared team access

    Task-level sharing gives invited collaborators access to the same task, agents, artifacts, files, diffs, and comments according to their access.

First-party sources
  • Traycer coding-agent support

    Sixteen named chat integrations, the smaller terminal-integration set, interface differences, and authentication notes.

  • Traycer agent-to-agent communication

    Child-agent creation, instructions, replies, transcripts, independent session state, and interface-specific delivery limits.

  • Traycer worktrees

    Separate checkouts, isolated directories and branches, per-agent worktree selection, and worktree-scoped diffs.

  • Traycer Git Diff panel

    Changed-file review, search, summaries, grouping, and worktree selection.

  • Traycer Hosts

    Host ownership of live execution surfaces, reachable-machine connections, cloud-synced task data, and cross-device limitations.

  • Traycer task sharing

    Task-level access, shared agents and artifacts, files, diffs, and comments.

  • Traycer repository snapshot

    Pinned client implementation snapshot for worktrees, diffs, remote host transport, sharing, agent-to-agent surfaces, and MIT licensing.

Code audit

Inspected commit 8f21d506f994.

  • The desktop client binds worktree creation and worktree-scoped Git diff review into the task interface.
  • A remote transport connects the client to a reachable execution Host.
  • Collaborator mutations and the sharing panel implement task access and role management.
  • The chat store exposes agent-to-agent session state and messaging surfaces.
Inspected paths
  • clients/gui-app/src/hooks/worktree/use-worktree-create-mutation.ts
  • clients/gui-app/src/components/epic-canvas/git-diff/git-diff-panel-body-live.tsx
  • clients/shared/host-transport/remote/create-remote-transport.ts
  • clients/gui-app/src/hooks/epic/use-epic-collaborator-mutations.ts
  • clients/gui-app/src/components/epic-canvas/panels/epic-sharing/panel.tsx
  • clients/gui-app/src/stores/chats/a2a-open-store.tsx

The public repository exposes client and protocol code, but not every hosted collaboration or cloud service. The audit does not establish service guarantees, privacy properties, or feature parity across every named integration.

webmux

Code inspected

A self-hosted browser dashboard that owns worktrees, tmux layouts, agent events, services, and optional containers.

Multi-harness workspaceOpen sourceBrowser · macOS · Linux
Product details and evidence
Best for
Developers who want a hackable web control plane on their own machine or server, including mobile check-ins.
Check first
Deployment and secure network exposure are the user's responsibility, and full in-app chat features are limited for custom agents.
Harness coverage
Any CLI, with documented presetsCodex and Claude Code receive full in-app chat, history, interrupt, and resume controls. Custom CLIs are terminal-first and can optionally define a resume command.
Capability claims
  • documented
    parallel sessions

    One dashboard manages parallel worktree and tmux agent sessions.

  • documented
    workspace isolation

    The service creates Git worktrees and can add Docker sandbox isolation.

  • documented
    visual review

    The dashboard surfaces PRs, CI checks, comments, services, and session state.

  • documented
    remote execution or access

    A browser and mobile-oriented chat UI reconnect to persistent host sessions.

  • unknown
    shared team access

    The current official record does not establish multi-user access controls or shared steering.

First-party sources
  • webmux inspected source snapshot

    Pinned implementation boundary for worktrees, terminals, browser and mobile UI, review state, containers, agents, and MIT licensing.

  • webmux worktree service

    Worktree and tmux lifecycle, rollback handling, workspace services, and optional container setup.

  • webmux agent registry

    First-class Codex and Claude adapters plus command-configurable custom agent definitions.

  • webmux agent UI service

    Chat-capability checks, persistent session state, interrupt and resume integration, and terminal-first custom-agent boundary.

Code audit

Inspected commit 99cb139eac4b.

  • The backend owns worktree and tmux session lifecycle with rollback behavior.
  • Codex and Claude have first-class chat, interrupt, history, and resume capabilities.
  • Custom agents are command-configurable but terminal-first, without the same built-in chat, history, and interrupt integration.
  • The browser and mobile-oriented views derive their state from managed worktree sessions.
Inspected paths
  • backend/src/services/worktree-service.ts
  • backend/src/services/agent-registry.ts
  • backend/src/services/agents-ui-service.ts
  • backend/src/adapters/agent-runtime.ts

The audit does not establish secure internet exposure; the documented deployment remains a service on infrastructure the user controls.

Inactive products excluded from matches

1Code. The official repository was archived and made read-only on July 7, 2026, and the product site now resolves to that repository, so it is excluded from active workflow matches. Open source record

Vibe Kanban. The company announced its shutdown and the repository release feed records the sunset, so it is excluded from active workflow matches. Open source record