Superset

superset · superset-sh/superset · ★ 11k · last commit 2026-05-26

Primitive shape 13 total

Commands 11 Subagents 1 MCP tools 1

Summary

Superset — Summary

Superset is "The Code Editor for AI Agents" — a macOS desktop application (Electron + Bun) that lets users run 10–100+ CLI coding agents simultaneously, each isolated in its own git worktree, monitored from a single dashboard with built-in diff viewer and one-click IDE handoff. It is agent-agnostic (any CLI agent: Claude Code, Codex, Gemini CLI, Amp, Cursor, Copilot, OpenCode, Pi) and does not proxy API calls — users bring their own keys. The platform pairs a desktop app with a SaaS backend (PostgreSQL + ElectricSQL sync, Relay WebSocket cluster) for task management, automation scheduling, and multi-user workspaces. The core value proposition is eliminating context-switching overhead when managing many parallel agent runs. An ELv2-licensed GitHub repo (11.3k stars) with a hosted freemium offering; the desktop app is the primary consumer surface.

Differs from seeds: Superset is most similar in spirit to claude-flow (both run parallel agents) but is a native desktop app rather than an npm plugin, and it externalizes orchestration coordination from the agent's context window into a standalone GUI + backend. Unlike superpowers (skill-injection Claude plugin), Superset is a process manager — it doesn't inject behavior into agents but rather creates worktrees and terminal sessions for them to run in. The MCP server exposes Superset's task/workspace management to agents so they can self-schedule work; this is the inverse of superpowers' "agent controls the flow" model — here the platform controls the flow and agents interact with it via MCP.

Overview

Superset — Overview

Origin

GitHub: superset-sh/superset. 11,262 stars. ELv2 license (Elastic License 2.0 — source available, not OSI open source; production SaaS use restricted). TypeScript primary language. Active (last commit 2026-05-26). 30 contributors.

Website: superset.sh. Download available for macOS.

Philosophy

"The Code Editor for AI Agents. Orchestrate 100+ coding agents in parallel. Works for any agents. Built for the AI era."

"Run multiple agents simultaneously without context switching overhead"

"Each agent runs in its own isolated Git worktree, which means they can work on different branches or features simultaneously without conflicts."

"Superset doesn't proxy any API calls. You use your own API keys directly with whatever AI providers you choose."

Core values:

Agent-agnostic: if it runs in a terminal, it runs in Superset
BYOK: No API key proxying, full user cost control
Isolation-first: worktree per task, no merge conflicts
Minimal switching: Monitor all agents from one place

Positioning

Primary target: Individual developers and small teams who want to run many AI coding agents simultaneously without the cognitive overhead of switching between terminals. The "10x faster with no switching cost" framing positions it against the tedium of managing multiple terminal windows.

Comparison self-positioning (from homepage FAQ):

"Designed to work with your existing tool" — not a replacement for Cursor/Windsurf/VSCode
"Natively supports deep-linking to IDEs like Cursor"
"Each agent runs in its own isolated Git worktree"
"Superset has a free tier. The source code is available on GitHub under Elastic License 2.0 (ELv2)"

Architecture

Superset — Architecture

Client-Server Architecture

Desktop App (Electron + Bun, macOS)
    ↕ (local API + WebSocket)
Local Backend Services
    ↕ (Electric SQL sync, WebSocket relay)
SaaS Backend (hosted at superset.sh)
    ├── PostgreSQL + ElectricSQL (state sync)
    ├── Relay cluster (WebSocket for terminal streaming)
    └── Admin / auth services

Application Monorepo (`apps/`)

App	Tech	Role
`desktop/`	Electron + electron-vite + Bun	Primary user interface (macOS)
`web/`	(inferred: Next.js or similar)	Web interface
`api/`	Bun server	Backend API
`relay/`	Go or Node	WebSocket relay for terminal I/O
`electric-proxy/`	ElectricSQL proxy	Real-time state sync
`mobile/`	unknown	Mobile client
`admin/`	unknown	Admin console
`marketing/`	unknown	Marketing site
`streams/`	unknown	Stream processing
`docs/`	unknown	Documentation

Agent Workspace (`.agents/`)

The .agents/ directory acts as the runtime configuration for agents working on Superset itself. Contains:

