superset-sh · AviPeltz · Feb 25, 2026 · coderabbitai · Feb 25, 2026 · coderabbitai
diff --git a/apps/marketing/content/blog/agent-orchestration-not-another-agent.mdx b/apps/marketing/content/blog/agent-orchestration-not-another-agent.mdx
@@ -8,6 +8,28 @@ relatedSlugs:
   - parallel-coding-agents-guide
   - roadmap-to-100-agents
   - working-with-worktrees-in-superset
+keywords:
+  - ai agent orchestration
+  - parallel coding agents
+  - multi-agent workflows
+  - coding agent management
+  - ai coding tools 2026
+  - claude code orchestration
+  - codex orchestration
+  - agent scaling
+  - superset orchestrator
+  - ai development workflow
+faq:
+  - question: "What is AI agent orchestration?"
+    answer: "AI agent orchestration is the process of managing multiple AI coding agents running in parallel — handling isolation, session persistence, task allocation, and unified review. Instead of running one agent at a time, an orchestrator lets you run 5-10+ agents simultaneously on independent tasks."
+  - question: "Why do I need an orchestrator instead of a better AI coding agent?"
+    answer: "A 20% improvement in agent quality improves throughput by 20%. Running 5 agents in parallel instead of 1 improves throughput by 5x. The orchestration layer has more leverage than the agent layer because the bottleneck is managing multiple agents, not individual agent quality."
+  - question: "How does Superset orchestrate multiple coding agents?"
+    answer: "Superset uses Git worktrees for filesystem isolation, a persistent daemon for session management, and supports any CLI agent (Claude Code, Codex, Aider, OpenCode) as a first-class citizen. It includes a built-in diff viewer for fast review and editor integration for VS Code, Cursor, JetBrains, and Xcode."
+  - question: "Can I use different AI coding agents for different tasks?"
+    answer: "Yes. An orchestrator like Superset is agent-agnostic, letting you match agents to tasks — Claude Code for complex refactors, Codex for well-defined tasks, Aider for iterative changes — and run them all simultaneously."
+  - question: "What's the difference between an AI coding agent and an AI agent orchestrator?"
+    answer: "An AI coding agent (like Claude Code, Codex, or Cursor) performs individual coding tasks. An AI agent orchestrator (like Superset) manages multiple agents running in parallel, handling isolation, session persistence, and review workflows so you can scale from 1 agent to 10+."
 ---
 
 Every month, a new AI coding agent launches. Claude Code. Codex. Aider. OpenCode. Cursor's agent mode. Windsurf's Cascade. Devin. The list keeps growing. Each promises to be smarter, faster, more capable than the last.

diff --git a/apps/marketing/content/blog/git-worktrees-history-deep-dive.mdx b/apps/marketing/content/blog/git-worktrees-history-deep-dive.mdx
@@ -6,7 +6,30 @@ date: 2026-01-27
 category: Engineering
 relatedSlugs:
   - terminal-daemon-deep-dive
-  - how-to-get-hit
+  - working-with-worktrees-in-superset
+  - parallel-coding-agents-guide
+keywords:
+  - git worktrees
+  - git worktree tutorial
+  - git worktree history
+  - git 2.5 worktrees
+  - multiple working directories git
+  - git worktree ai agents
+  - parallel branch development
+  - git-new-workdir
+  - worktree internals
+  - git worktree best practices
+faq:
+  - question: "What are Git worktrees and when were they introduced?"
+    answer: "Git worktrees are a feature introduced in Git 2.5 (July 2015) that lets you check out multiple branches simultaneously in separate working directories, all sharing the same git object store. They were primarily authored by Nguyễn Thái Ngọc Duy."
+  - question: "Why are Git worktrees suddenly popular in 2026?"
+    answer: "AI coding agents need isolated environments to work without conflicting. Worktrees provide filesystem-level isolation — each agent gets its own directory, branch, and staging area while sharing the git history. This pattern of parallel human + AI work is driving a resurgence in worktree adoption."
+  - question: "What's the difference between Git worktrees and cloning a repo twice?"
+    answer: "Worktrees share the git object store (commits, trees, blobs), so they take seconds to create and use minimal disk space. Separate clones duplicate the entire history, take minutes to create, and require push/pull to synchronize. Worktrees also share branches and tags natively."
+  - question: "Can the same branch be checked out in multiple Git worktrees?"
+    answer: "No. Git enforces a one-branch-per-worktree rule to prevent confusing bugs where commits in one worktree would cause unexpected dirty diffs in another. You can work around this with detached HEAD or by creating a new branch."
+  - question: "How do Git worktrees work under the hood?"
+    answer: "When you create a worktree, git creates a new directory with a .git file (not directory) pointing back to the main repo. The main repo stores worktree metadata in .git/worktrees/<name>/ with separate HEAD, index, and reflog files. Shared resources like objects and refs are resolved via the commondir mechanism."
 ---
 
 Git worktrees have been around since 2015. For most of that time, they were a curiosity — something kernel developers used, something that showed up in obscure Stack Overflow answers, something most developers had never heard of.

