Skip to content

docs(marketing): update guides and comparisons #7752

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
Kitenite merged 3 commits into from
Sep 23, 2026
Merged

docs(marketing): update guides and comparisons #7752

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
b994eb8
docs(marketing): update workflow guides and comparisons
Kitenite Sep 23, 2026
9594422
docs(marketing): polish blog copy and keep selected guides unlisted
Kitenite Sep 23, 2026
df0684c
docs(marketing): name automation recovery actions
Kitenite Sep 23, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
120 changes: 26 additions & 94 deletions apps/marketing/content/blog/agent-orchestration-not-another-agent.mdx
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,6 +1,6 @@
---
title: "You Don't Need Another AI Coding Agent: You Need an Orchestrator"
description: "The AI coding tools landscape is flooded with agents. The real bottleneck isn't agent quality. It's managing multiple agents at scale. Here's why orchestration is the missing layer."
title: "Managing Several Coding Agents at Once"
description: "Give coding agents separate workspaces, keep track of blocked tasks, and review changes while other agents keep working."
author: satya
date: 2026-02-18
category: Product
Expand All @@ -10,118 +10,50 @@ relatedSlugs:
- working-with-worktrees-in-superset
---

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.
One coding agent is easy to follow. With several running at once, you need to know which task each one owns, which agent needs an answer, and which changes are ready to review.

The agents are already good enough. Claude Code can refactor a module. Codex can write a test suite. Aider can iterate on a bugfix. The quality difference between top-tier agents is shrinking. What's not getting better is the workflow around them.
That's the problem we built Superset to help with. It runs the agents you already use in separate workspaces and gives you a place to manage their output.

The real bottleneck isn't agent quality. It's agent quantity.
## Start with independent tasks

---

## The Single-Agent Ceiling

Most developers use AI coding agents the same way:

1. Open terminal
2. Describe a task
3. Watch the agent work
4. Review the output
5. Give feedback or merge
6. Repeat

This is sequential. One task at a time. The agent might take 5 minutes. Your review might take 10. That's one task per 15 minutes, four tasks per hour. For an individual developer, that's a solid productivity boost.

But your codebase has 50 parallelizable tasks right now. Writing tests for untested modules. Refactoring deprecated patterns. Updating stale documentation. Migrating config formats. Fixing lint warnings. Each task is independent. None requires the output of another.

Running them one at a time means 50 tasks at 15 minutes each: over 12 hours. Running 5 in parallel: under 3 hours. Running 10 in parallel: under 2 hours. The math is straightforward. The orchestration is the hard part.

---
A test for an existing helper, a documentation correction, and a small UI change can often run separately. An API rewrite and tests that depend on that rewrite need an order.

## Why Orchestration Is Hard
Parallel work helps when one task can progress while you're reviewing another. More agents also create more output to check. Add tasks at a pace you can review, and watch for shared dependencies that make them less independent than they look.

### Isolation
The [parallel coding guide](/blog/parallel-coding-agents-guide) walks through three tasks, with prompts and review steps.

Two agents in the same directory destroy each other's work. You need filesystem-level isolation: each agent in its own working directory with its own branch. Git worktrees solve this elegantly, but setting them up manually for every task is tedious.
## Give each task its own workspace

### Session Management
Agents editing the same working directory can overwrite each other's changes or mix them in the staging area. A Git worktree gives each task a separate checkout and index while sharing the repository's history.

Agents crash. Terminals close. Laptops go to sleep. If your agent's session dies, you lose the context and have to restart. For a single agent, this is annoying. For 10 agents, it's unmanageable.
In Superset, create a workspace and branch for each independent task. The agent works there while you keep using your main checkout. When it's ready, review its diff before merging.

### Review
Worktrees separate files. They don't isolate ports, databases, credentials, or machine resources. Two branches can also make incompatible changes, so test the combined result after merging.

The review workflow matters more with parallel agents, not less. You need to see what each agent changed, verify it against the task description, and decide whether to merge or iterate. Without a unified view across all tasks, you're tab-switching between terminals.
## Keep sessions separate from the app window

### Task Allocation

Not every task suits every agent. Claude Code handles complex refactors better than Codex. Codex is faster for well-defined tasks. Aider excels at iterative changes. An orchestrator lets you match agents to tasks instead of using one agent for everything.

---

## Orchestration vs More Agents

The AI coding industry is betting heavily on better agents. Smarter models, larger context windows, better tool use. These improvements are real and valuable.

But consider: a 20% improvement in agent quality (smarter code, fewer bugs) 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.

