superset

Superset is a desktop application built for developers who want to run multiple AI coding agents in parallel without the overhead of context switching or workspace collisions. Instead of waiting for one agent to finish before starting the next task, Superset lets you dispatch work to Claude Code, OpenAI Codex, Gemini CLI, Cursor Agent, GitHub Copilot, and other CLI-based agents simultaneously—each isolated in its own git worktree so their changes never interfere with one another.

At its core, Superset wraps each agent in a managed terminal session backed by a custom PTY daemon that handles session persistence, handoff between restarts, and output buffering. A local host service process coordinates workspace lifecycle—cloning worktrees, running setup and teardown scripts from .superset/config.json, and tracking which agent is doing what. The renderer is a React application that surfaces all running workspaces in a unified sidebar, a built-in diff viewer, and a notification system that pings you the moment an agent completes or needs attention.

The project ships as a native macOS Electron app with an embedded Bun runtime, a bundled CLI, and a relay service for remote connectivity. The entire monorepo is built with Turborepo, typed end-to-end with TypeScript, and uses tRPC for IPC between the Electron main process and renderer, keeping the API contract fully type-safe across layers.

Superset is source-available under the Elastic License 2.0, meaning the full codebase is readable and modifiable for personal and internal use, but you cannot offer it as a hosted service to third parties. The project is under active development with multiple releases per week and a public roadmap driven through GitHub Discussions and Discord.

What You Get

• Parallel agent execution — launch 10+ coding agents simultaneously with no resource contention between tasks
• Git worktree isolation — every workspace gets its own branch and working directory so agents never overwrite each other’s changes
• Built-in PTY daemon — a custom pseudoterminal daemon manages session persistence, I/O buffering, and graceful handoff across app restarts
• Unified monitoring panel — track every running agent’s status, output, and pending diffs from a single sidebar without tab-switching
• Configurable workspace scripts — define per-project setup and teardown commands in .superset/config.json (copy .env, install deps, seed DBs) that run automatically when a workspace is created or deleted
• Built-in diff viewer and editor — inspect and patch agent-generated changes without leaving Superset; open in an external editor with one click
• Universal agent compatibility — wraps any CLI agent that runs in a terminal; supported agents include Claude Code, Codex, Gemini CLI, Copilot, Cursor Agent, Amp Code, Droid, Mastra Code, OpenCode, and Pi
• Keyboard-shortcut-driven workflow — every navigation and workspace action has a configurable shortcut, with ⌘1–9 for instant workspace switching

Common Use Cases

• Running parallel feature branches — dispatch separate coding tasks to multiple Claude Code instances working on different features simultaneously while you review completed work
• AI-assisted code review pipeline — use one agent to write a feature, another to write tests, and a third to draft documentation—all in isolated worktrees that merge cleanly
• Multi-agent debugging — spin up agents against different versions of a bug reproduction to isolate regressions while monitoring their terminal output in real time
• Rapid prototyping at scale — assign distinct experiments to separate agent workspaces, compare their diffs side-by-side, and cherry-pick the best approach
• Automating repetitive migrations — run the same refactoring or migration prompt across multiple agents targeting different modules of a large codebase in parallel
• Onboarding new codebases — let agents explore, document, or add tests to an unfamiliar repo while you set workspace presets that automate the local environment setup

Under The Hood

Architecture Superset is a layered Electron application organized as a Turborepo monorepo with clear separation between the desktop shell, a local host service, a PTY daemon, a cloud API, and a shared package layer. The Electron main process acts as a coordinator: it boots a host service child process that manages workspace lifecycle and git worktree operations, connects to a PTY daemon over Unix sockets for terminal I/O, and exposes all functionality to the React renderer via a fully type-safe tRPC IPC router. The renderer is a React single-page application that communicates exclusively through this typed interface, with Zustand stores managing local UI state. This layered design means the core workspace-management logic lives in a Node-based host service that can be reasoned about independently of the Electron shell, and the PTY daemon is a separately compiled binary with its own versioned protocol, enabling hot-reload of agent sessions across app restarts.

