Long reads from the
workshop on gmux.

Open a terminal today and the question isn't "which file should I edit?" It's "which of my ten agents is waiting for me to say yes, and which one is quietly burning my API budget on the wrong thing?"

tmux is wonderful. It can hold all ten of them. But every pane looks the same. Black background. Spinner. Maybe a prompt. You alt-tab through them like checking on a row of kettles, hoping you catch the one that boiled over before it spills.

gmux is the traffic light layer on top of tmux. A coloured dot per agent, updated live. Green when it's working. Honey when it's waiting for you. Clay when it's asking permission to do something risky. You glance, you know, you move on.

Not screen-scraping. Live API.

Most "agent monitors" you've seen just pattern-match the terminal output: looking for a spinner character, a prompt symbol, the word "error". It works most of the time and breaks the rest.

gmux reads state from the agent's own HTTP API. OpenCode and qalcode2 already expose one per session. Server-sent events stream the status the moment it changes — no polling lag, no false positives. When an agent goes from working to needs permission, the dot changes within the same second the prompt appears in its pane.

What you actually do differently.

With the traffic light in front of you, a few small habits shift. You stop alt-tabbing. You stop wondering whether the silent pane is thinking or hung. You start treating the row of dots as a single signal: is anything red? If no, you keep writing. If yes, one keystroke takes you to the agent that needs you, and one gesture sends you back.

The promise is small: you should never have to ask a terminal "what are you doing?" again.

Everything else in gmux — the gestures, the voice, the phone, the memory layer — is built on top of this one observation. Once you can see the fleet, every other interaction stops being a guess.

The first version of gmux was one big process that did everything: tmux orchestration, hand tracking, voice transcription, phone bridge. When any one piece misbehaved, the whole thing went down, and so did the work happening in the terminals it was supposed to be helping with.

That was the wrong shape. gmux now sits in three layers that fail independently. Anything you care about lives in the bottom one; everything else can crash without you noticing.

Why we picked Tauri, not Electron.

The desktop app is a Tauri build. Five-megabyte binary, native WebView, real PTY through a tiny Rust shim, no Node runtime shipped to your laptop. It opens in under a second on the kind of mid-spec Linux box that AI coding actually happens on, and it doesn't squat 400 MB of RAM just to render a window.

The tradeoff: WebKit on Linux doesn't have every API a Chromium build would. So voice runs through a separate Python sidecar instead of the Web Speech API, which turned out to be a win — local Whisper is more accurate, works offline, and doesn't make a network call every time you say something.

Why the camera goes through a broker.

The hardest bug in the early builds was simple: open gmux, your video call breaks. The webcam is exclusive on Linux — one process owns it at a time. So gmux runs an ffmpeg broker as a background service. Real camera goes in one end, a virtual camera (via v4l2loopback) comes out the other. Anyone can read from the virtual device simultaneously: gmux, Brave, OBS, Zoom.

The same broker means the camera-on light goes on once when you log in and stays on, which is honestly the most polite thing it can do.

A good architecture isn't the one where everything works. It's the one where you can tell exactly what broke.

Most of the design notes for gmux read like that quote in different costumes. The terminal layer doesn't know the desktop layer exists. The desktop layer doesn't depend on the phone. Each one publishes its state, each one subscribes to what it needs, and none of them care if the others come and go.

Hand-tracking demos look great in a thirty-second clip and feel terrible after thirty minutes. Your arm gets tired. The gesture you used to scroll is the same one you used to wave at your colleague, and now the page is at the bottom. By the end of the afternoon you'd rather use the keyboard.

The cure isn't more gestures. It's a small vocabulary that splits between two hands so that accidental motions on one side never trigger an action on the other. Your dominant hand navigates. Your other hand issues commands. Move with the right, decide with the left.

The passive mode that saved everything.

Gestures only fire when you're being deliberate. When you're typing — the most common state — gmux runs in a high-threshold passive mode. Swipes are blocked, gentle motions ignored. Hold an open palm steady for 1.5 seconds and it switches into active mode, where every gesture is live.

It sounds small. In practice it's the single feature that took the system from annoying after fifteen minutes to quietly running for hours.

Voice, when the keyboard is a long way away.

Voice and gesture are partners, not alternatives. Stand at a projector across the room and there's no keyboard to reach for. You'd rather just say "approve it" or "next red" or "claude, write the test for that".

