Superlogical

I'm working this with https://boxes.dev - a workspace for launching and managing claude + codex sessions, each running in its own cloud devbox.

We launched with a desktop app but have gotten a lot of pull for terminal-driven workflows, so have a TUI as well. It's interesting - when the Codex desktop app launched I was so sure that GUI is the future for coding agents (it's just a chat!). But turns out there's no killing the CLI

[1] https://github.com/AltanS/collie

Overall I think I don't even want to start coding too much on the go with a setup like this but it's nice to have options :)

Its intended as a terminal agent orchestrator aimed at power users who want a little more design than what I like to call 'hackerman' UXes.

The first app in this space was VibeTunnel[1]. It basically lets you start terminals on your Mac and the web app allows you to control these terminals on your iPhone using Tailscale. In the end, it’s just terminals on the web with organization around it.

I forked VibeTunnel and turned it into a Next app and added workspaces with memory and turned it into a software factory which is making open-source alternatives for me while I sleep. I call it VibeGhost and will be launching it soon[2].

0. https://opensource.builders/alternatives/conductor

1. https://github.com/amantus-ai/vibetunnel

2. https://www.vibeghost.org

It does capture a provenance graph for any ad-hoc shell commands executed in the shell mode, or if prepended by `sci run`, by tracing all new files created from commands, and creating an accompanying json file for every output with metadata, which can later be assembled into a graph specific to any output file, using the `sci tohtml` or `sci toshell` commands (producing an HTML report with an SVG graph, or a reproducing shell script, respecively).

I'm quite bullish of the possibilities with this approach.

And, this was in fact also born out of the thinking to "rip apart" workflow tools, and build them up again using small, well-defined tools that do one thing well.

[1] https://github.com/samuell/scicommander

> We are building the multiplexer for all work.

imo this would have been a better way to do the HN submission title (with or without [terminal])

> Superlogical: We are building the [terminal] multiplexer for all work

Why? Because if you use SSH to connect to connect to GitHub, your SSH public key is published at https://github.com/<username>.keys so an SSH server to which you connect could do a reverse lookup.

This is the reason why my ~/.ssh/config has those 2 lines at the end:

    Host *
    PubkeyAuthentication no

But try also `TERM=dumb ssh superlogical.jobs` for an alternate, monochrome, experience.

Undocumented keys h,j,k,l also work to navigate the UI.

Any other easter eggs?

https://xkcd.com/927/

1. it will be incredible

2. it will be composable

3. it will be safe to use in production

I would totally invest millions into these guys, they have a bright future ahead.

Why reinvent the wheel?

/s

Are they the champions of collaboration or the champions of company culture?

And here we now have people saying stuff like this again.

Also, long live the "lifestyle business" if it means people just making businesses that bring in non-exponential but justifiable and sustainable income ... like, y'know, a business is supposed to. Good grief.

(This is not, in my mind, either a good or a bad thing.)

As a specific example of this, I've been using emacs since about 1997, but it's only this year that I've started down this sort of "integrate everything" road that it promises, because I've never wanted to learn emacs' specific Lisp variant that is used nowhere else. But now with AI I've done more emacs extensions that are providing real value to me than I have in the last... ever. About my previous limit was reifying a keyboard macro into a command, which still isn't really programming emacs.

The ability to indicate "intent" in a way that computers can actually process it as "intent" might change the calculus enough to make this more possible than it used to be in the past.

But those tradeoffs are real. Non-determinism is a problem. Difficulty in knowing what the AI is doing unless you're staring at its output, and even the ability to conceivably monitor an AI's output is only a transient thing we have at the moment, they'll speed up past our ability to monitor them at all soon enough. But it's at least a new area that can be explored and there may be solutions to some problems in there we couldn't reach before.

Hopefully that's not the endgame?

Why not meet people where they are at?

If this product isn't valuable, then it will fail. I suspect it will not fail.

I still regularly need to edit text files and use nvim for that. Sometimes I even use it to edit a prompt. I like to prompt my system by writing .md files to help get through the planning phase, and then I like to edit the generated todo list.

Visual Studio as the IDE for building windows client apps, especially WinForms, was and still is a genuinely incredible and productive experience. The ease of which you could click-and-drag a UI, context switch to logic in the code behind the forms, wire up a web service backend, share domain models and have navigation and search tools understand all of it was great. And the TFS integration was quite good too. You really only had to leave VS to do database work or administer some IIS pools.

Unfortunately, it couldn't keep up with the rest of the dev world. "Server Explorer" morphed to include your Azure VMs but froze for 30s each time you opened it. Docker tools came in super late, most Azure services didn't really have a VS tooling experience. The "right click publish" workflow meant for small systems never figured out how to graduate to real-world needs across many teams. Developers had to learn how to use many other tools for modern stuff, and so VS became far less of a center of gravity, often to their annoyance.

> so you can close the application, reconnect from another device, and pick up exactly where you left off.

I think this is the remote IDE development dream that no one could quite get right, partly because there wasn't enough reason to run things on a 24/7 device. I think with coding agents that can run in the background this changes.

> Sessions can be accessed through the web and native macOS/iOS applications, and sharing a live session with other people is built in from the start.

I'd really like to point out that "Sharing a live session" is horrible UX for a terminal multiplexer because the terminal has to be the same size (# of rows/cols) on all viewers' screens, and some of these viewers may be on a phone and others on a laptop. Believe it, I tried myself and there's no good way around the problem.

What is interesting is that they added this sentence anyway. This tells me that their long-term endgame is not the terminal. They're most likely trying to build a GUI-based agent IDE and then eventually expand to other work (per their headline of being the "multiplexer for all work") as it all gets more and more agent-based anyways. Well, they're not alone in having that vision.

