xNAUT - AI-Powered Native Terminal

  ██╗  ██╗███╗   ██╗ █████╗ ██╗   ██╗████████╗
  ╚██╗██╔╝████╗  ██║██╔══██╗██║   ██║╚══██╔══╝
   ╚███╔╝ ██╔██╗ ██║███████║██║   ██║   ██║
   ██╔██╗ ██║╚██╗██║██╔══██║██║   ██║   ██║
  ██╔╝ ██╗██║ ╚████║██║  ██║╚██████╔╝   ██║
  ╚═╝  ╚═╝╚═╝  ╚═══╝╚═╝  ╚═╝ ╚═════╝    ╚═╝

A native terminal for working with a fleet of coding agents.

xnaut.dev · Download

Why xNAUT?

xNAUT is a native terminal and dev cockpit for running AI coding agents — with
your own subscription, not a per-seat markup. Built with Rust + Tauri v2,
it's a ~20MB native download and it actually feels fast.

Run any agent (Claude Code, Codex, Gemini, opencode…) in a terminal, split it
across parallel worktrees, or hand a task to the NautLoom Cloud Agent and
get a branch and a PR back. macOS & Windows.

Features

Terminal Core

• Multiple PTY sessions with tabs; split panes (up to 16 per tab)
• zsh / bash / fish auto-detection, full xterm.js (256-color + truecolor)
• Clickable URLs, shell integration (OSC 133) for prompt detection

Project Workspaces

• Every tab belongs to a project — selecting a project card shows only its tabs,
  with a shared Home workspace for global views
• Open any folder as a project (right-click → "Open as project", or ask the
  agent); drag a file/folder onto a terminal to insert its path
• Right-pane root picker switches the file tree between Home, project root, and
  the current project

AI Agents

• Agent Library + AgentFather — reusable agent profiles (personas, roles,
  skills, tools, access scopes, constraints, runtime model)
• Agent Runner — launch any coding CLI with a live status strip (working /
  done / blocked / waiting), hook-driven real-time state; click a pill to jump
  to its tab
• Provider-aware Agent Chat — switch agent + model independently across
  Anthropic, OpenAI, OpenRouter, LM Studio, and Ollama

NautLoom Cloud Agent

• Hand a task (or a ticket) to a self-hosted coding agent: Plan → sandbox →
  live stream → verify → ship (branch + PR) — it runs in an isolated GitVM
  microVM and pulls the code back before teardown.
• Powered by Loom, our open
  agent-deployment format: a Weave (*.loom.json) declares the sandbox, goal,
  acceptance checks, and report — a manifest for an agent run.

Observatory

• A command deck of every running agent (terminal + sandbox) — elapsed, model,
  status — with your plan's weekly budget on top and a PRs-to-review table

Multi-Agent Swarm

• A manager chat that validates your open tickets against the project manager
  and dispatches parallel agent runs — one isolated git worktree per run, capped
  by a max-parallel setting

Plan Mode

• Two-pane planning workspace from any PM project: chat (left) + a live
  PLAN.md (right), solution-architect persona, Edit/Preview toggle

Diff Viewer with AI Annotations

• Side-by-side / unified git diff HEAD for any worktree, with inline note
  cards read from <worktree>/.xnaut/notes.json
• HTTP broker so external agents (Claude Code, Codex, …) can add/apply/list
  annotations

Worktree Manager

• Create worktrees pre-wired for painless push (--no-track +
  push.autoSetupRemote=true) and launch any agent directly in the new tree

Project Management & NautFlow (optional)

• A local Git-backed control repo for projects, tickets, and workflow events
  (Forgejo or GitHub) — Kanban + table views, ticket details, Vault-document links
• NautFlow: stage workspaces, versioned Markdown artifacts, agent collaboration,
  review + promotion
• Parallel builds — a plan is split into slices, each in its own worktree and
  branch, with dependencies honoured: a slice waits until the work it needs has
  landed, then starts on its own
• Build log — every build writes one durable, append-only log with a level
  and source per event. Filter by level or slice, search it, tail it live, and
  reopen any earlier build; it is kept on disk, not held in memory
• Files view — what each slice changed, measured against the commit it forked
  from, with inline diffs. An agent that has already committed still shows its
  work, which a working-tree view would miss

Markdown Vault

• Wiki-linked work + personal vaults under ~/.xnaut-vault — note tree,
  tags, search, backlinks, wikilinks, templates
