Why I'm betting on Rex
developer-toolsterminalmultiplexerrexghosttyherdrtmuxai-agentsagentic-engineering
Verdict: A clear explainer of compositing versus mirroring, and a case for Rex that concedes the checklist losses and judges it as a multiplexer platform; the session-restore and pi-agency demos are the practical part.
TL;DR
- reemus (reemus_dev, Nov 2026) says comparing Rex with herdr or Orca is the wrong comparison. On a checklist Rex loses: no Linux or Windows app, not open source, invite only, no Git worktrees in the app, and agent sessions don't resume after a restart. reemus's reply is that Rex builds the multiplexer itself, while the others build agent workspaces that happen to need one.
- The technical core is compositing versus mirroring. tmux paints every pane into one screen of text, so it works in any terminal and over SSH, but it sits in the middle and breaks text selection, mouse input and newer features such as images. Rex's server sends each program's raw output to a smart client that runs a real terminal engine, libghostty, for every program. In exchange, you need the app on every screen, and on a slow connection every byte goes to every client.
- Mirroring isn't new (WezTerm in 2019, VS Code in 2021), and herdr shipped herdr-core and a desktop app within days of reemus getting Rex. reemus picks Rex for its focus: the multiplexer is the product, Mitchell Hashimoto calls Rex "more of a platform", and herdr-core already adopted OSC 7501, the agent-status protocol Rex published.
- The demo answers the top complaint: after a full server restart, reemus's setup uses the API to relaunch the agent and resume its session. reemus's pi-agency tool runs a Pi agent in a Rex block, waits for it to finish and captures the output.
- The closing section is speculation, and reemus says so: two block types in the API (terminal and onboarding) hint at non-terminal blocks, Ghostty going open source after its own closed beta suggests Rex will follow, and Rex could become "the tail scale for terminals".
Full summary
The wrong comparison
reemus opens by admitting to almost ignoring the Rex invite. All of reemus's workflows ran on herdr, and the appeal of Rex came partly from following Mitchell Hashimoto, who created Ghostty and is now part of Superlogical, the company making Rex. At face value Rex comes up short. A slide lists five rows where herdr and Orca get a tick and Rex a cross: Linux desktop app, Windows desktop app, open source, download with no invite, and Git worktrees in the app. The most common complaint reemus sees on Reddit and X is that Rex can't resume agent sessions after a restart. reemus's argument is that "Rex is trying to build a multiplexer and all these other tools are trying to build an agent management workspace that just so happened to need a multiplexer."
What a multiplexer is for
Normally a program lives inside the terminal app, so quitting Ghostty kills a running build or a log stream. A multiplexer moves programs into a server, a daemon in the background on your Mac or on another machine, so they keep running when the window closes and are still there when you connect from somewhere else. Tabs and splits are not the point; plenty of terminals have those.
What changed is agents. They are long-running programs like Neovim, a build or server logs, but they spawn sub-agents, which start programs of their own, and some need to read each other's output. The simplest way for one agent to see what another is doing is to read its terminal. So any tool that runs agents has to keep them alive, let you reach them, and let other programs drive them: start a program, read its screen, send it input, wait for it to finish. That is why herdr and Orca each have a multiplexer, and why reemus thinks the terminal space is filling up with agent workspaces.
Compositing and mirroring
tmux, Zellij and Rex all run a server. They differ in how output reaches the screen. tmux works out what every pane should look like and paints it all into one screen, borders and status bar included; the terminal thinks it is running one program, and the lines between panes are text characters. That is compositing, and reemus calls it genius for its time, because it works locally, over SSH and in any terminal.
The cost is a terminal running inside a terminal, with tmux as the middleman reinterpreting everything. reemus lists the familiar problems: selecting text across panes grabs the wrong lines, mouse clicks have to get through tmux first, and new features such as images have to pass through it too. A clip of Mitchell adds the speed argument: putting something in front of a fast terminal gives you "that slow experience in a fast terminal".
Mirroring keeps the background server but sends each program's output raw to a smart client. The app runs a real terminal engine for every program and mirrors the server; after a disconnect, the server brings it back up to date. Selecting text gets that program's text, and every device, Mac or phone, draws natively. The trade-offs are that you need the app on every screen, you can't SSH in from an old terminal and get this, and on a slow connection it is worse than tmux because every byte goes to every client. Mitchell says the same in a second clip: every client has to be a smart, compliant one, and the key is libghostty, Ghostty's terminal engine as a library. Ghostty carries on as a nonprofit, and Rex builds on that engine.
Why Rex, if the idea isn't new
reemus expected Rex's architecture to be the reason and found it wasn't unique. A timeline slide puts WezTerm (2019, a native client for a mux server) and VS Code (2021, a background process that keeps its terminals alive) before Rex's invite-only beta in October 2026, and herdr released herdr-core and a desktop app with the same approach within days of reemus downloading Rex.
The difference reemus sees is focus. Rex's website is about the multiplexer. herdr's site leads with "No two Herdrs look alike" and a gallery of community layouts; reemus says you can build an RPG game with your terminals on top. Orca's site presents an agent IDE with the file manager and browser built in. reemus has nothing against those, but cares about managing terminal programs in a way that is scriptable, automatable and extendable. Mitchell's post on X says Rex is "less AI-focused, less opinionated, more of a platform" and that tools like cmux and herdr are more likely partners; herdr-core has already adopted OSC 7501, the protocol Rex published for agent status. reemus expects Superlogical to repeat Ghostty's model, building the engine others build on, with layers of terminal engine (Ghostty), then multiplexer (Rex), then everything else.
Primitives over features
reemus has always cared about good primitives, and reads Rex's focus on one as a sign of stability, while the agent IDEs and herdr still seem to be working out what they are. With agent harnesses, reemus liked Grok Bot's simplicity but worried about customising it the way Hermes Agent allows, with plugins, skills, a dashboard and themes. Then: "Why do I actually care?" Grok Bot's agents can use anything reemus builds, whether MCP servers, APIs, CLIs or scripts. Rex is the same: its CLI, API and Lua can run, send to, capture and wait on a browser driven by Playwright CLI, a file tree in yazi, scripts or agents, so none of it needs to live inside the multiplexer.
reemus also finds the beta polished, with a few bugs and what feels like a new release every day; a Discord feed of release notes is on screen. reemus calls the docs and API well designed and says most complaints are easy to solve with them, to the point that you could ask an agent such as Claude to build the fix from the Rex docs.
The demo
On screen, an X post says its author went back to herdr because Rex's Claude sessions don't survive reboots, next to Rex's four verbs: start (rex run), read (rex capture), send (rex send), wait (rex wait). reemus quits the Rex app and reopens it with nothing lost, because only the client closed. Then reemus stops the server and relaunches everything, and the agent that was running in the terminal comes back too. The API lets a script tie agent session IDs to where they ran, so on startup it sends the right resume command.
The second demo is pi-agency, reemus's CLI that lets any harness run a Pi agent and collect its answer. It was a heavy herdr workflow, and moving it to Rex felt natural. It opens a block in a Rex session (a block is Rex's word for a pane), waits for the program to finish and captures its output.
Hints and bets
reemus dislikes Rex's names (sessions, windows and blocks where others say workspaces, windows or tabs, and panes) but finds a clue in the API: blocks have two types, terminal and onboarding. Why design it that way unless more types are coming? On screen, Mitchell's post says charging for a multiplexer is not the business, it's about "what this leads to (non-terminals)". reemus calls it a hunch that Rex becomes a customisable workspace.
On the closed beta, reemus would be scared too, but points to Ghostty, which also had a long closed beta before it went open source. A slide reads "Rex is and will always be free." reemus closes with Tailscale: subnet routers existed before but were never that effortless, and Tailscale stacked primitives until complex setups felt simple. Use whatever works for you, reemus says, but reemus is betting on the people who focus on the primitive.
Key moments
- [00:00] Rex is misunderstood โ reemus almost ignored the invite and argues the herdr and Orca comparisons miss the point. hook_frames
- [00:26] The checklist โ Rex gets five crosses next to herdr and Orca: no Linux or Windows app, closed source, invite only, no worktrees. frame_0002.jpg
- [01:36] What a multiplexer is โ programs move into a background server and survive closing the window. frame_0006.jpg
- [02:15] Why agents need one โ agents spawn programs that others must read and drive. frame_0007.jpg
- [03:46] Compositing โ tmux paints all panes into one screen of text, so it works anywhere. frame_0010.jpg
- [04:31] The middleman problem โ text selection, mouse input and speed suffer. frame_0012.jpg
- [05:16] Mirroring โ raw output per program to a smart client running libghostty. frame_0014.jpg
- [06:44] Not a new idea โ WezTerm, VS Code, Rex and herdr-core on one timeline. frame_0017.jpg
- [07:50] Rex as a platform โ Mitchell's "more of a platform" post and herdr-core adopting OSC 7501. frame_0020.jpg
- [12:12] Demo โ server restart with the agent resumed, then pi-agency waiting on a block and capturing its output. frame_0029.jpg, frame_0032.jpg
Hook microscope (0-10s)
-
Frames: 20 at 2 fps
Read these hook frames with the Read tool:
hook_frames/frame_0001.jpg(t=0.0s)hook_frames/frame_0002.jpg(t=0.5s)hook_frames/frame_0003.jpg(t=1.0s)hook_frames/frame_0004.jpg(t=1.5s)hook_frames/frame_0005.jpg(t=2.0s)hook_frames/frame_0006.jpg(t=2.5s)hook_frames/frame_0007.jpg(t=3.0s)hook_frames/frame_0008.jpg(t=3.5s)hook_frames/frame_0009.jpg(t=4.0s)hook_frames/frame_0010.jpg(t=4.5s)hook_frames/frame_0011.jpg(t=5.0s)hook_frames/frame_0012.jpg(t=5.5s)hook_frames/frame_0013.jpg(t=6.0s)hook_frames/frame_0014.jpg(t=6.5s)hook_frames/frame_0015.jpg(t=7.0s)hook_frames/frame_0016.jpg(t=7.5s)hook_frames/frame_0017.jpg(t=8.0s)hook_frames/frame_0018.jpg(t=8.5s)hook_frames/frame_0019.jpg(t=9.0s)hook_frames/frame_0020.jpg(t=9.5s)
-
Word-level transcript (35 words):
[ 0.07s] I'm
[ 0.21s] absolutely
[ 0.93s] in
[ 1.07s] love
[ 1.46s] with
[ 1.63s] Rex,
[ 2.00s] the
[ 2.08s] new
[ 2.24s] multiplexer
[ 2.84s] from
[ 3.05s] Superlogical.
[ 4.18s] The
[ 4.26s] interesting
[ 4.31s] thing,
[ 4.62s] though,
[ 5.04s] is
[ 5.07s] just
[ 5.25s] how
[ 5.38s] misunderstood
[ 6.00s] it
[ 6.18s] is.
[ 7.16s] And
[ 7.16s] to
[ 7.16s] be
[ 7.24s] honest,
[ 7.68s] I
[ 7.75s] fell
[ 8.03s] for
[ 8.24s] the
[ 8.45s] exact
[ 8.80s] same
[ 9.08s] trap
[ 9.36s] when
[ 9.63s] that
[ 10.00s] in
- 0.0s: The Rex logo with a BETA badge sits next to a Rex window where Claude Code runs sub-agents in split blocks, on "I'm absolutely in love with Rex".
- by 3.0s: The subtitle "The new multiplexer, from Superlogical" appears under the logo as the line is said.
- by 6.0s: Cut to a wall of other videos about Rex (Rex versus herdr, Orca versus Rex, "ghostty killer?!") and two X replies asking how Rex differs from herdr, on "how misunderstood it is".
- by 7.5s: Zoom into the "ghostty killer?!" thumbnail, on "I fell for the exact same trap".
- by 9.5s: The thumbnail dims under "It's built on Ghostty!?".
Pattern: a declaration of love, then a contrarian claim (everyone misunderstands it) backed by showing the misunderstanding in other creators' thumbnails, and a confession that reemus made the same mistake.
Editorial profile
No scene-change data โ likely a static/screen-recorded source.
Narrated motion-graphics essay: voiceover over dark animated diagrams with a fixed colour per program (build green, logs blue, shell amber, Rex purple), cut with Rex screen recordings, website captures, X posts and two short clips of Mitchell Hashimoto. The narrator is not on camera in any sampled frame. The run recorded no scene-change data, so there is no cut rate.
Quotable moments
- [00:51] "Rex is trying to build a multiplexer and all these other tools are trying to build an agent management workspace that just so happened to need a multiplexer"
- [02:06] "It's not about tabs or splits fundamentally."
- [04:34] "you're actually running a terminal inside your terminal, and T-mux is acting like the middleman"
- [14:08] "it just so happens that a great agent workspace actually needs a great multiplexer"
- [17:08] "If you want to play Age of Empires with your terminals on top, I mean, feel free."
Entities mentioned
- People: reemus, mitchell-hashimoto
- Companies: Superlogical, Tailscale
- Tools / products: rex, herdr, herdr-core, Orca, tmux, Zellij, Ghostty, libghostty, WezTerm, VS Code, cmux, Claude Code, Pi, pi-agency, Hermes Agent, Grok Bot, Playwright CLI, yazi, Neovim, OSC 7501
Concepts surfaced
- compositing-vs-mirroring: tmux paints all panes into one screen of text that any terminal can show; Rex sends each program's raw output to a smart client that runs a terminal engine per program.
- Multiplexer as the primitive: the layer that starts, reads, drives and waits on terminal programs; agent workspaces are things built on top of it.
- The wrong comparison: judging Rex on agent-workspace features (worktrees, layouts, session resume), when the product is the multiplexer and its API.
- Build outside the tool: when agents can call your CLIs, APIs and scripts, the harness or multiplexer doesn't need to be customisable itself.
- Closed beta, then open source: Ghostty's path, offered as the precedent for Rex.
- agent-native-multiplexer: reemus's view that a great agent workspace needs a great multiplexer first.
Frame timeline
What's said while each frame is on screen.
[00:00]