diff --git a/apps/marketing/content/blog/parallel-coding-agents-guide.mdx b/apps/marketing/content/blog/parallel-coding-agents-guide.mdx
@@ -8,6 +8,28 @@ relatedSlugs:
   - working-with-worktrees-in-superset
   - roadmap-to-100-agents
   - git-worktrees-history-deep-dive
+keywords:
+  - parallel coding agents
+  - run multiple ai agents
+  - ai agent isolation
+  - git worktrees ai agents
+  - claude code parallel
+  - codex parallel
+  - agent orchestration guide
+  - ai coding workflow
+  - review bottleneck agents
+  - multi-agent development
+faq:
+  - question: "How do I run multiple AI coding agents in parallel without conflicts?"
+    answer: "Use Git worktrees to give each agent its own working directory, branch, and staging area. Each worktree shares the git object store but has completely isolated files, preventing agents from overwriting each other's work."
+  - question: "How many AI coding agents can I run at the same time?"
+    answer: "On a modern laptop, 5-7 concurrent agents are comfortable. Start with 2-3 to get used to the review workflow, then scale up. The bottleneck is usually review speed, not compute resources."
+  - question: "Which AI coding agent is best for which task?"
+    answer: "Claude Code excels at complex multi-file refactors and architectural changes. Codex is fast for well-scoped, clearly defined tasks. OpenCode offers flexibility with 75+ model providers. Aider is ideal for iterative pair programming with tight feedback loops."
+  - question: "What is the biggest challenge with running parallel AI coding agents?"
+    answer: "The review bottleneck. If you run 10 agents producing diffs every 15 minutes, you need to review 10 diffs per hour. Strategies include prioritizing by risk, reviewing diffs rather than full files, letting agents verify their own work with tests, and batching similar tasks."
+  - question: "Do I need a special tool to run parallel coding agents?"
+    answer: "You can start with manual Git worktrees for 2-3 agents, but for 5+ agents you need a dedicated orchestrator like Superset that handles worktree creation, session persistence, diff review, and editor integration automatically."
 ---
 
 Running one AI coding agent is straightforward. Running ten at once introduces problems that most developers haven't encountered before: file conflicts, branch collisions, resource contention, and a review bottleneck that grows linearly with agent count. This guide covers the patterns that work and the mistakes to avoid.

diff --git a/apps/marketing/content/blog/roadmap-to-100-agents.mdx b/apps/marketing/content/blog/roadmap-to-100-agents.mdx
@@ -1,9 +1,34 @@
 ---
 title: "Our plan for running 100 Parallel Coding Agents"
-description: "An attempt to crystallize our plans for 2026"
+description: "How Superset plans to scale from 7 to 100 parallel coding agents by the end of 2026. The bottleneck isn't better models — it's the human review loop."
 author: satya
 date: 2026-02-02
 category: Product
+image: /blog/roadmap-to-100-agents/cover.png
+relatedSlugs:
+  - parallel-coding-agents-guide
+  - agent-orchestration-not-another-agent
+  - working-with-worktrees-in-superset
+keywords:
+  - 100 parallel coding agents
+  - scaling ai agents
+  - agent review bottleneck
+  - coding agent roadmap
+  - adversarial agents code review
+  - ai agent automation
+  - superset agent scaling
+  - event-driven coding agents
+  - agent-driven UI
+  - automated code review agents
+faq:
+  - question: "Why can't you just run more AI coding agents to scale?"
+    answer: "The bottleneck isn't agent compute — it's the human review loop. Every agent needs a human to review its code, give feedback, and decide what to work on next. At 100 agents, you can't review 100 diffs a day or context-switch between 100 streams of work."
+  - question: "How does Superset plan to scale to 100 parallel agents?"
+    answer: "Three strategies: (1) Have agents work harder before reaching you — using adversarial review agents, stacked testing, and long-running iteration loops. (2) Make review faster — with agent-driven UIs that prepare briefings instead of raw diffs. (3) Make agents more proactive — with event-driven triggers and reusable workflows."
+  - question: "What are adversarial agents in code review?"
+    answer: "Adversarial agents are review agents that sit between coding agents and the human reviewer, enforcing tests, reviewing code quality, and preventing agents from surfacing work until it meets quality standards. This turns human review into a final sign-off rather than a first pass."
+  - question: "How many AI coding agents can you realistically run in parallel today?"
+    answer: "Superset currently supports 5-7 reliable parallel coding agents. The path to 100 requires reducing human involvement per agent interaction through automated review layers, agent-driven UIs, and event-driven task allocation."
 ---
 
 ![Superset — managing coding agents in parallel](/blog/roadmap-to-100-agents/cover.png)