• Git-backed — the vault is a version-controlled repo synced to a private
  remote (Forgejo/GitHub), so your docs and the agents that write them share
  one source of truth; optional MinIO/NAS sync too
• A Vault Librarian chat that searches, reads, creates, moves, and tags notes
  through deterministic tool actions

More

• Forge review workspace — Forgejo/GitHub issues & PRs open inside xNAUT
  with agent-generated RCA
• Browser & Markdown panes — native webview / dependency-free Markdown
  (marked + highlight.js + Mermaid) beside your terminal
• Settings (Cmd+,), 50 bundled themes + AI theme generator, command
  snippets, file navigator + editor, SSH profiles, triggers, error monitor
• Work Session Logger — Merkle-proofed command log with HTML/PDF reports
  for billable hours
• Privacy Monitor — transparent LLM proxy that flags leaked keys /
  credentials / PII in prompts
• Auto-update — signed releases checked on startup, one-click update
• Cross-platform — macOS (Apple Silicon + Intel) and Windows (.msi / .exe)

Supported Agents

Works with any CLI agent — if it runs in a terminal, it runs in xNAUT. Bring
your own subscription (no per-seat markup) and drive any agent from the live
status strip and Agent Chat.

Built-in launch profiles ship for Claude Code, Codex, Gemini, Grok, and
opencode; add anything else in ~/.config/xnaut/agents.toml — 5 prompt-injection
strategies cover each CLI's quirks.

LLM providers for the built-in Agent Chat: Anthropic, OpenAI, OpenRouter,
plus local LM Studio and Ollama — configured in Settings → AI.

Getting Started

Install

Download the latest build from
Releases:

The macOS DMGs are Apple-notarized — open the DMG and drag xNAUT to
Applications; it launches cleanly with no Gatekeeper warning. New versions are
offered in-app via the auto-updater.

Build from source

Prerequisites

• Rust 1.70+ — rustup.rs
• macOS: xcode-select --install
• Linux: sudo apt install libwebkit2gtk-4.1-dev build-essential libssl-dev libgtk-3-dev

git clone https://github.com/48Nauts-Operator/xNaut.git
cd xNaut/src-tauri

# Development (with hot reload)
cargo tauri dev

# Release build
cargo tauri build

# Launch
open target/release/bundle/macos/xNAUT.app

Keyboard Shortcuts

All shortcuts are rebindable in Settings > Keyboard Shortcuts.

Architecture

Frontend (HTML/CSS/JS + xterm.js)
    |  Tauri IPC
Backend (Rust)
    ├── pty.rs          PTY sessions + directory tracking
    ├── worklog.rs      Session logging, Merkle proof, QR, reports
    ├── vault.rs        Markdown vault — index, search, git-synced docs
    ├── nautloom.rs     Cloud Agent runs, ship/PR, sandbox stats
    ├── sandbox.rs      GitVM microVM driver (create/exec/destroy)
    ├── ssh.rs          SSH connections
    ├── ai.rs           LLM provider integration
    ├── commands.rs     Tauri commands (file nav, editor, forge)
    ├── triggers.rs     Pattern matching & automation
    ├── state.rs        Thread-safe shared state
    └── main.rs         Native menu, updater, app setup

• Binary size: ~29MB (release, stripped); ~20MB DMG
• Memory per terminal: ~2MB
• PTY creation: <100ms
• IPC latency: Sub-millisecond

Deployment, code-signing, and notarization are documented in the
knowledge base (xNaut → Deployment).

CI/CD

xNAUT uses reusable GitHub Actions workflows from
48Nauts-Operator/ci-workflows:

• cargo fmt --check -- formatting
• cargo clippy -D warnings -- linting
• cargo test -- unit tests
• cargo audit -- security vulnerabilities

Releases are built and Apple-notarized by .github/workflows/release.yml on a
v* tag and staged in a draft release. After the downloaded installers pass
verification, the draft is published and the Homebrew update is dispatched with
update_homebrew_only=true on that tag. Every PR must pass all checks before merge.

Roadmap

• Module system -- loadable tool packs with community SDK
• Community Hub -- GitHub-based package registry for sharing scripts
• SecondBrain integration -- terminal long-term memory
• Privacy reports -- privacy-monitor data folded into work reports
• Linux support (AppImage, .deb)

License

Released under the MIT License — © 2026 André Wolke, 48Nauts. See
LICENSE for the full text. Free and open source, free forever.

Built with Rust, Tauri v2, and too much coffee.