I'm absolutely in love with Rex, the new multiplexer from Superlogical. The interesting thing though is just how misunderstood it is. And to be honest, I fell for the exact same trap. And that invite link came through. I almost put it aside and didn't think about it because I was already so into my herder setup and I built all my workflows around it. But to be honest, something was just calling to me. I think a part of that just comes from following Mitchell Hashimoto,...
[00:52]

wrong. The big difference is that Rex is trying to build a multiplexer and all these other tools are trying to build an agent management workspace that just so happened to need a multiplexer. They're not actually focused on the multiplexer. But the important thing is I came to realize just how critical the multiplexer is. You see, I believe Rex is probably going to revolutionize how we work with the terminal and manage terminal programs the same way perhaps Tailscale has...
[01:18]

want to make the case as to why I think this is likely to happen. And if you're looking for stability in your workflows, especially in a world where everything is changing so rapidly now with agents and AI, Rex might just be the one to bet on. I believe it's probably going to set the standard for everything to come in the terminal and multiplexer space. And it's something that's probably more important than most of us actually realizing. So what is the multiplexer? You've...
[02:10]

job. It's not about tabs or splits fundamentally. Plenty of terminals have those. The interesting thing now though is just how important these kind of multiplexer programs are becoming. You see, we've always had long-running programs, things like Neovim, a build, or logs coming in from a server, and staying connected to those has always mattered. But what's changed now is agents. Agents are also long-running programs too, but they don't stop at one. They actually spawn new...
[03:02]