This isn't an argument against better agents. It's an argument that the orchestration layer deserves equal attention. The best coding agent in the world, run one at a time, is slower than a good agent run ten at a time.

---
Closing the interface shouldn't end the work running inside it. Superset's terminal daemon owns terminal sessions separately from the desktop UI, so you can reconnect after an app restart.

## What Good Orchestration Looks Like
The host and daemon still need to be running. A machine reboot stops the processes; saved terminal history helps you recover context, but it doesn't keep an agent executing through a reboot. The [terminal daemon deep dive](/blog/terminal-daemon-deep-dive) explains the design.

![A workspace board triaging a fleet of coding agents by status: working, needs attention, needs review, and merged](/changelog/2026-08-16-workspaces-board.png)
## See what needs your attention

### Automatic Isolation
![Superset's workspace board showing tasks that are working, need attention, or are ready for review.](/changelog/2026-08-16-workspaces-board.png)

Creating a task should automatically create a Git worktree and branch. No manual setup, no remembering to checkout a new branch, no worrying about file conflicts. The orchestrator handles this transparently.
A useful workspace view tells you where to act next. Answer the agent waiting for a decision, then review a completed task while the others keep running.

### Session Persistence
For each change, check what the agent edited and whether it ran the right tests. Open the workspace in your editor when you need more context. A short diff can still change important behavior.

Agent sessions should survive crashes, app restarts, and laptop sleep cycles. A background daemon that owns the sessions independently of the UI solves this: the same pattern that tmux uses for terminal multiplexing, applied to agent orchestration.
## Choose agents without rebuilding your workflow

### Agent Agnosticism
Use the agent and model that work for your repository. Keep the task description and acceptance checks consistent when trying another tool so you can compare the results.

Lock-in to a single agent is a strategic mistake. The AI landscape moves fast. Today's best agent might be tomorrow's second-best. An orchestrator should run any CLI-based agent: Claude Code, Codex, Aider, OpenCode, or whatever ships next week.
Superset runs CLI agents in workspace terminals. You can use Claude Code for one task and Codex for another, then review both through the same workspace workflow. Your editor stays part of the process: open the worktree in VS Code, Cursor, JetBrains, Xcode, or the editor you prefer.

### Unified Review
## Start with two tasks

All active tasks, their status, and their diffs should be visible in one place. When a task completes, the review workflow should be fast: see the diff, open in your editor if needed, merge or give feedback. Seconds per review, not minutes.
Give each agent a clear scope and a check it must run. When one finishes, review it while the other continues. If the review queue grows faster than you can clear it, start fewer tasks or make them smaller.

### Editor Integration

Developers have strong editor preferences. The orchestrator shouldn't force an editor choice. It should integrate with whatever you use (VS Code, Cursor, JetBrains, Xcode, Neovim) and let you open any worktree in your preferred environment.

---

## Building This at Superset

We built [Superset](https://superset.sh) because we hit this ceiling ourselves. We were running Claude Code for everything, and it was great for individual tasks. But scaling to 5-7 agents manually was operational overhead that distracted from the actual work.

The architecture is intentionally simple:

- **Git worktrees** for isolation (no containers, no VMs)
- **Persistent daemon** for session management (Unix domain sockets, survives crashes)
- **Any CLI agent** as a first-class citizen (no SDK integrations to maintain)
- **Built-in diff viewer** for fast review
- **Editor integration** for deep inspection (VS Code, Cursor, JetBrains, Xcode)

The orchestrator doesn't make agents smarter. It makes using agents at scale practical. That's the missing layer in most developers' AI workflows: not a better agent, but a better way to run the agents they already have.

---

## The Compound Effect

Running parallel agents has a compound effect on productivity:

1. **More tasks completed per day**: 5x agents means 5x throughput (minus review overhead)
2. **Faster iteration**: while one agent iterates on feedback, others are working on new tasks
3. **Better agent matching**: use the right agent for each task instead of one-size-fits-all
4. **Reduced context switching**: tasks run to completion in isolation instead of being stashed and resumed

The developers we work with who've adopted parallel agent workflows don't go back to single-agent work. The throughput difference is too large. The question shifts from "which agent should I use?" to "how many agents can I actually manage?"

That's the right question. And the answer is: as many as your orchestrator supports and your review speed allows.

---
The point is to finish useful work with less waiting. The number of open terminals is only part of that.

**Related:** [Best Agentic IDE in 2026](/compare/best-agentic-ide) · [Best AI Coding Tools and Agents (2026)](/compare/best-ai-coding-agents-2026) · [Best Conductor Alternatives](/compare/conductor-alternative)
**Related:** [Working with Git Worktrees in Superset](/blog/working-with-worktrees-in-superset) · [Best Agentic IDE in 2026](/compare/best-agentic-ide)
106 changes: 106 additions & 0 deletions apps/marketing/content/blog/claude-code-codex-iphone.mdx
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,106 @@
---
title: "Manage Claude Code and Codex from your iPhone"
description: "Connect an iPhone to your Superset workspaces, unblock Claude Code or Codex, and inspect changes. Includes Pro requirements, host setup, and offline troubleshooting."
author: kiet
date: 2026-09-22
unlisted: true
category: Engineering
image: /images/blog/superset-mobile/diffs.png
relatedSlugs:
- superset-mobile
- parallel-coding-agents-guide
- scheduled-agent-maintenance
keywords:
- claude code iphone
- codex iphone
- coding agents from phone
---

Your agent asks a question just as you leave your desk. Open Superset on your iPhone, reply in the same terminal, and check the diff when the change is ready.

Claude Code and Codex keep running on your computer. Superset Mobile gives you access to those workspaces from your phone.

## What you need

- An iPhone running **iOS 26 or later** and **Superset Pro**.
- A host computer with your repository and an authenticated coding agent.
- The same Superset account and organization on both devices.

The host must stay awake and online. Closing your laptop can put it to sleep and disconnect the session. For work that needs to continue overnight, use a computer that stays on.

Your agent subscription or API usage is billed separately. See [plans](/pricing). Android is on the [waitlist](/mobile#android).

<StoreBadges source="blog_claude_code_codex_iphone" androidHref="/mobile#android" />

## Connect your computer

In Superset desktop, open **Settings → Remote Access** and enable **Allow remote access to this device via relay**. Enable it before starting work: changing this setting restarts the host service and interrupts running terminals.

On a dedicated host, use the CLI:

```bash
superset auth login
superset start --daemon
superset status
```

See [remote access setup](https://docs.superset.sh/remote-access) for host permissions and connection settings.

## Start a task on desktop

Create a workspace in your repository and start Claude Code or Codex. For a small search-copy change, try:

```text
Propose a clearer message for the search screen's no-results state.
Ask me to approve the wording before editing. Then change the message
and any existing test that asserts it. Run the relevant check.
Do not commit, push, or merge.
```

Replace the example with a task from your project. Asking for a proposal gives you a chance to choose the wording before the agent edits it.

## Reply from your iPhone

Open the connected host in Superset Mobile, then open the workspace. Read the proposal in its terminal and send your approval or a revision.

You're continuing the session on your computer. You don't need to start a new chat or paste in the conversation. Try sending a message from your phone before leaving your desk to check the connection.

## Review the diff

Open **Files changed** to see what the agent edited. Check the message and its test result, then ask for any corrections in the terminal.

<video controls playsInline preload="metadata" poster="/videos/blog/phone-diff-review/poster.jpg" aria-label="Inspect a sample diff and mark the file viewed in Superset Mobile" className="mx-auto max-h-[640px] w-auto rounded-xl">
<source src="/videos/blog/phone-diff-review/demo.mp4" type="video/mp4" />
Your browser can [download the diff-review recording](/videos/blog/phone-diff-review/demo.mp4).
</video>

Inspect the diff, then mark the file as viewed.

For a larger change, continue the review on desktop. Open the same workspace, run any remaining checks, and commit or open a pull request when you're ready.

## If you can't connect

- **Host offline:** check that the computer is awake, online, and running the host service.
- **Host missing:** check your account, organization, and host membership on both devices.
- **Terminal works but the agent doesn't:** check the agent's login, usage limits, and repository setup on the host.
- **Session stopped after changing remote access:** reopen the workspace and check the terminal before resuming.

## Frequently asked questions

### Does Claude Code or Codex run on the iPhone?

The agent runs on your connected computer. The iPhone lets you send instructions and review its work.

### Can I use Claude Code and Codex together?

Yes. Install and authenticate both on the host, then use separate workspaces for independent tasks. You can open either workspace from your phone.

### Will work continue if my laptop is closed?

Only if it stays awake and connected. Use another host that stays online if you need work to continue while your laptop sleeps.

### Is the mobile app free?

It's free to download. Mobile access requires Superset Pro, and agent usage is billed separately by its provider.

For several tasks at once, follow the [parallel coding workflow](/blog/parallel-coding-agents-guide). To run work on a schedule, see the [maintenance automation guide](/blog/scheduled-agent-maintenance).
Loading
Loading