diff --git a/apps/marketing/content/blog/terminal-daemon-deep-dive.mdx b/apps/marketing/content/blog/terminal-daemon-deep-dive.mdx
@@ -6,7 +6,26 @@ date: 2026-01-26
 category: Engineering
 relatedSlugs:
   - git-worktrees-history-deep-dive
-  - how-to-get-hit
+  - working-with-worktrees-in-superset
+  - roadmap-to-100-agents
+keywords:
+  - persistent terminal electron
+  - terminal daemon architecture
+  - electron terminal session persistence
+  - node-pty daemon
+  - unix domain socket terminal
+  - terminal backpressure handling
+  - xterm.js headless emulator
+  - cold restore terminal
+  - superset terminal architecture
+  - electron app terminal
+faq:
+  - question: "How does Superset's terminal survive app restarts?"
+    answer: "Superset runs a detached Node.js daemon process that owns all PTY sessions. The Electron app connects as a client over Unix domain sockets. When the app restarts, it reconnects to the still-running daemon and reattaches to existing sessions."
+  - question: "What happens if the terminal daemon crashes?"
+    answer: "Superset implements cold restore — terminal scrollback and metadata are persisted to disk. On next launch, it detects unclean shutdown, shows the previous scrollback as read-only, and spawns a new shell in the same directory."
+  - question: "Why didn't Superset use tmux for terminal persistence?"
+    answer: "Tmux has three issues: (1) it's an extra dependency users must install, (2) it doesn't work on Windows, and (3) tmux hijacks scrollbar, selection, and hotkeys inside xterm.js, making the experience clunky. A custom daemon avoids all three problems."
 ---
 
 One of the slickest features of Superset is how our terminal survives app restarts. This is a deep dive on how we built it. Huge credits to [Andreas Asprou](https://x.com/andyasprou) who spearheaded this entire effort.

diff --git a/apps/marketing/content/blog/working-with-worktrees-in-superset.mdx b/apps/marketing/content/blog/working-with-worktrees-in-superset.mdx
@@ -7,6 +7,27 @@ category: Engineering
 relatedSlugs:
   - git-worktrees-history-deep-dive
   - roadmap-to-100-agents
+  - parallel-coding-agents-guide
+keywords:
+  - git worktrees superset
+  - ai agent isolation
+  - parallel development workflow
+  - worktree agent orchestration
+  - superset worktrees tutorial
+  - multiple coding agents workflow
+  - git worktrees vs containers
+  - agent workspace isolation
+  - concurrent ai development
+  - worktree management tool
+faq:
+  - question: "How does Superset use Git worktrees for AI coding agents?"
+    answer: "When you create a task in Superset, it automatically creates a Git worktree and branch for the agent. The agent works in isolation with its own files, branch, and staging area, while sharing the git object store. When finished, you review the diff and merge — just like reviewing a coworker's PR."
+  - question: "What are the advantages of Git worktrees over Docker containers for AI agents?"
+    answer: "Git worktrees are faster to create (seconds vs minutes), cheaper on disk (shared object store), share git history natively, and use standard git merging. Containers add unnecessary overhead for most coding tasks where filesystem isolation is sufficient."
+  - question: "How many parallel agents can Superset manage with worktrees?"
+    answer: "Most developers find a sweet spot around 5-7 concurrent agents before review becomes the bottleneck. Superset's persistent daemon manages all sessions via Unix domain sockets, with sessions surviving crashes and app restarts."
+  - question: "Can I use different AI coding agents in different worktrees?"
+    answer: "Yes. Superset is agent-agnostic — you can run Claude Code on a complex refactor, Codex on test generation, and Aider on iterative fixes, all simultaneously in separate worktrees."
 ---
 
 Running one AI coding agent is useful. Running ten at once is a different game entirely. But running ten agents in the same working directory is a disaster — they step on each other's files, create merge conflicts mid-edit, and leave your codebase in an unpredictable state.

diff --git a/apps/marketing/content/compare/best-ai-coding-agents-2026.mdx b/apps/marketing/content/compare/best-ai-coding-agents-2026.mdx
@@ -23,6 +23,23 @@ keywords:
   - codex alternatives
   - ai pair programmer comparison
   - ai agent orchestration
+  - windsurf alternatives
+  - devin alternatives
+  - github copilot alternatives
+  - conductor alternatives
+faq:
+  - question: "Which AI coding tool is the best in 2026?"
+    answer: "There's no single best — it depends on your workflow. For parallel agent execution, Superset is the leading orchestrator. For single-agent depth, Claude Code and Cursor lead. For inline completions, GitHub Copilot is the standard. Most developers combine tools from different categories."
+  - question: "Can I use multiple AI coding tools together?"
+    answer: "Yes, and most teams do. A common stack is an orchestrator (Superset) + a primary agent (Claude Code or Codex) + inline completions (Copilot). These tools serve different purposes and don't conflict."
+  - question: "What's the difference between an AI coding agent and an AI coding orchestrator?"
+    answer: "An agent talks to AI models, reads your code, and makes changes. An orchestrator runs many agents in parallel with isolation and management. Think of it as the difference between a developer and a project manager — one does the work, the other coordinates many workers."
+  - question: "Is it worth paying for AI coding tools?"
+    answer: "The free tiers of most tools are sufficient for light usage. If you're using agents for multiple hours daily, paid plans and direct API access typically offer better throughput and reliability. At scale, the ROI is significant — AI agents can handle work that would take hours."
+  - question: "Which AI coding tool is most private?"
+    answer: "Superset and OpenCode are both open source and run locally with no telemetry. Codex CLI is open source but requires OpenAI API calls. Cursor, Windsurf, Devin, and Copilot all route code through external servers."
+  - question: "What is the best free AI coding tool?"
+    answer: "For agents, OpenCode (MIT license, 75+ providers) and Codex CLI (Apache 2.0) are fully free and open source — you only pay for API usage. For orchestration, Superset has a free tier. For inline completions, GitHub Copilot has a free tier with limited requests."
 ---
 
 The AI coding landscape in 2026 has split into two categories: **agents** that write code and **orchestrators** that manage agents. This guide compares the major tools in both categories so you can build the right stack for your workflow.
@@ -35,21 +52,21 @@ The AI coding landscape in 2026 has split into two categories: **agents** that w
 
 These tools talk to AI models, read your code, and make changes:
 
-- **Claude Code** — Anthropic's terminal agent, strong at complex multi-file refactors
-- **Codex CLI** — OpenAI's open-source terminal agent with sandbox modes
-- **GitHub Copilot** — Inline completions + chat + Agent mode in your editor
-- **Cursor** — AI-native IDE (VS Code fork) with deep editor integration
-- **Windsurf** — AI-powered IDE with Cascade agentic workflows
-- **Devin** — Fully autonomous cloud-based AI software engineer
-- **OpenCode** — Open-source terminal agent supporting 75+ model providers
+- **[Claude Code](/compare/superset-vs-claude-code)** — Anthropic's terminal agent, strong at complex multi-file refactors
+- **[Codex CLI](/compare/superset-vs-codex)** — OpenAI's open-source terminal agent with sandbox modes
+- **[GitHub Copilot](/compare/superset-vs-github-copilot)** — Inline completions + chat + Agent mode in your editor
+- **[Cursor](/compare/superset-vs-cursor)** — AI-native IDE (VS Code fork) with deep editor integration
+- **[Windsurf](/compare/superset-vs-windsurf)** — AI-powered IDE with Cascade agentic workflows
+- **[Devin](/compare/superset-vs-devin)** — Fully autonomous cloud-based AI software engineer
+- **[OpenCode](/compare/superset-vs-opencode)** — Open-source terminal agent supporting 75+ model providers
 - **Aider** — Open-source terminal agent focused on iterative pair programming
 
 ### Agent Orchestrators
 
 These tools run and manage multiple agents:
 
 - **Superset** — Desktop terminal that runs 10+ agents in parallel via Git worktrees
-- **Conductor** — macOS app for running Claude Code and Codex in parallel
+- **[Conductor](/compare/superset-vs-conductor)** — macOS app for running Claude Code and Codex in parallel
 
 Most developers use one tool from each category. The agent does the coding; the orchestrator scales it.