comes in. And this is why Herder has one, this is why Orca has one, and at the same time this is why the whole terminal space is really exploding right now with all these different applications that seem to be agent management workspaces or terminal related utilities. See, the multiplexer is what gives us the tools to run and manage these actual processes within the terminal. It gives us the APIs to allow us to start these programs and check in on them. You start a program,...
[03:28]

a program, you read its screen, send it input, wait for it to finish. This is all things that a multiplexer helps us with, and everything else gets built on that. And agents are really just one kind of program. Every multiplexer has the server, right? Tmux, Zellij, Rex, they all have a server. Where they differ is how everything those programs print actually get to your screen. With Tmux, it takes the output of every program and works out what each pane should look like and...
[04:20]

time, and back then the design and architecture of T-mux was great in that it worked in any terminal. It could be on the other end of a server, and overall it was a design that fit the situation and the times it was built in. But the constraints have changed now. See the problem with T-mux is what you're doing is you're actually running a terminal inside your terminal, and T-mux is acting like the middleman. It has to reinterpret everything and process it all correctly, and...
[05:12]

you're just you're sort of like getting that slow experience in a fast terminal, um which sucks. >> And it all comes down to this middleman problem. So now we know what compositing is, but really what's the other way and what's Rex doing differently than the ever popular T-mux is Zsh? Well the other way is mirroring. You don't actually paint one screen at all. Instead you still have this background processor server that actually runs your programs and keeps them...
[06:04]

apps all looking at the same program. The The is that you need that app on every screen. You can't SSH into it from an old terminal and get all of this. And on a slow connection, it's actually worse than tmux because every byte goes to every client and Mitchell says this himself as well. >> It does require that every connecting client be a very smart, high-functioning uh compliant client. And uh the key to that is libghostty. Runs everywhere, um has no dependencies,...
[06:30]

that is libghostty. Runs everywhere, um has no dependencies, it's lightweight, it's fast. >> For Rex, what actually makes this work on every device is libghostty. And Ghostty's terminal engine is a library. And Ghostty carries on as a nonprofit. And Rex has essentially built its entire engine and everything on top of it. So going into this, my gut feeling was that Rex actually had a fundamentally better architecture and everything else was fundamentally inferior. But...
[07:22]

what everyone's building and what they're focused at. If you look at the Rex website, you can see it's completely clear. They're focused on building the multiplexer. On the other hand, if you look at Hurdler's website, the first thing they say is no two Hurdlers look alike. I mean, look at the gallery. You can basically build an RPG game and have your terminals on top of it. And if you go to Orca's site, you can see it's all about the agent IDE. It's all about having all...
[08:14]

everything composable and making it safe and operable in production. If I quote Mitchell, you'll see he says less AI focused, less opinionated, more for platform. We're not trying to compete with people like C-Max or Herder or similar. They're more likely probable partners. And I think this is the most interesting thing. They just want to solve the multiplexer problem. And maybe there's a future in which all these other tools actually make use of Rex underneath in order to...
[08:40]

problem effectively. And it's already started. Herder Co adopted OSC 7501, the protocol Rex published for agent status. And I think what Mitchell and Superlogical are going to do is they're going to do similar to what Ghosty did where they build the engine and then ultimately everyone else builds on top of it. So if you look at it in terms of layers, you have the layer where the actual terminal programs run, the actual terminal engine which is Ghosty, and then what comes...
[09:32]

love terminals and we love terminal programs. And really what's the foundation for all of this? It is the multiplexer. And if you get the multiplexer right, then everything else becomes easy and comes after that properly. And the fact that they're focused on this as the primitive gives me that sense that there's going to be stability. It's not going to be a tool that's constantly out there trying to find its place in the world cuz it feels like with all these other tools...
[10:24]

workspaces. And it's not to say that those are bad. They definitely have their place and they're good, but all these things can be done without actually using those tools. You can still script your browser and control it and have your agents work with it using things like Playwright CLI. You've got all these other tools for things like seeing file trees in the terminal. I think an interesting analogy to sort of draw from a similar situation that I had was I was looking at...
[10:50]

like the simplicity of Grok Bot a lot, but I just worried that I wouldn't be able to customize it the way I might be able to customize something like Hermes. But that's when it sort of hit me. Why do I actually care? The agents in Grok Bot can interact with anything I build. I don't need to be building directly into the actual harness or tool like Hermes. I could just be building things separately and these agents can interact with them. So why do I really care? And I sort...
[11:42]

though it's focused on the primitives and the fundamentals, is actually a beautiful and really well done app. And even though it's in its beta, it honestly feels incredibly polished. It's not to say that it doesn't have a few bugs or a few little niggly issues, but if you look at their release space and cadence, it feels like there's almost a new release every single day with something improving. Now to show you why I think Rex is so good beyond just talking about how they...
[12:34]

honestly, you could easily ask any agent even Claude to just build this for you and have a look at the Rex docs, and they'll figure it out pretty quickly. So, let me give you an actual demo. I quit the Rex app, but you see if I reopen it, nothing is actually lost cuz I've just closed the client. The server is actually running in the background. But if I stop the server and then I relaunch everything again, you'll see that in my case everything actually restores itself...
[13:26]

called pi-agency, a CLI tool, and it allows any other harness to run a Pi agent and collect its response. This was something I used a lot in Herder, and moving that from Herder to Rex felt extremely natural like Rex was actually built for it. If you have a look when I run Pi agency, you'll see that it opens up a block in a particular session, and a block is what Rex calls a pain effectively or particular terminal tab if you want to call it that. And with Rex's APIs, it's...
[13:52]

the program that you just spawned running on that particular block to actually complete and then capture its output. So, you can see from all this that when you compare Rex to things like Herder, you're actually making the wrong comparison. You can use Rex as a agent workspace of course just like use Herder, but the difference is that Rex is built as a multiplexer, and it just so happens that a great agent workspace actually needs a great multiplexer. When you have the...
[14:44]

blocks right now. There is the terminal block and there's the onboarding block. Now, why would you actually design your API like this unless you intended on having additional types of blocks? If you think about that, something else is coming, and I don't know exactly what it is. What could the other types of blocks be and what could you actually put within them? I'm not sure, but it feel like that gives me some sense that they know this is ultimately going to become some...
[15:36]

closed beta and it wasn't open sourced. And it had a lengthy period like that, and eventually it was open sourced. So at least you have some track record and you can see that it's the exact same pattern just happening again. Is it guaranteed to happen? No, but I would say there's a pretty good chance. If you read the Rex website and you see Mitchell Hashimoto and the way he works, I'm almost certain that the core aspect of all of this will be open sourced in time. To wrap...
[16:02]

how I think Rex is actually going to be the tail scale for terminals, and I think that's the best way to look at it because what did tail scale do? It really focused on the underlying primitives that surrounded networking in many ways. For example, you could always have a subnet router in the past, but it was never that effortless. With tail scale, they were able to stack these primitives on top of each other and then ultimately make all these amazing complex things that we...
[16:55]