Jetbrains is valued around $7bil and their business is almost exclusively in IDEs.

Wolfram Research is valued probably around $100mil and their business also mostly consists of an IDE product.

---

With AI, I think the future of IDEs will be very split. A lot less work will happen in IDEs (in terms of LOC), but at the same time, I think AI will allow for a more sophisticated build-out of IDEs, so e.g. debug experiences will become a lot richer.

JetBrains would disagree, as would I.

Nevertheless I agree this is the next _evolution_ in IDEs.

https://erock.prose.sh/posix-shell-is-all-you-need

Multiplexers have a lot of little papercuts and limitations when you want consistent and native-to-the-OS behavior to flow all the way between the OS and the apps and connections in the multiplexers. For example, gesture scrolling in a tmux/zellij pane is hard because the right events don't flow through. It's an itch to scratch like designing a good terminal lib (like ghostty.)

And then, there's all the unifying and smoothing out of data connections--I imagine they'll be a lot to make sure that, e.g., an ssh session or a Claude code session in a pane can be seamlessly reconnected or never drop when the pane is closed. This takes a lot of hacking to make look seamless in most setups right now.

Like mitchell, I write a lot of software around multiplexers, and I've thought about making something similar, but I don't have quite the same level of personal wealth or angel investor connections. :)

herdr and mosh are a couple of reference points for this, there are others.

I don't actually use a multiplexer. I'm not sure I understand the use case when most terminal emulators supports tabs + windows (like iTerm2 does). Or you could just launch multiple windows and use your OS's window manager to "multiplex". Are the terminals connected in some way that I'm missing?

Regardless, I think Ghostty is a reminder that you can win in a space that's crowded. There's probably a lot of widely used software that would get dropped en masse immediately if someone had the guts to make a better alternative.

I don't get the whole GPU rendering thing for ghostty either. Its a terminal emulator. It shows plain text. Why would I need GPU acceleration? I never felt "yeah, this terminal needs faster rendering".

Maybe I'm just an idiot

The other problem is it does have to be hosted somewhere, and if you run it locally, it goes away when you close your laptop. If you run it remotely, you have the latency to the remote site. I suspect Superlogical is going to find a way to fix this problem.

Yes, but good, standardized developer tooling is valuable.

Postman could’ve also been a “just use CURL and dump to JSON” for example.

I actually am bullish on this. Tmux and ssh are somewhat clunky and probably under utilized by most people. I struggle to find commands, navigate sessions, see history, and so on.

Also in an “agent” based world where you might ask an agent to execute things for you, how do you manage that context well beyond just giving it its own Tmux session to drive?

It’s a good idea, and I’m surprised no one’s built it sooner.

Also, interesting permission problems. Are you going to allow a remote server owned by someone else have shell access to all of your computers? Are they allowed to train an LLM from all the things you type?

What's your approach?

https://en.wikipedia.org/wiki/Tobias_L%C3%BCtke#Voting_right...

People probably had just as many uncreative ideas before, but lacked the ability to execute on them. Remember the "idea guys" constantly looking for tech cofounders to build their "brilliant" visions? Now, LLMs have given them the ability to execute.

As long as you are rich all the VCs will throw money at you.. fine.. but if you are rich then you don't have to take the VC money either. Just do it out of passion.

Ghostty is the client side aspect of this (the binary that actually runs on your laptop), but there will be a large backend system that the binary talks to through an API. With the API you can then also start automating sessions, for example when a metrics value trips an alert start an agent to triage with a session you can then attach to for further interrogation.

What Im not sure of is if they are going to build on top of kubernetes or not, which already provides a lot of the features necessary (etcd store, API server, workload orchestration, tenant isolation, extendable API).

(This is all speculation)

In other words, this probably won't directly involve changes to ghostty.

Ah, I see you have figured it out the thing that has always been the case.

- it demonstrates they have funding (pre-empting "no-one will fund something weird like this")

- its transparent and open (pre-empting "which bastards are the ones who really own it?")

Investors can be good for funding but they can also be good for education. Later, they're also very good for strategy.

> What happened to the good old way of figuring out product market fit first? Is that the only way a product can succeed nowadays

Generally it's very challenging. I have two products I'm building this way and you face a lot of up-hill climb where people with VC backing are getting the door opened for them. Of course, because of those same pressures to deliver and succeed, it's equally possible those same doors will eventually get closed on them.

I think Mitchell also lives in a bit of a bubble now. He went from friendly open source guy to very rich friendly open source guy. That's no knock on him, but I would consider viewing business from the perspective of someone who has been a CEO, CTO, and IC at the same company (his company) as his only job who became insanely wealthy as a result. I have a friend who has largely only worked in big tech, and successful startups, who tells me all the time level and salary don't matter to him. They don't matter to him because he found success early. Again, not a knock but sustained success will shape how you view the world and how you play the game.

Insert "It always was" meme

That was my question, too. Does Mitchell even need to take outside funding? I get why you would prefer to use others' poker chips instead of your own, especially if they're happy to give them to you, but usually funding comes with strings attached.

Something something "never spend your own money if you can spend someone else's money." That plus the perception of having those specific investors gives the idea/business fast authority/prestige.

It's not the gangster move, but it's a move.

Superlogical (allegedly) uses it for the multiplexer.

Mitchell Hashimoto is just the icing on the cake and he has a track record of building defining dev tools used by millions of devs.

So it makes sense why you see 15 angel investors.

More money / investment in the dev tool space is great for everyone!

He’s just looking at america post Citizens United and wishing he could ull the same shenans in Canada. It’s been working very well for the folks and orgs who can afford it

I think it’ll be fine