commands/ — slash commands for agents working in this repo
config.json — agent configuration
setup.sh / teardown.sh — workspace lifecycle scripts
setup.local.sh / teardown.local.sh — local override scripts

Claude Code Plugin

.claude-plugin/marketplace.json — points to an internal plugins directory (./plugins/superset). The plugin exposes Superset's task/workspace management to Claude Code via MCP tools.

Build/Runtime

Bun v1.0+ (JavaScript runtime, faster than Node)
Caddy (reverse proxy for ElectricSQL streams in dev)
Git 2.20+ (worktree management)
gh CLI (GitHub PR creation)
macOS primary (Windows/Linux untested per README)

Key Config

.env.example / .env.local.example — environment configuration
biome.jsonc — Biome linter config
cli.json — CLI configuration
docker-compose.yml — Docker infra for local development
Caddy config for dev TLS

Install

Pre-built: Download macOS app from GitHub Releases.
Build from source: git clone, bun install, bun run dev, bun run build.

Components

Superset — Components

Desktop App Features (from homepage)

Feature	Description
Parallel Execution	Run 10–100+ coding agents simultaneously
Worktree Isolation	Each task gets its own git branch and working directory
Agent Monitoring	Track agent status, get notified when changes ready
Built-in Diff Viewer	Inspect and edit agent changes without leaving the app
Workspace Presets	Automate env setup, dependency installation, and more
Universal Compatibility	Any CLI agent that runs in a terminal
Quick Context Switching	`⌘1–9` to switch workspace
IDE Integration	One-click open in Cursor, VSCode, etc.
Kanban Board	Task management with real-time SSE updates
Automations	Scheduled agent runs
Ports Forwarding	Expose agent-spawned servers
PR Review	Integrated PR creation and review

Claude Code Plugin (`superset` plugin)

Description: "Use Superset to spawn agents, create workspaces, manage tasks, and schedule automations from Claude Code."

Commands (11 found in `.agents/commands/`)

Command	Purpose
`task.md`	Create a task in Superset and assign to me via `mcp__superset__create_task`
`create-plan.md`	Create a development plan
`create-pr.md`	Create a pull request
`task-run.md`	Run a task
`draft.md`	Draft content
`deslop.md`	Remove low-quality/sloppy content
`ci-check.md`	Run CI checks
`clean-neon-branches.md`	Clean up Neon database branches
`refresh-compare-pages.md`	Refresh comparison pages
`respond-to-pr-comments.md`	Respond to PR review comments
`pr/` (subdirectory)	PR-related commands
`ticket-format/` (subdirectory)	Ticket formatting commands

Agents (1 found in `.claude/agents/`)

project-structure-validator.md — validates project directory structure

MCP Server

The Superset Claude Code plugin exposes MCP tools including at minimum:

mcp__superset__create_task — Create a task in Superset and assign it
mcp__superset__list_members — List workspace members (for assignee resolution)
mcp__superset__ (other tools for workspace management, automations)

Supported Agents

Claude Code, Amp Code, OpenAI Codex CLI, Cursor Agent, Gemini CLI, GitHub Copilot, OpenCode, Pi, and any CLI agent.

Prompts

Superset — Prompts

Verbatim Excerpt 1: `task.md` Command

---
description: Create a task and assign it to me via Superset MCP
allowed-tools: mcp__superset__create_task, mcp__superset__list_members, Bash(git config user.email)
---

Create a new task in Superset and assign it to me.

## Input

Parse `$ARGUMENTS` for:
- **Description** (required): The task title/description — this is the main text
- **Priority** (optional): One of `urgent`, `high`, `medium`, `low`, `none`. Defaults to `none` if not specified.

## Steps

1. Parse the arguments to extract the task description and optional priority
2. Generate a clear, concise task title from the description (imperative form, under 80 chars)
3. If the user provided more detail beyond a short title, include it as a markdown description on the task
4. Resolve the current user's member ID by calling `mcp__superset__list_members` and matching against the git user (run `git config user.email` to get the current user's email)
5. Create the task using `mcp__superset__create_task` with:
   - `title`: The generated title
   - `description`: Expanded detail if provided, otherwise omit
   - `priority`: Parsed priority or `none`
   - `assigneeId`: The resolved member ID from step 4

## Output

Confirm the task was created with its title, priority, and slug.

$ARGUMENTS