change at any moment or that haven't even found exactly where they're going. Whereas you can see with Rex, the actual vision is clear. It's all about the multiplexer. For me as a developer, I care about terminals and terminal programs and I want to bet on the thing that's focused on that and everything else can be built on top of it. If you want to play Age of Empires with your terminals on top, I mean, feel free. You can obviously do that and build it into Hurder if you...
Transcript
Source: captions.
[00:02] I'm absolutely in love with Rex, the new multiplexer from Superlogical. The
[00:04] multiplexer from Superlogical. The interesting thing though is just how
[00:05] interesting thing though is just how misunderstood it is. And to be honest, I
[00:08] misunderstood it is. And to be honest, I fell for the exact same trap. And that
[00:10] fell for the exact same trap. And that invite link came through. I almost put
[00:12] invite link came through. I almost put it aside and didn't think about it
[00:13] it aside and didn't think about it because I was already so into my herder
[00:15] because I was already so into my herder setup and I built all my workflows
[00:17] setup and I built all my workflows around it. But to be honest, something
[00:19] around it. But to be honest, something was just calling to me. I think a part
[00:21] was just calling to me. I think a part of that just comes from following
[00:22] of that just comes from following Mitchell Hashimoto, which is the creator
[00:23] Mitchell Hashimoto, which is the creator of Ghostty and now part of Superlogical,
[00:26] of Ghostty and now part of Superlogical, which is making Rex. I thought to
[00:27] which is making Rex. I thought to myself, there has to be something else
[00:29] myself, there has to be something else over here. And after doing a bit of
[00:31] over here. And after doing a bit of digging, I came to realize you actually
[00:33] digging, I came to realize you actually can't compare Rex to any of these other
[00:35] can't compare Rex to any of these other tools. If you compare it at face value,
[00:37] tools. If you compare it at face value, it feels like Rex comes up short against
[00:39] it feels like Rex comes up short against these other tools. The most common
[00:41] these other tools. The most common complaint I see on Reddit or X is that
[00:43] complaint I see on Reddit or X is that it can't even automatically resume your
[00:45] it can't even automatically resume your agent sessions when you restart it. You
[00:46] agent sessions when you restart it. You see though, I think this comparison is
[00:48] see though, I think this comparison is wrong. The big difference is that Rex is
[00:51] wrong. The big difference is that Rex is trying to build a multiplexer and all
[00:53] trying to build a multiplexer and all these other tools are trying to build an
[00:55] these other tools are trying to build an agent management workspace that just so
[00:57] agent management workspace that just so happened to need a multiplexer. They're
[00:58] happened to need a multiplexer. They're not actually focused on the multiplexer.
[01:01] not actually focused on the multiplexer. But the important thing is I came to
[01:02] But the important thing is I came to realize just how critical the
[01:04] realize just how critical the multiplexer is. You see, I believe Rex
[01:06] multiplexer is. You see, I believe Rex is probably going to revolutionize how
[01:08] is probably going to revolutionize how we work with the terminal and manage
[01:10] we work with the terminal and manage terminal programs the same way perhaps
[01:13] terminal programs the same way perhaps Tailscale has done for networking. I
[01:15] Tailscale has done for networking. I want to make the case as to why I think
[01:16] want to make the case as to why I think this is likely to happen. And if you're
[01:18] this is likely to happen. And if you're looking for stability in your workflows,
[01:21] looking for stability in your workflows, especially in a world where everything
[01:22] especially in a world where everything is changing so rapidly now with agents
[01:24] is changing so rapidly now with agents and AI,
[01:26] and AI, Rex might just be the one to bet on. I
[01:27] Rex might just be the one to bet on. I believe it's probably going to set the
[01:29] believe it's probably going to set the standard for everything to come in the
[01:30] standard for everything to come in the terminal and multiplexer space. And it's
[01:32] terminal and multiplexer space. And it's something that's probably more important
[01:34] something that's probably more important than most of us actually realizing. So
[01:36] than most of us actually realizing. So what is the multiplexer? You've probably
[01:38] what is the multiplexer? You've probably all heard the word and the first thing
[01:39] all heard the word and the first thing that comes to mind would be something
[01:40] that comes to mind would be something like tmux. You see, normally your
[01:42] like tmux. You see, normally your programs live inside your terminal, the
[01:44] programs live inside your terminal, the app you're looking at. If you quit
[01:46] app you're looking at. If you quit Ghostty in the middle of a build or when
[01:47] Ghostty in the middle of a build or when you're streaming some logs, that process
[01:49] you're streaming some logs, that process is gone and dead. A multiplexer moves
[01:52] is gone and dead. A multiplexer moves them out of the actual terminal
[01:53] them out of the actual terminal application. It keeps your program
[01:55] application. It keeps your program running in a server in the background,
[01:57] running in a server in the background, essentially a daemon managing it. So it
[01:59] essentially a daemon managing it. So it continues running even when close the
[02:00] continues running even when close the window and you reopen it up again.
[02:02] window and you reopen it up again. If you connect from somewhere else,
[02:04] If you connect from somewhere else, everything is still there. So that's the
[02:06] everything is still there. So that's the job. It's not about tabs or splits
[02:08] job. It's not about tabs or splits fundamentally. Plenty of terminals have
[02:10] fundamentally. Plenty of terminals have those. The interesting thing now though
[02:11] those. The interesting thing now though is just how important these kind of
[02:13] is just how important these kind of multiplexer programs are becoming.
[02:15] multiplexer programs are becoming. You see, we've always had long-running
[02:17] You see, we've always had long-running programs, things like Neovim, a build,
[02:19] programs, things like Neovim, a build, or logs coming in from a server, and
[02:21] or logs coming in from a server, and staying connected to those has always
[02:23] staying connected to those has always mattered. But what's changed now is
[02:25] mattered. But what's changed now is agents. Agents are also long-running
[02:27] agents. Agents are also long-running programs too, but they don't stop at
[02:30] programs too, but they don't stop at one. They actually spawn new versions of
[02:32] one. They actually spawn new versions of themselves. Those sub-agents start their
[02:34] themselves. Those sub-agents start their own programs. So you've got these
[02:36] own programs. So you've got these terminal programs that are now spawning
[02:37] terminal programs that are now spawning terminal programs and they can all be
[02:39] terminal programs and they can all be pretty long-running things.
[02:41] pretty long-running things. And some of them also need to read the
[02:43] And some of them also need to read the outputs of others. If you want an agent
[02:45] outputs of others. If you want an agent to see what another agent is doing, the
[02:47] to see what another agent is doing, the easiest way is to just read the actual
[02:49] easiest way is to just read the actual output in the terminal.
[02:50] output in the terminal. So now any tool that runs agents has to
[02:53] So now any tool that runs agents has to keep them alive and let you reach them
[02:55] keep them alive and let you reach them and let other programs drive them. And
[02:57] and let other programs drive them. And that's really where the multiplexer
[02:58] that's really where the multiplexer comes in. And this is why Herder has
[03:00] comes in. And this is why Herder has one, this is why Orca has one, and at
[03:02] one, this is why Orca has one, and at the same time this is why the whole
[03:04] the same time this is why the whole terminal space is really exploding right
[03:06] terminal space is really exploding right now with all these different
[03:06] now with all these different applications that seem to be agent
[03:09] applications that seem to be agent management workspaces or terminal
[03:11] management workspaces or terminal related utilities.
[03:12] related utilities. See, the multiplexer is what gives us
[03:14] See, the multiplexer is what gives us the tools to run and manage these actual
[03:17] the tools to run and manage these actual processes within the terminal. It gives
[03:20] processes within the terminal. It gives us the APIs to allow us to start these
[03:23] us the APIs to allow us to start these programs and check in on them. You start
[03:25] programs and check in on them. You start a program, you read its screen, send it
[03:27] a program, you read its screen, send it input, wait for it to finish. This is
[03:29] input, wait for it to finish. This is all things that a multiplexer helps us
[03:31] all things that a multiplexer helps us with, and everything else gets built on
[03:33] with, and everything else gets built on that.
[03:34] that. And agents are really just one kind of
[03:36] And agents are really just one kind of program. Every multiplexer has the
[03:38] program. Every multiplexer has the server, right? Tmux, Zellij, Rex, they
[03:40] server, right? Tmux, Zellij, Rex, they all have a server. Where they differ is
[03:43] all have a server. Where they differ is how everything those programs print
[03:45] how everything those programs print actually get to your screen. With Tmux,
[03:47] actually get to your screen. With Tmux, it takes the output of every program and
[03:49] it takes the output of every program and works out what each pane should look
[03:51] works out what each pane should look like and paints it all into one screen,
[03:53] like and paints it all into one screen, borders, status bars included. Your
[03:56] borders, status bars included. Your terminal has no idea there are panes.
[03:58] terminal has no idea there are panes. It's running one program as far as it's
[04:00] It's running one program as far as it's concerned, just Tmux. Those lines
[04:02] concerned, just Tmux. Those lines between your panes are just text
[04:04] between your panes are just text characters. Now that's called
[04:05] characters. Now that's called compositing, and in many ways it's
[04:07] compositing, and in many ways it's genius. It's genius because it works
[04:09] genius. It's genius because it works everywhere, locally, over SSH in the
[04:12] everywhere, locally, over SSH in the terminal, and this is why T-mux is so
[04:14] terminal, and this is why T-mux is so popular.
[04:15] popular. But you see T-mux came from a different
[04:16] But you see T-mux came from a different time, and back then the design and
[04:18] time, and back then the design and architecture of T-mux was great in that
[04:21] architecture of T-mux was great in that it worked in any terminal. It could be
[04:22] it worked in any terminal. It could be on the other end of a server, and
[04:25] on the other end of a server, and overall it was a design that fit the
[04:27] overall it was a design that fit the situation and the times it was built in.
[04:29] situation and the times it was built in. But the constraints have changed now.
[04:31] But the constraints have changed now. See the problem with T-mux is what
[04:32] See the problem with T-mux is what you're doing is you're actually running
[04:34] you're doing is you're actually running a terminal inside your terminal, and
[04:36] a terminal inside your terminal, and T-mux is acting like the middleman.
[04:38] T-mux is acting like the middleman. It has to reinterpret everything and
[04:40] It has to reinterpret everything and process it all correctly, and this is
[04:42] process it all correctly, and this is where all the finickiness comes in. I'm
[04:44] where all the finickiness comes in. I'm sure everyone has felt the pain of all
[04:45] sure everyone has felt the pain of all these little niggly things when you deal
[04:47] these little niggly things when you deal with T-mux. You try to select some text
[04:49] with T-mux. You try to select some text and you actually get the wrong
[04:50] and you actually get the wrong selection. You try to click on a
[04:52] selection. You try to click on a terminal program that expects mouse
[04:54] terminal program that expects mouse input and it just doesn't quite work
[04:55] input and it just doesn't quite work properly. And more than that now you
[04:58] properly. And more than that now you have all these new terminal features
[04:59] have all these new terminal features coming in, things like image support. If
[05:01] coming in, things like image support. If you look at what Mitchell says, he makes
[05:03] you look at what Mitchell says, he makes the speed argument as well.
[05:05] the speed argument as well. >> When you put something in front of it,
[05:06] >> When you put something in front of it, you're just you're sort of like getting
[05:09] you're just you're sort of like getting that slow experience in a fast terminal,
[05:12] that slow experience in a fast terminal, um which sucks.
[05:14] um which sucks. >> And it all comes down to this middleman
[05:15] >> And it all comes down to this middleman problem. So now we know what compositing
[05:17] problem. So now we know what compositing is, but really what's the other way and
[05:19] is, but really what's the other way and what's Rex doing differently than the
[05:21] what's Rex doing differently than the ever popular T-mux is Zsh? Well the
[05:24] ever popular T-mux is Zsh? Well the other way is mirroring.
[05:25] other way is mirroring. You don't actually paint one screen at
[05:27] You don't actually paint one screen at all. Instead you still have this
[05:29] all. Instead you still have this background processor server that
[05:30] background processor server that actually runs your programs and keeps
[05:32] actually runs your programs and keeps them alive, but the difference is that
[05:34] them alive, but the difference is that you send the output of each program raw,
[05:37] you send the output of each program raw, untouched to the actual app you're
[05:38] untouched to the actual app you're looking at, a smart client effectively.
[05:40] looking at, a smart client effectively. The app runs a real terminal engine for
[05:42] The app runs a real terminal engine for every program. The app just mirrors the
[05:44] every program. The app just mirrors the server. If it disconnects, the server
[05:46] server. If it disconnects, the server simply gets it back up to speed when it
[05:48] simply gets it back up to speed when it reconnects, and that's called mirroring.
[05:50] reconnects, and that's called mirroring. There's no middleman reinterpreting
[05:52] There's no middleman reinterpreting anything. When you select text in
[05:53] anything. When you select text in another program, you get that program's
[05:56] another program, you get that program's text. Every device draws it natively,
[05:59] text. Every device draws it natively, your Mac, your phone, each with its own
[06:01] your Mac, your phone, each with its own apps all looking at the same program.
[06:03] apps all looking at the same program. The The is that you need that app on
[06:05] The The is that you need that app on every screen. You can't SSH into it from
[06:07] every screen. You can't SSH into it from an old terminal and get all of this.
[06:09] an old terminal and get all of this. And on a slow connection, it's actually
[06:11] And on a slow connection, it's actually worse than tmux because every byte goes
[06:13] worse than tmux because every byte goes to every client and Mitchell says this
[06:15] to every client and Mitchell says this himself as well.
[06:16] himself as well. >> It does require that every connecting
[06:18] >> It does require that every connecting client be a very smart, high-functioning
[06:23] client be a very smart, high-functioning uh compliant client. And uh the key to
[06:26] uh compliant client. And uh the key to that is libghostty. Runs everywhere, um
[06:29] that is libghostty. Runs everywhere, um has no dependencies, it's lightweight,
[06:31] has no dependencies, it's lightweight, it's fast.
[06:32] it's fast. >> For Rex, what actually makes this work
[06:34] >> For Rex, what actually makes this work on every device is libghostty. And
[06:36] on every device is libghostty. And Ghostty's terminal engine is a library.
[06:38] Ghostty's terminal engine is a library. And Ghostty carries on as a nonprofit.
[06:40] And Ghostty carries on as a nonprofit. And Rex has essentially built its entire
[06:42] And Rex has essentially built its entire engine and everything on top of it. So
[06:44] engine and everything on top of it. So going into this, my gut feeling was that
[06:46] going into this, my gut feeling was that Rex actually had a fundamentally better
[06:47] Rex actually had a fundamentally better architecture and everything else was
[06:49] architecture and everything else was fundamentally inferior. But the truth is
[06:52] fundamentally inferior. But the truth is that it's not even a new idea. In fact,
[06:54] that it's not even a new idea. In fact, WezTerm was actually one of the more
[06:55] WezTerm was actually one of the more popular terminals that had a similar
[06:58] popular terminals that had a similar concept. But what's interesting though
[07:00] concept. But what's interesting though is that within a few days of actually
[07:01] is that within a few days of actually downloading Rex, as it turns out,
[07:04] downloading Rex, as it turns out, Hurdler even released Hurdler Core as
[07:06] Hurdler even released Hurdler Core as well as the desktop app. And they now
[07:07] well as the desktop app. And they now also follow the same pattern and
[07:09] also follow the same pattern and approach. So it's not unique to Rex and
[07:11] approach. So it's not unique to Rex and I think there's others in the space that
[07:12] I think there's others in the space that are also doing the same thing. So in
[07:15] are also doing the same thing. So in that case, why Rex? I think for me, the
[07:17] that case, why Rex? I think for me, the fundamental thing is if you just look at
[07:19] fundamental thing is if you just look at what everyone's building and what
[07:20] what everyone's building and what they're focused at. If you look at the
[07:22] they're focused at. If you look at the Rex website, you can see it's completely
[07:24] Rex website, you can see it's completely clear. They're focused on building the
[07:26] clear. They're focused on building the multiplexer. On the other hand, if you
[07:28] multiplexer. On the other hand, if you look at Hurdler's website, the first
[07:30] look at Hurdler's website, the first thing they say is no two Hurdlers look
[07:32] thing they say is no two Hurdlers look alike. I mean, look at the gallery. You
[07:34] alike. I mean, look at the gallery. You can basically build an RPG game and have
[07:36] can basically build an RPG game and have your terminals on top of it. And if you
[07:37] your terminals on top of it. And if you go to Orca's site, you can see it's all
[07:39] go to Orca's site, you can see it's all about the agent IDE. It's all about
[07:41] about the agent IDE. It's all about having all those other tools built right
[07:43] having all those other tools built right in, like your file manager or your
[07:45] in, like your file manager or your browser. And I'm not saying all these
[07:46] browser. And I'm not saying all these things aren't cool and I totally dig it
[07:48] things aren't cool and I totally dig it and there's nothing wrong with any of
[07:50] and there's nothing wrong with any of it. But I think the key thing is that
[07:52] it. But I think the key thing is that for Rex, the multiplexer is their
[07:54] for Rex, the multiplexer is their product and it's what they're focused
[07:55] product and it's what they're focused on. And what I care about personally is
[07:59] on. And what I care about personally is about how I interact with the terminal
[08:00] about how I interact with the terminal and manage my terminal programs and
[08:03] and manage my terminal programs and actually do so in a way that's
[08:04] actually do so in a way that's scriptable and automatable and
[08:05] scriptable and automatable and extendable.
[08:07] extendable. It's all about building an incredible
[08:08] It's all about building an incredible multiplexers, they called it, and making
[08:10] multiplexers, they called it, and making everything composable and making it safe
[08:12] everything composable and making it safe and operable in production. If I quote
[08:15] and operable in production. If I quote Mitchell, you'll see he says less AI
[08:17] Mitchell, you'll see he says less AI focused, less opinionated, more for
[08:19] focused, less opinionated, more for platform. We're not trying to compete
[08:21] platform. We're not trying to compete with people like C-Max or Herder or
[08:22] with people like C-Max or Herder or similar. They're more likely probable
[08:24] similar. They're more likely probable partners. And I think this is the most
[08:26] partners. And I think this is the most interesting thing. They just want to
[08:28] interesting thing. They just want to solve the multiplexer problem. And maybe
[08:31] solve the multiplexer problem. And maybe there's a future in which all these
[08:32] there's a future in which all these other tools actually make use of Rex
[08:35] other tools actually make use of Rex underneath in order to solve this
[08:36] underneath in order to solve this problem effectively. And it's already
[08:38] problem effectively. And it's already started. Herder Co adopted OSC 7501, the
[08:42] started. Herder Co adopted OSC 7501, the protocol Rex published for agent status.
[08:44] protocol Rex published for agent status. And I think what Mitchell and
[08:45] And I think what Mitchell and Superlogical are going to do is they're
[08:47] Superlogical are going to do is they're going to do similar to what Ghosty did
[08:48] going to do similar to what Ghosty did where they build the engine and then
[08:51] where they build the engine and then ultimately everyone else builds on top
[08:52] ultimately everyone else builds on top of it. So if you look at it in terms of
[08:54] of it. So if you look at it in terms of layers, you have the layer where the
[08:56] layers, you have the layer where the actual terminal programs run, the actual
[08:58] actual terminal programs run, the actual terminal engine which is Ghosty, and
[09:00] terminal engine which is Ghosty, and then what comes after that? You have the
[09:02] then what comes after that? You have the manager of all these terminal programs.
[09:05] manager of all these terminal programs. And that's where the multiplexer is. So
[09:06] And that's where the multiplexer is. So Ghosty is the first layer and then Rex
[09:08] Ghosty is the first layer and then Rex is the thing that comes after it. See,
[09:10] is the thing that comes after it. See, as a developer, one of the things I've
[09:11] as a developer, one of the things I've always felt strongly about is building
[09:13] always felt strongly about is building good primitives. When you build a good
[09:15] good primitives. When you build a good primitive, you can build anything else
[09:16] primitive, you can build anything else correctly on top of it. And that's
[09:18] correctly on top of it. And that's really why I love Rex. I can see that
[09:21] really why I love Rex. I can see that they're focused on the multiplexers
[09:22] they're focused on the multiplexers being the primitive for everything to
[09:24] being the primitive for everything to come. We as developers, we love agents.
[09:27] come. We as developers, we love agents. Well, at least I love agents. And we
[09:29] Well, at least I love agents. And we love terminals and we love terminal
[09:30] love terminals and we love terminal programs. And really what's the
[09:32] programs. And really what's the foundation for all of this? It is the
[09:34] foundation for all of this? It is the multiplexer. And if you get the
[09:36] multiplexer. And if you get the multiplexer right, then everything else
[09:38] multiplexer right, then everything else becomes easy and comes after that
[09:39] becomes easy and comes after that properly. And the fact that they're
[09:41] properly. And the fact that they're focused on this as the primitive gives
[09:43] focused on this as the primitive gives me that sense that there's going to be
[09:45] me that sense that there's going to be stability. It's not going to be a tool
[09:47] stability. It's not going to be a tool that's constantly out there trying to
[09:49] that's constantly out there trying to find its place in the world cuz it feels
[09:51] find its place in the world cuz it feels like with all these other tools like
[09:53] like with all these other tools like so-called agent IDEs or Herder and
[09:56] so-called agent IDEs or Herder and everything else, it feels like they're
[09:58] everything else, it feels like they're still trying to find out exactly what
[09:59] still trying to find out exactly what their identity is, what space they sit
[10:01] their identity is, what space they sit in. And the multiplexer just comes as a
[10:03] in. And the multiplexer just comes as a byproduct of all these things underlying
[10:05] byproduct of all these things underlying what they're trying to do. But with Rex
[10:07] what they're trying to do. But with Rex at least you can tell as I said, it's
[10:08] at least you can tell as I said, it's the primitive and it's what they're
[10:10] the primitive and it's what they're focused on building. I mean, I honestly
[10:11] focused on building. I mean, I honestly don't care if I can build an RPG game
[10:14] don't care if I can build an RPG game and have my terminals on top of it. And
[10:16] and have my terminals on top of it. And I'm not the biggest fan either of having
[10:18] I'm not the biggest fan either of having all these sort of integrated agent ID
[10:20] all these sort of integrated agent ID workspaces. And it's not to say that
[10:22] workspaces. And it's not to say that those are bad. They definitely have
[10:23] those are bad. They definitely have their place and they're good, but all
[10:25] their place and they're good, but all these things can be done without
[10:26] these things can be done without actually using those tools. You can
[10:29] actually using those tools. You can still script your browser and control it
[10:31] still script your browser and control it and have your agents work with it using
[10:32] and have your agents work with it using things like Playwright CLI. You've got
[10:34] things like Playwright CLI. You've got all these other tools for things like
[10:36] all these other tools for things like seeing file trees in the terminal. I
[10:38] seeing file trees in the terminal. I think an interesting analogy to sort of
[10:39] think an interesting analogy to sort of draw from a similar situation that I had
[10:42] draw from a similar situation that I had was I was looking at Grok Bot a bit and
[10:44] was I was looking at Grok Bot a bit and I was looking at Hermes, which I've used
[10:45] I was looking at Hermes, which I've used and dabbled with here and there. And I
[10:47] and dabbled with here and there. And I like the simplicity of Grok Bot a lot,
[10:49] like the simplicity of Grok Bot a lot, but I just worried that I wouldn't be
[10:51] but I just worried that I wouldn't be able to customize it the way I might be
[10:53] able to customize it the way I might be able to customize something like Hermes.
[10:55] able to customize something like Hermes. But that's when it sort of hit me. Why
[10:57] But that's when it sort of hit me. Why do I actually care? The agents in Grok
[10:59] do I actually care? The agents in Grok Bot can interact with anything I build.
[11:01] Bot can interact with anything I build. I don't need to be building directly
[11:03] I don't need to be building directly into the actual harness or tool like
[11:05] into the actual harness or tool like Hermes. I could just be building things
[11:07] Hermes. I could just be building things separately and these agents can interact
[11:09] separately and these agents can interact with them. So why do I really care? And
[11:12] with them. So why do I really care? And I sort of started thinking about Rex
[11:13] I sort of started thinking about Rex from that same perspective as well is,
[11:15] from that same perspective as well is, you know, it's nice to have a tool like
[11:16] you know, it's nice to have a tool like Herder where I can build whatever I want
[11:18] Herder where I can build whatever I want into it. But why? You could just do that
[11:21] into it. But why? You could just do that outside of the tool. So what actually
[11:24] outside of the tool. So what actually matters is that the fundamentals behind
[11:26] matters is that the fundamentals behind it are there and interactable and
[11:29] it are there and interactable and automatable and scriptable and it's done
[11:30] automatable and scriptable and it's done correctly, right? It doesn't need to be
[11:33] correctly, right? It doesn't need to be done within a tool that allows you to
[11:35] done within a tool that allows you to build whatever you want to build into
[11:36] build whatever you want to build into it. Now the nice thing is that Rex, even
[11:38] it. Now the nice thing is that Rex, even though it's focused on the primitives
[11:40] though it's focused on the primitives and the fundamentals, is actually a
[11:42] and the fundamentals, is actually a beautiful and really well done app. And
[11:44] beautiful and really well done app. And even though it's in its beta, it
[11:45] even though it's in its beta, it honestly feels incredibly polished. It's
[11:47] honestly feels incredibly polished. It's not to say that it doesn't have a few
[11:49] not to say that it doesn't have a few bugs or a few little niggly issues, but
[11:51] bugs or a few little niggly issues, but if you look at their release space and
[11:52] if you look at their release space and cadence, it feels like there's almost a
[11:54] cadence, it feels like there's almost a new release every single day with
[11:56] new release every single day with something improving. Now to show you why
[11:58] something improving. Now to show you why I think Rex is so good beyond just
[11:59] I think Rex is so good beyond just talking about how they focused on the
[12:01] talking about how they focused on the fundamentals is if you just have a look
[12:03] fundamentals is if you just have a look at their docs, you have a look at their
[12:04] at their docs, you have a look at their APIs, you can see that it's just
[12:06] APIs, you can see that it's just incredibly well designed and well
[12:07] incredibly well designed and well thought off. And a lot of what people
[12:09] thought off. And a lot of what people are complaining about can actually be
[12:11] are complaining about can actually be achieved so simply. So I've explained a
[12:13] achieved so simply. So I've explained a lot about the primitives, but let me
[12:14] lot about the primitives, but let me actually show you from a firsthand
[12:16] actually show you from a firsthand perspective just how powerful they are.
[12:17] perspective just how powerful they are. Consider the most common complaint to do
[12:19] Consider the most common complaint to do with session restoration and resuming
[12:21] with session restoration and resuming agents once you actually close the
[12:22] agents once you actually close the server and reopen.
[12:24] server and reopen. This is actually something that can be
[12:25] This is actually something that can be done really easily. I know other tools
[12:27] done really easily. I know other tools like Herder might have it built in, and
[12:29] like Herder might have it built in, and I'm sure there's a time that's going to
[12:30] I'm sure there's a time that's going to come where Rex will do the same. But
[12:32] come where Rex will do the same. But honestly, you could easily ask any agent
[12:34] honestly, you could easily ask any agent even Claude to just build this for you
[12:35] even Claude to just build this for you and have a look at the Rex docs, and
[12:37] and have a look at the Rex docs, and they'll figure it out pretty quickly.
[12:38] they'll figure it out pretty quickly. So, let me give you an actual demo.
[12:40] So, let me give you an actual demo. I quit the Rex app, but you see if I
[12:42] I quit the Rex app, but you see if I reopen it, nothing is actually lost cuz
[12:44] reopen it, nothing is actually lost cuz I've just closed the client. The server
[12:46] I've just closed the client. The server is actually running in the background.
[12:48] is actually running in the background. But if I stop the server and then I
[12:50] But if I stop the server and then I relaunch everything again, you'll see
[12:52] relaunch everything again, you'll see that in my case everything actually
[12:53] that in my case everything actually restores itself including the agent I
[12:55] restores itself including the agent I had running in the terminal. And because
[12:57] had running in the terminal. And because of the APIs, you're able to actually
[12:59] of the APIs, you're able to actually correlate whatever agent session IDs you
[13:02] correlate whatever agent session IDs you have and where it was actually running
[13:04] have and where it was actually running so that when the server starts again,
[13:06] so that when the server starts again, you know that you had a running session
[13:07] you know that you had a running session previously and then you can just send
[13:10] previously and then you can just send the correct command to resume that
[13:11] the correct command to resume that session and carry it right back on. And
[13:14] session and carry it right back on. And let me show you one other really cool
[13:15] let me show you one other really cool thing that worked out so well, which is
[13:17] thing that worked out so well, which is my Pi coding harness and how I use it
[13:19] my Pi coding harness and how I use it programmatically. You see I have a tool
[13:22] programmatically. You see I have a tool called pi-agency, a CLI tool, and it
[13:24] called pi-agency, a CLI tool, and it allows any other harness to run a Pi
[13:27] allows any other harness to run a Pi agent and collect its response.
[13:29] agent and collect its response. This was something I used a lot in
[13:30] This was something I used a lot in Herder, and moving that from Herder to
[13:32] Herder, and moving that from Herder to Rex felt extremely natural like Rex was
[13:35] Rex felt extremely natural like Rex was actually built for it. If you have a
[13:37] actually built for it. If you have a look when I run Pi agency, you'll see
[13:39] look when I run Pi agency, you'll see that it opens up a block in a particular
[13:40] that it opens up a block in a particular session, and a block is what Rex calls a
[13:43] session, and a block is what Rex calls a pain effectively or particular terminal
[13:45] pain effectively or particular terminal tab if you want to call it that. And
[13:46] tab if you want to call it that. And with Rex's APIs, it's easy to wait for
[13:49] with Rex's APIs, it's easy to wait for the program that you just spawned
[13:50] the program that you just spawned running on that particular block to
[13:52] running on that particular block to actually complete and then capture its
[13:54] actually complete and then capture its output. So, you can see from all this
[13:55] output. So, you can see from all this that
[13:56] that when you compare Rex to things like
[13:58] when you compare Rex to things like Herder, you're actually making the wrong
[13:59] Herder, you're actually making the wrong comparison. You can use Rex as a agent
[14:02] comparison. You can use Rex as a agent workspace of course just like use
[14:04] workspace of course just like use Herder, but the difference is that Rex
[14:06] Herder, but the difference is that Rex is built as a multiplexer, and it just
[14:08] is built as a multiplexer, and it just so happens that a great agent workspace
[14:10] so happens that a great agent workspace actually needs a great multiplexer. When
[14:12] actually needs a great multiplexer. When you have the great multiplexer under the
[14:14] you have the great multiplexer under the hood, all these things become really
[14:16] hood, all these things become really easy to do. There is one very
[14:17] easy to do. There is one very interesting thing I noticed as well with
[14:19] interesting thing I noticed as well with Rex, which is actually their concept of
[14:21] Rex, which is actually their concept of blocks.
[14:22] blocks. I'm not necessarily the biggest fan of
[14:23] I'm not necessarily the biggest fan of their naming and what they've called
[14:25] their naming and what they've called sessions and windows and blocks.
[14:27] sessions and windows and blocks. Typically, you might call them, for
[14:28] Typically, you might call them, for example, workspaces, windows, or tabs,
[14:31] example, workspaces, windows, or tabs, and panes, but it's just how they've
[14:33] and panes, but it's just how they've decided to name it. But the interesting
[14:35] decided to name it. But the interesting thing about the blocks part is if we
[14:36] thing about the blocks part is if we actually look at the API output, you'll
[14:39] actually look at the API output, you'll see that there's actually two types of
[14:40] see that there's actually two types of blocks right now. There is the terminal
[14:42] blocks right now. There is the terminal block and there's the onboarding block.
[14:44] block and there's the onboarding block. Now, why would you actually design your
[14:46] Now, why would you actually design your API like this unless you intended on
[14:48] API like this unless you intended on having additional types of blocks?
[14:50] having additional types of blocks? If you think about that, something else
[14:52] If you think about that, something else is coming, and I don't know exactly what
[14:54] is coming, and I don't know exactly what it is. What could the other types of
[14:55] it is. What could the other types of blocks be and what could you actually
[14:57] blocks be and what could you actually put within them? I'm not sure, but it
[15:00] put within them? I'm not sure, but it feel like that gives me some sense that
[15:03] feel like that gives me some sense that they know this is ultimately going to
[15:04] they know this is ultimately going to become some kind of customizable
[15:06] become some kind of customizable workspace of some kind. It's just a
[15:08] workspace of some kind. It's just a hunch, but I have a good feeling it's
[15:10] hunch, but I have a good feeling it's probably going to go in that direction
[15:11] probably going to go in that direction somehow. So right now, Rex is in a
[15:13] somehow. So right now, Rex is in a closed beta. It's not open source at the
[15:15] closed beta. It's not open source at the moment, and I know this scares a lot of
[15:17] moment, and I know this scares a lot of people off as well. And to be honest, I
[15:18] people off as well. And to be honest, I would be scared of it too. But I'm not
[15:20] would be scared of it too. But I'm not too worried because if you look at the
[15:22] too worried because if you look at the patterns of the past, at least with
[15:23] patterns of the past, at least with Mitchell Hashimoto and the way he ran
[15:25] Mitchell Hashimoto and the way he ran Ghosty and built Ghosty out, you'll see
[15:28] Ghosty and built Ghosty out, you'll see that Ghosty also started the exact same
[15:30] that Ghosty also started the exact same way. It was also a closed program with a
[15:32] way. It was also a closed program with a closed beta and it wasn't open sourced.
[15:35] closed beta and it wasn't open sourced. And it had a lengthy period like that,
[15:37] And it had a lengthy period like that, and eventually it was open sourced. So
[15:39] and eventually it was open sourced. So at least you have some track record and
[15:41] at least you have some track record and you can see that it's the exact same
[15:43] you can see that it's the exact same pattern just happening again. Is it
[15:45] pattern just happening again. Is it guaranteed to happen? No, but
[15:48] guaranteed to happen? No, but I would say there's a pretty good
[15:49] I would say there's a pretty good chance. If you read the Rex website and
[15:51] chance. If you read the Rex website and you see Mitchell Hashimoto and the way
[15:52] you see Mitchell Hashimoto and the way he works, I'm almost certain that the
[15:55] he works, I'm almost certain that the core aspect of all of this will be open
[15:57] core aspect of all of this will be open sourced in time. To wrap up, I want to
[15:58] sourced in time. To wrap up, I want to come back to what I said before about
[16:00] come back to what I said before about how I think Rex is actually going to be
[16:02] how I think Rex is actually going to be the tail scale for terminals, and I
[16:03] the tail scale for terminals, and I think that's the best way to look at it
[16:05] think that's the best way to look at it because what did tail scale do? It
[16:07] because what did tail scale do? It really focused on the underlying
[16:09] really focused on the underlying primitives that surrounded networking in
[16:11] primitives that surrounded networking in many ways.
[16:13] many ways. For example, you could always have a
[16:14] For example, you could always have a subnet router in the past, but it was
[16:16] subnet router in the past, but it was never that effortless.
[16:18] never that effortless. With tail scale, they were able to stack
[16:19] With tail scale, they were able to stack these primitives on top of each other
[16:21] these primitives on top of each other and then ultimately make all these
[16:22] and then ultimately make all these amazing complex things that we now take
[16:24] amazing complex things that we now take for granted and see as so simple. And I
[16:26] for granted and see as so simple. And I think Rex is essentially doing the exact
[16:28] think Rex is essentially doing the exact same thing. They're so focused on the
[16:29] same thing. They're so focused on the underlying primitives that once you get
[16:31] underlying primitives that once you get the primitives down pat and you get that
[16:33] the primitives down pat and you get that correct, then everything else can come
[16:35] correct, then everything else can come on top of that easily and effortlessly.
[16:37] on top of that easily and effortlessly. At the end of the day, which should you
[16:38] At the end of the day, which should you use? I mean, use whatever makes you
[16:40] use? I mean, use whatever makes you happy and use whatever you feel works
[16:42] happy and use whatever you feel works best for you, obviously. But for me, I
[16:45] best for you, obviously. But for me, I want to take a bet on the people who
[16:47] want to take a bet on the people who focus on the underlying primitives. I
[16:49] focus on the underlying primitives. I don't want to use tools that could
[16:51] don't want to use tools that could change at any moment or that haven't
[16:53] change at any moment or that haven't even found exactly where they're going.
[16:55] even found exactly where they're going. Whereas you can see with Rex, the actual
[16:56] Whereas you can see with Rex, the actual vision is clear. It's all about the
[16:58] vision is clear. It's all about the multiplexer. For me as a developer, I
[17:00] multiplexer. For me as a developer, I care about terminals and terminal
[17:02] care about terminals and terminal programs and I want to bet on the thing
[17:04] programs and I want to bet on the thing that's focused on that and everything
[17:06] that's focused on that and everything else can be built on top of it. If you
[17:08] else can be built on top of it. If you want to play Age of Empires with your
[17:09] want to play Age of Empires with your terminals on top, I mean, feel free. You
[17:11] terminals on top, I mean, feel free. You can obviously do that and build it into
[17:13] can obviously do that and build it into Hurder if you want. For me, if I want to
[17:15] Hurder if you want. For me, if I want to do that, I'm just going to have Age of
[17:16] do that, I'm just going to have Age of Empires open separately and be using the
[17:18] Empires open separately and be using the best terminal and terminal multiplexer
[17:20] best terminal and terminal multiplexer on top of that.
All frames
Total: 40. Hero frames flagged with star.
frames/frame_0001.jpg(t=00:00)frames/frame_0002.jpg(t=00:26)frames/frame_0003.jpg(t=00:52)frames/frame_0004.jpg(t=01:18)frames/frame_0005.jpg(t=01:44)frames/frame_0006.jpg(t=02:10)frames/frame_0007.jpg(t=02:36)frames/frame_0008.jpg(t=03:02)frames/frame_0009.jpg(t=03:28)frames/frame_0010.jpg(t=03:54)frames/frame_0011.jpg(t=04:20)frames/frame_0012.jpg(t=04:46)frames/frame_0013.jpg(t=05:12)frames/frame_0014.jpg(t=05:38)frames/frame_0015.jpg(t=06:04)frames/frame_0016.jpg(t=06:30)frames/frame_0017.jpg(t=06:56)frames/frame_0018.jpg(t=07:22)frames/frame_0019.jpg(t=07:48)frames/frame_0020.jpg(t=08:14)frames/frame_0021.jpg(t=08:41)frames/frame_0022.jpg(t=09:07)frames/frame_0023.jpg(t=09:33)frames/frame_0024.jpg(t=09:59)frames/frame_0025.jpg(t=10:25)frames/frame_0026.jpg(t=10:51)frames/frame_0027.jpg(t=11:17)frames/frame_0028.jpg(t=11:43)frames/frame_0029.jpg(t=12:09)frames/frame_0030.jpg(t=12:35)frames/frame_0031.jpg(t=13:01)frames/frame_0032.jpg(t=13:27)frames/frame_0033.jpg(t=13:53)frames/frame_0034.jpg(t=14:19)frames/frame_0035.jpg(t=14:45)frames/frame_0036.jpg(t=15:11)frames/frame_0037.jpg(t=15:37)frames/frame_0038.jpg(t=16:03)frames/frame_0039.jpg(t=16:29)frames/frame_0040.jpg(t=16:55)