Run 10 Coding Agents in Parallel: Superset IDE Setup (2026)

Most developers using Claude Code, Codex CLI, or Gemini CLI share a common frustration: you send one task to an agent, then you wait. The agent is working through your codebase and you're watching a cursor blink. You have ten other tasks in a backlog that could also be running right now, but your one agent is busy.

Superset is a macOS application built to solve exactly this. It runs multiple CLI coding agents simultaneously, each isolated in its own git worktree, while you monitor all of them from one interface. Here's how to set it up and how to extend it with a custom agent backed by ModelsLab's LLM API.

What Superset Actually Does

Superset isn't a coding agent itself — it's an orchestration layer for agents that run in a terminal. When you create a task in Superset, it:

• Creates a new git worktree (a separate branch and working directory from your main branch)
• Starts the agent of your choice in a terminal session inside that worktree
• Monitors the agent and notifies you when it pauses for input or finishes
• Shows a diff of every change the agent made, which you can review and edit without leaving the app
• Lets you open the worktree in your IDE with one click

The worktree isolation is the key detail. Each agent works on its own branch, so ten agents running simultaneously on the same codebase don't interfere with each other. When an agent finishes, you review its changes and merge what's good.

Superset currently supports Claude Code, OpenAI Codex CLI, Cursor Agent, Gemini CLI, GitHub Copilot, and OpenCode — and because it works with any CLI agent, you can add your own custom agent script.

Requirements and Setup

Superset runs on macOS. Windows and Linux are untested as of the initial release. Before installing, make sure you have:

• Bun v1.0+ (the JavaScript runtime Superset is built on)
• Git 2.20+ (for worktree support)
• GitHub CLI (gh)
• Caddy (for the dev server)

Install the dependencies if you don't have them:

# Bun
curl -fsSL https://bun.sh/install | bash

# GitHub CLI
brew install gh

# Caddy
brew install caddy

Then download Superset from the releases page:

# Download the latest macOS release
# https://github.com/superset-sh/superset/releases/latest

Once installed, authenticate your agents. For Claude Code and Codex CLI, this means having the respective API keys set in your environment or running the initial auth flow — Superset will launch them in configured terminal sessions, so they need access to the same credentials they'd use standalone.

Running Parallel Agents on a Real Task

Here's a concrete example. You have a codebase with three independent refactoring tasks:

• Migrate the database layer from raw queries to an ORM
• Add input validation to five API endpoints
• Write tests for the authentication module

Without Superset, you'd run these sequentially — each agent finishing before the next starts. With Superset:

1. Create Task 1 in Superset, assign to Claude Code, write your prompt
2. Create Task 2, assign to Codex CLI, write your prompt
3. Create Task 3, assign to Claude Code (a second instance), write your prompt
4. All three start simultaneously, each in its own git worktree

Superset monitors all three. When one finishes or needs input, you get a notification. You review the diff, edit anything the agent got wrong, and move the changes to your main branch. The other two are still running while you review.

This is the core value: the bottleneck in AI-assisted development isn't the model's speed — it's your review-and-iterate loop. Superset lets you parallelize the waiting so the bottleneck becomes your review time, not the agents' compute time.

Building a Custom Agent for Superset

Because Superset works with any CLI agent, you can write a shell script that calls any API and use it as an agent in Superset. Here's a custom agent that uses ModelsLab's OpenAI-compatible LLM endpoint — useful when you want a cheaper alternative to Claude or GPT for high-volume tasks like generating boilerplate, writing docstrings, or summarizing code.

The Agent Script

Create a file at ~/agents/modelslab-agent.sh:

#!/bin/bash
# ModelsLab LLM agent for Superset
# Usage: ./modelslab-agent.sh "your task prompt"

set -e

API_KEY="${MODELSLAB_API_KEY:?Set MODELSLAB_API_KEY in your environment}"
MODEL="${MODELSLAB_MODEL:-meta-llama/llama-3.3-70b-instruct}"
TASK="$1"

if [ -z "$TASK" ]; then
    echo "Usage: $0 'describe your task'"
    exit 1
fi

# Build context: include relevant files from the current worktree
CONTEXT=$(find . -name "*.py" -o -name "*.ts" -o -name "*.js" | \
    grep -v node_modules | grep -v __pycache__ | \
    head -20 | \
    xargs -I {} sh -c 'echo "=== {} ===" && head -100 {}' 2>/dev/null)

echo "Starting ModelsLab agent ($MODEL)"
echo "Task: $TASK"
echo "---"