A wake word — kalarc by default, configurable — opens the channel. Transcription happens on-device with faster-whisper, about 400ms end-to-end. Anything that looks like a navigation command goes to tmux: "next window", "split", "previous". Anything else gets typed into whichever agent is focused.

A voice command is just a faster way of doing what your fingers were going to do anyway.

A specific feeling: you've kicked off three long agent runs before leaving the house. Halfway to the café one of them hits a permission prompt — "can I install this package?" — and just sits there. The other two finished an hour ago. You don't know any of this because you're not at your desk.

The fix isn't a cloud product. It's that the desktop you've already paid for has every piece of information you need; you just can't see it from outside the house. gmux turns your own machine into the back-end and your phone into the dashboard.

Not a cloud account. Your own URL.

The phone UI is just a web page that your desktop serves. No login. No third-party service. On a home network it's reachable directly; over the open internet, gmux is happy to live behind Tailscale or a Cloudflare Tunnel — same data, same UI, encrypted end-to-end without any of the secrets leaving your machine.

If your laptop is off, the dashboard is off. That's the right tradeoff. Nothing about your agents, your code, your conversations sits on someone else's server waiting to be subpoenaed or leaked.

The carousel sorts by who needs you.

Open the PWA and the agents are ordered by urgency: anything asking for permission first, then anything waiting on you, then the ones still working, then the ones already finished. The top of the list is always where your attention should land. Scroll down only if you're curious.

The phone isn't a smaller terminal. It's a smaller, calmer view of the one you already have.

Most days the worst part of working with coding agents is the re-explanation. You spent forty minutes yesterday talking your agent through the architecture, the conventions, why you rejected the obvious approach. Today you open a fresh pane and it's all gone. The agent grep-searches blindly through the same files, proposes the same first solution you already vetoed, and reaches the wrong conclusion in a slightly different way.

gmux-brain is the memory layer that fixes this. It's not one new database — it's a router that combines three kinds of memory that already exist, and hands them to every agent pane as inline context the moment it starts.

One endpoint. The agent doesn't need to know how it works.

The agents in each pane connect to a single MCP endpoint called brain_query. Ask it a question and a small router decides which layer to consult. Keywords like "what calls" or "god nodes" route to the structural graph. "Why did we" or "when was" route to episodic memory. "What's the other pane doing" hits the live workspace. Ambiguous questions get all three.

No new database, no new LLM. The routing is plain keyword matching — fast, free, and easy to debug when it gets something wrong.

Six hundred tokens, automatic.

When a pane opens on a project, gmux-brain assembles a context block of about 600 tokens and hands it to the agent before the first message: a one-page summary from the code graph, the most relevant decisions from past sessions, and a snapshot of what the rest of the workspace is doing.

The agent doesn't ask for it. The user doesn't write it. It's just there, the same way a new teammate gets a handover doc instead of a blank page.

Without gmux-brain, an agent starts with zero tokens of context. With it, every agent starts as if it had been there last week.

Every few months someone proposes replacing tmux. Rust rewrite. New protocol. Modern terminal. Every one of those projects spends two years rebuilding a fraction of what tmux already does well, and the migration cost is borne by people who didn't ask for any of it.

gmux refuses to be that. tmux is the foundation. Your existing config file is honoured. Your prefix key is whatever you set it to. Your status bar, your keybindings, your tmux-resurrect setup, your .tmux.conf tweaks from 2019 — none of it changes.

What we deliberately didn't build.

• A new terminal emulator. xterm.js renders the panes inside the desktop app; tmux still does the work below it.
• A cloud account. Your data, your machine. Tailscale or a tunnel if you want it remote.
• A custom model. Bring your own — Claude, GPT, Gemini, DeepSeek, local Ollama. gmux watches them; it doesn't replace them.
• Glasses, headsets, or VR. Webcam gestures and a microphone are enough for the next twelve months. AR glasses come later, when the hardware stops being awkward.
• An IDE. If you want one, your editor is one tmux pane away. gmux doesn't have opinions about it.

What's actually shipped versus what's still being built.

Honest about state: the status bar, the sidebar, the gesture engine, the voice daemon, the phone PWA, the session restore, the camera broker — all working. The Tauri desktop wrapper that ties them into a single window is the piece we're polishing now. The installer comes after that, because packaging something that doesn't run cleanly is premature.

If you want to follow along, the email signup on the homepage will tell you when each milestone lands. We've capped the early access invites so the first round of users gets real attention rather than a Discord channel and a shrug.

Calm is a design choice. It's not the absence of features — it's the discipline to add only the ones that don't ask for your attention.