Prompting technique: Structured procedural multi-step command with explicit tool allowlist and input schema. The $ARGUMENTS variable substitution pattern (standard Claude Code slash command). Notable: the command uses MCP tools to interact with Superset's backend — the agent is a first-class platform citizen that can create tasks, not just execute them.

Verbatim Excerpt 2: `.claude-plugin/marketplace.json`

{
  "name": "superset",
  "owner": {
    "name": "Superset",
    "url": "https://superset.sh"
  },
  "plugins": [
    {
      "name": "superset",
      "source": "./plugins/superset",
      "description": "Use Superset to spawn agents, create workspaces, manage tasks, and schedule automations from Claude Code."
    }
  ]
}

Technique: Plugin manifest with capability description as a one-line purpose statement. The description field is the semantic anchor for when an agent should activate this plugin — classic "useWhen" equivalent in manifest form.

Uniqueness

Superset — Uniqueness and Positioning

Differs from Seeds

Superset is unique among all seeds in being a native desktop application rather than a CLI tool, npm package, or Claude Code plugin. The seed superpowers (same name coincidence, different project) is a skills-only behavioral framework. Superset as analyzed here is superset-sh/superset — the Code Editor for AI Agents.

The orchestration approach differs from claude-flow (which uses a hive-mind LLM inside the agent's context window) by externalizing all coordination to a process manager + kanban dashboard. Agents in Superset are "dumb workers" — they receive a task and work in their worktree; they don't know about each other unless they use Superset MCP tools.

Versus bernstein (deterministic Python scheduler): Bernstein auto-assigns tasks, runs agents, verifies output, and merges automatically. Superset is explicitly human-in-the-loop — the operator manages task creation and merge decisions. Superset trades automation for control.

Distinctive Features

macOS desktop app — the only desktop-native framework in this batch; no seed is desktop-first
100+ concurrent agents claim — largest stated concurrency limit
ElectricSQL real-time sync — modern reactive sync approach not seen in any seed
deslop.md command — unique heuristic for removing low-quality content ("sloppy code")
Workspace Presets — automate env setup per workspace type
Port forwarding — expose agent-spawned dev servers directly from the dashboard

Positioning

Superset targets individual developers and small teams who want to use multiple AI coding agents simultaneously as a force multiplier, without the complexity of full orchestration platforms like Bernstein or AgentsMesh. The "no switching cost" narrative positions it against the cognitive overhead of terminal multitasking.

Observable Failure Modes

macOS-only: explicitly untested on Windows/Linux — limits enterprise adoption
ELv2 license: source-available but production SaaS use restricted; different from Apache/MIT adoption dynamics
SaaS dependency: requires connection to superset.sh backend for full features
No automated verification: merge quality is entirely human-dependent; no janitor/gating equivalent
Agent isolation is context-isolation, not security isolation: worktrees prevent file conflicts but don't sandbox network/filesystem access

Workflow

Superset — Workflow

Standard Workflow

New Workspace — Operator creates a workspace in the Superset desktop app (or via mcp__superset__create_task). Each workspace = one git worktree + one agent session.
Agent Runs — Operator selects an agent type (Claude Code, Codex, etc.) and enters a task description. Agent starts in its isolated worktree.
Monitor — Superset Kanban shows: In Progress, Ready for Review. Real-time SSE updates. Operator switches workspaces with ⌘1–9.
Review — When agent finishes, review changes in the built-in diff viewer. Approve or reject.
Merge — Create PR, open in IDE, or merge directly.

Approval Gates

Gate	Type
Human review of agent diff	`file-review` — human inspects diff in built-in viewer
No automated merge	Merge is always human-triggered

Automation / Scheduling

Superset supports scheduled automations — agents can be triggered on a schedule rather than just manually. Details not fully public.

State Artifacts

PostgreSQL (backend state) + ElectricSQL (real-time sync to desktop)
Git worktrees (per workspace)
PR on GitHub (via gh CLI)

Spec Format

None — task descriptions are plain text entered by the operator.

Git Automation

Creates worktree per workspace (automated by Superset)
create-pr.md command: creates a GitHub PR
No automatic merge — human always approves

Memory Context

Superset — Memory and Context

Platform-Level State

PostgreSQL (hosted SaaS backend): tasks, workspaces, team members, automations, PR state
ElectricSQL: real-time sync from PostgreSQL to desktop app (local read replica)
Git worktrees: each workspace has its own branch and working directory

Agent-Level Context

Each agent session is completely isolated — each workspace is a separate terminal session with its own environment. There is no shared context between agents by default. Agents can interact with each other only via the Superset MCP tools (e.g., creating tasks that another agent picks up).

Cross-Session Persistence

Full persistence: tasks and workspace state persist in PostgreSQL across sessions. The desktop app syncs state via ElectricSQL on startup.

Compaction Handling

Not applicable — Superset is an external process manager. Context compaction is handled by each underlying agent tool independently within its terminal session.

Memory Type

File-based (git worktrees) + SaaS database (PostgreSQL). No in-process memory or local SQLite — state sync is via ElectricSQL protocol.

Orchestration

Superset — Orchestration

Pattern

Parallel fan-out with human-in-the-loop review gate. Superset creates N isolated agent workspaces in parallel; agents work independently. There is no inter-agent coordination by default — agents are managed from a human-facing kanban dashboard. The MCP server allows agents to create tasks (which may start other agents), enabling limited automated chaining.

Operator (Superset Dashboard)
├── Workspace-1 → Claude Code in worktree A → Ready for Review
├── Workspace-2 → Codex in worktree B → In Progress
├── Workspace-3 → Gemini CLI in worktree C → In Progress
└── Automations (scheduled agent runs)

Isolation Mechanism

Git worktrees — one per workspace. No agent-level containerization; each agent runs in the host's terminal environment within a worktree.

Multi-Model Routing

Yes — each workspace independently selects an agent type. No central model routing policy. The cli.json config and Superset In Progress kanban show mixed agent types in one workspace view (Claude Code, Codex, Cursor, OpenCode, Copilot, Amp, Gemini).

Consensus Mechanism

None — no automated consensus. Human review gate is the merge control.

Concurrent Agents

100+ claimed in marketing. Practical limit is local machine resources. The FAQ confirms: "Each agent runs in its own isolated Git worktree."

Execution Mode

Interactive (primary): operator creates workspaces manually. Scheduled/automated via Automations feature.

Cross-Tool Portability

High — any CLI agent (if it runs in a terminal, it runs in Superset).

Prompt Chaining

Limited — not a core feature. Agents can create tasks via MCP tools, but output-to-input automatic chaining is not documented.

Auto-Validators

None confirmed in the public codebase. Review is human-driven (diff viewer). The ci-check.md command exists, suggesting CI integration is available, but no automated pre-merge validation.

Audit Log

Not public. The web console shows activity per workspace (kanban state history). Enterprise/SaaS details not disclosed.

Ui Cli Surface

Superset — UI and CLI Surface

Primary Interface: Desktop App

Detail	Value
Platform	macOS (Windows/Linux: untested)
Tech	Electron + electron-vite + Bun
Download	GitHub Releases (pre-built for macOS)

Dashboard features (from homepage):

Kanban board (In Progress / Ready for Review columns)
Per-task/workspace terminal with live agent output
Built-in split/unified diff viewer
PR creation and review interface
Port forwarding panel
Agent type selector (Claude Code, Codex, Gemini, etc.)
Workspace switcher (⌘1–9)
Notification system

Keyboard Shortcuts

Fully customizable via Settings > Keyboard Shortcuts (⌘/).

⌘1–9: Switch to workspace 1–9
⌘⌥↑/↓: Previous/next workspace
⌘N: New workspace
⌘⇧N: Quick create workspace

Web Interface

apps/web/ — browser-based companion, useful for remote access. Shares same backend state via ElectricSQL sync.

Mobile Interface

apps/mobile/ — exists in the repo but not publicly documented.

Claude Code Plugin Surface

The Superset Claude Code plugin lets agents interact with Superset's task management from inside a Claude Code session:

Create tasks, list members, spawn workspaces
Via mcp__superset__* tools exposed by the plugin's MCP server

CLI

Not confirmed as a standalone binary. The cli.json in the root suggests some CLI capability, but the primary surface is the desktop app.

Observability

Real-time SSE updates to kanban board
Per-workspace agent terminal stream
Superset website: "real-time dashboard, per-agent cost tile, pipeline status" (mentioned in comparisons with great_cto)

Related frameworks

same archetype · same primary tool · same memory type

claude-mem (thedotmack) ★ 78k

A8 Cross-runtime harness

Background worker service captures every tool call as an observation, AI-compresses sessions, and auto-injects relevant past…

pi (badlogic/earendil) ★ 55k

A8 Cross-runtime harness

A minimal, hackable, multi-provider terminal coding agent that adapts to your workflows via npm-installable TypeScript Extensions…

Agent Skills (Addy Osmani) ★ 46k

A8 Cross-runtime harness

Encodes senior-engineer software development lifecycle as 23 auto-routed skills and 7 slash commands for any AI coding agent.

wshobson/agents Plugin Marketplace ★ 36k

A8 Cross-runtime harness

Single Markdown source for 83 domain-specialized plugins that auto-generates idiomatic artifacts for five AI coding harnesses.

TabbyML/Tabby ★ 34k

A8 Cross-runtime harness

Self-hosted AI coding assistant server (alternative to GitHub Copilot) with admin dashboard, RAG-based completions, and multi-IDE…

Compound Engineering ★ 17k

A8 Cross-runtime harness

Make each unit of engineering work compound into easier future work via brainstorm→plan→execute→review→learn cycles.

Distribution

Type: desktop-app
License: ELv2
Install: one-liner
Version: unknown (last commit 2026-05-26)

Surfaces

CLI subcmds: 0
Local UI: desktop-app
Tech stack: Electron + electron-vite + Bun; React (inferred); ElectricSQL real-time sync

Components

Commands: 11
Skills: 0
Subagents: 1
Hooks: 0
MCP servers: 1
Scripts: 4
Templates: 0

Workflow

Phases: 5
Approval gates: 1
Spec format: none
Spec storage: db
Delta or full: none

Orchestration

Multi-agent: Yes
Pattern: parallel-fan-out
Isolation: git-worktree
Consensus: none
Prompt chaining: No

Multi-model

Multi-model: Yes
BYOK: Yes
Modal: text

Execution

Mode: interactive-loop
Compaction: No
Session handoff: Yes
Streaming: Yes

Memory

Type: hybrid
Persistence: global
Search: none
State files: 3 files

Quality

TDD: No
TDD mechanism: none
Self-review: none

Git / Observability

Auto commit: No
Auto PR: Yes
Auto merge: No
Worktree/feat: Yes
Audit format: none

Tools

Primary: claude-code
Targets: 9
Portability: high

Signals

Stars: 11k
Last commit: 2026-05-26
Contributors: 30
Maintainer: active
Quality score: 3.5/10

Summary

Superset — Summary

Overview

Superset — Overview

Origin

Philosophy

Positioning

Architecture

Superset — Architecture

Client-Server Architecture

Application Monorepo (apps/)

Agent Workspace (.agents/)

Claude Code Plugin

Build/Runtime

Key Config

Install

Components

Superset — Components

Desktop App Features (from homepage)

Claude Code Plugin (superset plugin)

Commands (11 found in .agents/commands/)

Agents (1 found in .claude/agents/)

MCP Server

Supported Agents

Prompts

Superset — Prompts

Verbatim Excerpt 1: task.md Command

Verbatim Excerpt 2: .claude-plugin/marketplace.json

Uniqueness

Superset — Uniqueness and Positioning

Differs from Seeds

Distinctive Features

Positioning

Observable Failure Modes

Workflow

Superset — Workflow

Standard Workflow

Approval Gates

Automation / Scheduling

State Artifacts

Spec Format

Git Automation

Memory Context

Superset — Memory and Context

Platform-Level State

Agent-Level Context

Cross-Session Persistence

Compaction Handling

Memory Type

Orchestration

Superset — Orchestration

Pattern

Isolation Mechanism

Multi-Model Routing

Consensus Mechanism

Concurrent Agents

Execution Mode

Cross-Tool Portability

Prompt Chaining

Auto-Validators

Audit Log

Ui Cli Surface

Superset — UI and CLI Surface

Primary Interface: Desktop App

Keyboard Shortcuts

Web Interface

Mobile Interface

Claude Code Plugin Surface

CLI

Observability

Related frameworks

Application Monorepo (`apps/`)

Agent Workspace (`.agents/`)

Claude Code Plugin (`superset` plugin)

Commands (11 found in `.agents/commands/`)

Agents (1 found in `.claude/agents/`)

Verbatim Excerpt 1: `task.md` Command

Verbatim Excerpt 2: `.claude-plugin/marketplace.json`