# Call ModelsLab's OpenAI-compatible chat endpoint
RESPONSE=$(curl -s -X POST "https://modelslab.com/api/v6/llm/chat/completions" \
    -H "Authorization: Bearer $API_KEY" \
    -H "Content-Type: application/json" \
    -d @- << EOF
{
  "model": "$MODEL",
  "messages": [
    {
      "role": "system",
      "content": "You are a coding assistant. Analyze the provided code context and complete the given task. Output only the code changes needed, with file paths as headers."
    },
    {
      "role": "user",
      "content": "Code context:\n\n${CONTEXT}\n\nTask: ${TASK}"
    }
  ],
  "max_tokens": 4096,
  "temperature": 0.1
}
EOF
)

# Extract and display the response
echo "$RESPONSE" | python3 -c "
import json, sys
data = json.load(sys.stdin)
if 'choices' in data:
    print(data['choices'][0]['message']['content'])
elif 'error' in data:
    print(f'Error: {data[\"error\"]}', file=sys.stderr)
    sys.exit(1)
"

echo "---"
echo "Done. Review the output above and apply changes manually."

chmod +x ~/agents/modelslab-agent.sh

Set your API key:

export MODELSLAB_API_KEY="your_api_key"  # Get from docs.modelslab.com

Test it standalone before adding to Superset:

cd /path/to/your/project
~/agents/modelslab-agent.sh "Add docstrings to all public functions in utils.py"

Adding the Custom Agent to Superset

In Superset's settings, you can register custom agent commands. Point it to your script and pass the task prompt as the argument. Once registered, your ModelsLab agent appears alongside Claude Code, Codex CLI, and the others in the task creation interface.

When to Use Each Agent

Running costs and capabilities vary significantly across agents. Here's a practical routing guide:

• Claude Code (Sonnet/Opus): Complex reasoning tasks, architectural decisions, tasks requiring multi-file context understanding. Higher cost, higher quality on ambiguous tasks.
• Codex CLI: Code generation from clear specs, filling in well-defined patterns. Strong on repetitive code tasks.
• Custom ModelsLab agent (Llama 3.3 70B): High-volume routine tasks — docstrings, boilerplate, code summaries, format conversions. Cheaper per call, which matters when you're running 10 agents in parallel.
• Gemini CLI: Tasks involving large context (1M token context window). Good for analyzing entire codebases at once.

In a Superset workflow, a sensible split is: route complex tasks to Claude Code, routine generation tasks to the ModelsLab agent, and codebase-wide analysis to Gemini. You get the quality ceiling of each model for the tasks where it matters, at lower average cost across your parallel queue.

The Model Switching Advantage

ModelsLab's API exposes an OpenAI-compatible endpoint that covers multiple model families. Change the MODEL variable in your agent script to switch:

# Use different models for different task types
MODELSLAB_MODEL="meta-llama/llama-3.3-70b-instruct"   # Fast, cost-efficient
MODELSLAB_MODEL="Qwen/Qwen2.5-coder-32b-instruct"     # Code-specialized
MODELSLAB_MODEL="mistralai/mistral-large-2411"         # Balanced reasoning

The OpenAI-compatible format means the same agent script works with all of them — just change the model string. Useful for Superset workflows where you want different agent specializations without maintaining different scripts.

What This Changes About Your Development Workflow

The practical shift is that AI-assisted development stops being sequential. Before Superset, the typical flow is:

1. Send task to agent → wait 3–5 minutes → review → iterate → next task

With Superset and a pool of agents:

1. Send 10 tasks to 10 agents simultaneously → review as they complete → merge what's good

The constraint becomes your ability to review diffs, not the agents' generation time. If your team reviews code at 3 PRs per hour, you want agents producing PRs at 3 per hour — not 1 every 5 minutes. Superset is how you get there on a single machine.

Current Limitations

Superset is early-stage (launched March 2026). A few things to know before building your workflow around it:

• macOS only — Windows and Linux support is planned but not available
• CLI agents only — GUI-based agents don't work in terminal sessions
• Your machine's RAM and CPU are still the ceiling — 10 agents × token throughput = significant local compute
• Caddy dependency adds a setup step that's non-obvious for developers who haven't worked with it before

Getting Started

Download Superset at github.com/superset-sh/superset/releases/latest.

For a cost-efficient custom agent backend, ModelsLab's API covers Llama, Mistral, Qwen, and SDXL variants under a single OpenAI-compatible endpoint. Pay-as-you-go API access — full documentation at docs.modelslab.com.