- Superset makes it easy to spin up git worktrees and automatically setup your environment
- Agents and terminal tabs are isolated to worktrees, preventing conflicts
- Built-in hooks [0] to notify when your coding agents are done/needs attention,
- A diff viewer to review the changes and make PRs quickly
We’re three engineers who’ve built and maintained large codebases, and kept wanting to work on as many features in parallel as possible. Git worktrees [1] have been a useful solution for this task but they’re annoying to spin up and manage. We started superset as a tool that uses the best practices we’ve discovered running parallel agents.
Here is a demo video:
https://www.youtube.com/watch?v=pHJhKFX2S-4
We all use Superset to build Superset, and it more than doubles our productivity (you’ll be able to tell from the autoupdates). We have many friends using it over their IDE of choice or replacing their terminals with Superset, and it seems to stick because they can keep using whatever CLI agent or tool they want while Superset just augments their existing set of tools.
Superset is written predominantly in Typescript and based on Electron, xterm.js, and node-pty. We chose xterm+node-pty because it's a proven way to run real PTYs in a desktop app (used by VSCode and Hyper), and Electron lets us ship fast. Next, we’re exploring features like running worktrees in cloud VMs to offload local resources, context sharing between agents, and a top-level orchestration agent for managing many worktrees or projects at once.
We’ve learned a lot building this: making a good terminal is more complex than you’d think, and terminal and git defaults aren’t universal (svn vs git, weird shell setups, complex monorepos, etc.).
Building a product for yourself is way faster and quite fun. It's early days, but we’d love you to try Superset across all your CLI tools and environments, we welcome your feedback! :)
I haven’t setup worktrees yet, so if I have a quick task while working in main, I currently just spin up another agent in plan mode, and then execute them serially. In parallel would be really nice though. I often have 5-10 agents with completed plans, and I’m just slogging through executing them one at a time.
I’ve been able to productively run 12+ agents from CC, Codex, Gemini-cli at the same time this way and it works really well.
Most of these agents solutions are focusing on git branches and worktrees, but at least none of them mention databases. How do you handle them? For example, in my projects, this means I would need ten different copies of my database. What about other microservices that are used, like redis, celery, etc? Are you duplicating (10-plicating) all of them?
If this works flawlessly it would be very powerful, but I think it still needs to solve more issues whan just filesystem conflicts.
For example: • if you’re using Neon/Supabase, your setup script can create a DB branch per workspace • if you’re using Docker, the script can launch isolated containers for Redis/Postgres/Celery/etc
Currently we only orchestrate when they run, and have the user define what they do for each project, because every stack is different. This is a point of friction we are also solving by adding some features to help users automatically generate setup/teardown scripts that work for their projects.
We are also building cloud workspaces that will hopefully solve this issue for you and not limit users by their local hardware.
For my current project (Postgres proxy like PGBouncer) I had Claude write a benchmark system that’s worktree aware. I have flags like -a-worktree=… -b-worktree =… so I can A/B benchmark between worktrees. Works great.
For some cases test-containers [1] is an option as well. I’m using them for integration tests that need Postgres.
For databases, if you can’t see a connection string in env vars, use sqlite://:memory and make a test db like you do for unit testing.
For redis, provide a mock impl that gets/sets keys in a hash table or dictionary.
Stop bringing your whole house to the camp site.
What does that mean in this context?
What higher fidelity do you get with a real postgres over a SQLite in memory or even pglite or whatever.
The point isn’t you shouldn’t have a database, the point is what are your concerns? For me and my teams, we care about our code, the performance of that code, the correctness of that code, and don’t test against a live database so that we understand the separation of concerns between our app and its storage. We expect a database to be there. We expect it to have such and such schema. We don’t expect it to live at a certain address or a certain configuration as that is the databases concern.
We tell our app at startup where that address is or we don’t. The app should only care whether we did or not, if not, it will need to make one to work.
This is the same logic with unit testing. If you’re unit testing against a real database, that isn’t unit testing, that’s an integration test.
If you do care about the speed of your database and how your app scales, you aren’t going to be doing that on your local machine.
> What higher fidelity do you get with a real postgres over a SQLite in memory or even pglite or whatever
You want them to have the same syntax and features, to the extent that you use them, or you'll have one code path for testing and another for production. For example, sqlite does not support ARRAYs or UUIDs natively, so you'll have to write a separate implementation. This is a vector for bugs.
If you fail to understand why this separation is important, you'll fail to reason with why you'd do it in the first place so continue building apps like it's 1999, tightly coupled and you need the whole stack to run your thing. God forbid you expand beyond just 1 team.
Parallel agents are useful for:
1. Offloading minor refactoring work
2. Offloading non-overlapping features
3. Offloading unit or integration test additions
4. Exploring multiple ways to build a feature with maybe different coding models
5. Seeing how Claude code thinks for extremely ambitious ideas and taking only the gist of it
Most of these tools don’t make working with Git merges or conflicts to main simpler in their UX. Even in Cursor, it helps to be good at using git from the command line to use Parallel agents effectively (diff, patch, cherry-pick from worktree to main etc)
- I am no longer chained to my laptop. With the right setup, you can make real progress just using your phone as a thin client to your agents.
- They can easily outrun me when it comes to raw typing speed. For certain tasks, this does make things faster since the review is easy but the editing is tedious. It also helps if you have RSI.
- They are great for delegating small things that can potentially become distracting rabbit holes.Gives me 15 more minutes to work on another task!
For bug fixes and quick changes I can definitely get to 5-7 in parallel, but for real work I can only do 2-3 agents in parallel.
Human review still remains the /eventual/ bottleneck, but I find even when I'm in the "review phase" of a PR, I have enough downtime to get another agent the context it needs between agent turns.
We're looking into ways to reduce the amount of human interaction next, I think there's a lot of cool ideas in that space but the goal is over time tools improve to require less and less human intervention.
And yeah the next frontier is definitely offloading to agents in sandboxes, Kiet has that as one of his top priorities.
Recently I gave Catnip a try and it works very smoothly. It works on web via GitHub workspaces and also has mobile app. https://github.com/wandb/catnip
How is this different?
The mobile app is a pretty cool feature though - will definitely take a peek at that soon.
Superset will be a good alternative for someone who is using only ClaudeCode or CLIs. But for someone using Cursor, How does this differ from Cursor’s Agents UI, which supports local background agents using Git worktrees?
I'd need to do a refresher but for Cursor agents you can choose any model but you're tied to their tooling right? I've heard they're really solid I just find people have their cli preferences and being terminal-first let's anyone bring their favorite agent along for the ride
It is really hard to justify tools like these, where you need CC+this tool+ some other tools to make it more productive , and you need to deal with billing where cursor gives you access to all models possible + BYOK.
Not trying to be negative ... but why hustle?
I feel that maybe a couple of things in parallel could be useful at certain times, but more often the need is not for "one more jira ticket in the pipeline" but rather things like meetings, discussing strategy, clarifying things so they can be built at all as opposed to actually having ten crystal clear tasks to unleash the bot army on.
I liked this video a lot for a general idea of how it's possible, the main thing we need for 10 agents at once to be possible is less of a need for human intervention for agents, but I think it'll happen sooner (it may even be possible now with the right tools) than later.
I do tend to like the niceties of our GUI tho, if you get a chance to compare your cli / our GUI would love to hear what you think!
This kind of workflow feels a lot like "making the horse ten times faster", instead of using the power of AI to make developers stronger to build things that were previously too difficult or not worth the effort.
I guess I don't really see the intersection of "simple enough for parallel agents" vs "valuable enough to be worth the parallelization overhead".
Conductor
Chorus
Vibetunnel
VibeKanban
Mux
Happy
AutoClaude
ClaudeSquad
All of these allow you to work on multiple terminals at once. Some support work trees and others don’t. Some work on your phone and others are desktop only.
Superset seems like a great addition!
But it on the roadmap and glad to know theres interest there :)
I have my own VM's with agents installed inside, is there a tool which supports calling a codex/claude in a particular directory through a particular SSH destination?
Basically BringYourOwnAgentAndSandbox support.
Or which supports plugins so I can give it a small script which hooks it up to my available agents.
Since it’s open source and based on GitHub workspaces, it’s free and works very smoothly.
to be more clear, I'm talking about supporting attaching to and using existing VMs, not about your app creating/destroying the VMs.
For more complex setups if your app has hardcoded ports or multiple services that need coordination you can use setup/teardown scripts to manage this. Either dynamically assigning ports or killing the previous server before starting a new one (you can also kill the previous sever manually).
In practice most users aren't running all 10 agent's dev servers at once (yet), you're usually actively previewing 1-2 at at time while the other are working (writing code, running tests, reviewing, etc). But please give it a try and let me know if you encounter anything you want us to improve :)
You had use cases before in which you wanted more than 2 worktrees at once in the past and needed to juggle between them at the speed of "practical"?
What were you doing back then (a few years back and before agents as you implied) that required this and that your solution now solves?
What poor usability are you referring to here? Is the rate of utilizing git-worktrees a metric you are measuring? That does not make sense to me.
I also watched the demo video, and I don't understand the value here. Perhaps I am not your target demographic, but I am trying to understand who is. Is this for vibe-coding side projects only? Would be nice if you had a more practical/real stakes example. The demo video did not land for me.
Having a more practical video is a great call-out though, we should probably have a more deep dive video of an actual session!