A year ago my terminal held one thing at a time: me, typing. Now it holds a crew. One agent is refactoring the auth module, another is chasing a flaky test, a third is reading through a spec I haven't finished writing. My job changed from doing the work to directing the ones doing it — and every tool on my machine was still built for the old job.

Terminals assume one human at a keyboard. Editors assume you're the one editing. None of them have an opinion about a Claude Code session and a Codex session running side by side, each on its own branch, each needing to be watched, diffed, and either merged or thrown away. So I kept gluing things together — a terminal, a git tool, a notes app, a diff viewer, six tmux panes — and the glue kept being the bottleneck.

I got tired of the glue. I built the thing the glue was pretending to be. It's called xNAUT.

What it actually is

A native desktop app — Tauri v2, Rust, not Electron — that weighs about 20 MB and runs local-first. That last part is load-bearing: it's an app that sits on your machine and, by default, never needs to send your work anywhere. It's MIT-licensed and free, no account to create, because a tool you run your whole workflow through shouldn't also be a tool that watches you do it.

The pitch is consolidation with a point of view: everything the agent-era workflow needs, in one native window, arranged for directing agents rather than for typing.

The parts I use every day

  • Agent runner. Launch Claude Code, Codex, Gemini — whatever CLI agent — with live status pills so you can see at a glance which of your crew is thinking, which is waiting on you, and which is done. Running five agents is only useful if you can tell them apart at a glance; that's the pill.
  • Worktree manager. Every agent gets its own git worktree from a modal, so parallel work happens on isolated branches instead of stepping on each other in one checkout. Isolation is what makes a fleet safe instead of chaotic.
  • Diff viewer with agent notes. Side-by-side diffs with the agent's own inline annotations about why it changed a thing. Reviewing an agent's work is the actual job now; this is where I spend the time, so it's where the app spends its polish.
  • Project workspaces. Per-project tabs, terminals, and sessions — so switching from one client's repo to another is one click, not a re-derivation of your whole environment.
  • The pane types that fill the gaps. A sandboxed browser, a markdown editor with Mermaid, a file tree, a code editor — the satellite tools you'd otherwise alt-tab to, living in the same window as the agents that need them.

The two features I didn't expect to lean on

Some of it I built speculatively and then couldn't stop using:

  • An integrated doc vault — Obsidian-style, with wikilinks and backlinks, plus a force-directed graph orb that shows how your notes and your code imports actually connect. The context you keep about a project turned out to belong right next to the project, not in a separate app.
  • An MCP server, so the agents can drive xNAUT back — read the project, file a ticket, update a doc — over localhost. The terminal stops being a thing you use at the agent and becomes a thing the agent can use with you.
Proof of Work

The one that surprises people: commands you run get chained into a SHA-256 Merkle tree, and you can export a QR-verifiable HTML report of what actually happened. In a world where a lot of "work" is now an agent's output, being able to hand someone a tamper-evident record of the steps — this ran, then this, in this order — turns out to matter. I didn't know I wanted a notary in my terminal until I had one.

Local-first, and it means it

xNAUT runs its own AI against Ollama or LM Studio by default — local models, on your box. When you do wire in a cloud key, there's a privacy guard that flags keys and PII before anything goes out. It's the same reflex as routing your agent's search through a box you own: the default should protect you, and reaching for the cloud should be a deliberate, visible act — not the silent baseline.

There's also a cloud agent for when you want a job to run off your machine — autonomously build, test, fix, and open a PR, solo or as a parallel swarm. And when it runs off your machine, it runs on the sovereign sandboxes from the last post: isolated, jurisdiction-pinned, disposable. The helm stays local; only the grunt work ships out, and only to a place you can point at on a map.

Why free, why MIT

Because the terminal is where I live, and I'm not going to live somewhere I don't control. Making it free and open-source isn't generosity — it's the same self-hosting instinct applied to the tool itself. A closed, account-gated cockpit for running agents would be one more vendor sitting between me and my work, which is the exact thing this whole series is about removing.

The public tagline for it is "ship with a crew of agents, keep the helm," and that's honestly the whole design in six words. The agents multiplied what I can build. This is the bridge I steer them from — and it fits, crew and all, in 20 MB.