Tech Stack The project is written entirely in TypeScript and runs on Bun as the package manager and runtime for build tooling and scripts, while Electron provides the desktop shell on macOS. The renderer uses React 19 with Vite for bundling, TailwindCSS for styling, and TanStack Query for server-state caching against the tRPC endpoints. Persistence splits across two layers: a cloud Postgres database accessed through Drizzle ORM and hosted on Neon for collaborative state, and a local SQLite database via better-sqlite3 for machine-local settings and workspace metadata. The PTY daemon is a custom pseudoterminal server using node-pty with a binary framing protocol over Unix domain sockets. The entire monorepo is linted and formatted by Biome, type-checked with TypeScript strict mode, and orchestrated for parallel builds by Turborepo. MCP (Model Context Protocol) integration is provided through dedicated packages, enabling agents to call tools exposed by the host application.

Code Quality The codebase shows a disciplined approach to quality with several indicators: the PTY daemon package has comprehensive integration tests written in Node’s built-in test runner that exercise control-plane handshakes, session lifecycle, multi-client subscribe/replay, detach/reattach, concurrent sessions, and malformed input rejection. Host service tests cover pull-request scaling scenarios and workspace cleanup. The renderer has component-level tests for UI logic. Biome enforces consistent formatting and linting across all packages, and TypeScript strict mode is active throughout. Inter-process communication uses tRPC, which eliminates an entire class of runtime type mismatches. The main process code shows explicit error handling with logging for subprocess lifecycle events, though some renderer stores rely on Zustand without formal validation of external data. Overall the testing is solid for infrastructure-critical paths (PTY, host service) but lighter on renderer-side UI components.

What Makes It Unique Superset’s most distinctive technical contribution is treating git worktrees as the primary unit of AI agent isolation rather than processes or containers. Instead of sandboxing agents at the OS level, it leverages git’s native worktree mechanism to give each agent a full, independent working copy of the repository on disk with its own branch—meaning diffs are already in a reviewable, mergeable state the moment an agent finishes, with no file-level merging required. The companion PTY daemon is purpose-built for this use case: it supports multiple simultaneous subscribers to a single terminal session, persists output buffers across client reconnections (so closing and reopening the app never loses agent output), and exposes a versioned binary protocol that decouples daemon upgrades from desktop app releases. The agent hook system injects shell wrappers for each supported agent that call back into Superset over a local socket when the agent produces output or pauses, enabling real-time notifications without polling—an approach that generalizes across incompatible agent CLIs through a single shim pattern.

Self-Hosting

Superset is distributed under the Elastic License 2.0 (ELv2), a source-available license. The full source code is publicly available on GitHub, and you are free to use, copy, and modify it for personal projects, internal tooling, and commercial development work. The key restriction is that you may not offer Superset itself—or a product that exposes its substantial functionality—as a hosted or managed service to third parties. In plain language: you can run it on your own machine, fork it, and build internal tools on top of it, but you cannot resell it as a SaaS product. There are no copyleft obligations; your own code does not need to be open-sourced.

Running Superset yourself requires macOS (Windows and Linux builds are not yet available), Bun v1.0 or later, Git 2.20+, the GitHub CLI (gh), and Caddy for the development server. The application bundles a CLI tool and a PTY daemon, so the operational surface for end users is simply downloading the macOS app from GitHub Releases—no server infrastructure is required for the desktop client itself. If you build from source, you will also need Docker to bring up the local Postgres and Electric stack that backs the development environment, plus jq and caddy. The team ships multiple releases per week, and updates are delivered through Electron’s auto-updater mechanism.

At this stage Superset does not offer a separate cloud or enterprise tier with SLAs, managed upgrades, or support contracts—it is a single-tier product you download and run locally. What you give up compared to a hypothetical managed offering is automated updates delivered silently in the background (currently requires downloading new releases manually or relying on the built-in auto-updater), enterprise SSO, centralized audit logs, or priority support channels. Community support is available through a public Discord server and GitHub Issues. Given the project’s rapid release cadence and active Discord community, the practical support experience is responsive for an open-source tool, but there is no contractual SLA.