DOXA is a Rust terminal workspace for coding agents. Run Claude, Codex, DeepSeek, or GLM in tabs and split panes, then close the terminal and reattach to running sessions later. Jev routes each turn among configured models and can independently supervise fleet alignment at host checkpoints. Integrated LORE shares reviewed memory across DOXA, Claude Code, and Codex.

Warning

Rust 2.0 is in beta. Agents can edit files and run commands with your privileges. Choose a session isolation profile and review the platform limits before using DOXA on important work.

How the gallery was captured

Contents

• Install and start
• Workspace and sessions
• Engines and review
• Remote access
• Gallery
• Platform and scope
• Documentation

Install and start

Install the latest Rust beta release:

curl -fsSL https://raw.githubusercontent.com/docwilde/doxa/main/scripts/install.sh | sh

The installer builds the frontend, daemon, remote adapter, isolation and plugin workers, and native LORE carrier, then puts doxa in ~/.local/bin by default. It adds a Linux application-menu entry or a macOS ~/Applications/DOXA.command shortcut. Set DOXA_NO_LAUNCHER=1 to skip the shortcut. Run doxa update to update; pass a tag after sh -s -- to select a version. The installer builds source and does not authenticate a release signature or attestation; DOXA_RUST_EXPECTED_SHA can require an independently obtained 40-character commit SHA before it builds.

doxa doctor --engine codex
doxa new --engine codex
doxa list

Choose an installed engine in place of codex. Claude needs its CLI; protected Codex needs its private provider build on Linux. DeepSeek and GLM need API credentials through /setup or environment variables. doxa help lists CLI commands. From a checkout, use ./task build, ./task run, or ./task install.

Workspace and sessions

• Work in parallel. Open tabs with Ctrl+T, split with Alt+V or Alt+H, and keep a prompt in each pane. The project rail groups live and recoverable sessions. Saved layouts restore on launch.
• Detach and return. Ctrl+W closes a tab while its daemon runs; Ctrl+Q exits the window and leaves sessions detached. /resume finds saved sessions, including closed tabs. Ctrl+X stops the active daemon and retains its transcript.
• Review the work. Expand reasoning and tool calls, inspect diffs and worktrees, and use the action palette or slash commands. The Peers chip opens the active session's peer map, and restored peer receipts retain sender provenance. Context values survive session restore only as a clearly marked Last reported snapshot; reported context categories and subscription quota bars appear only when providers supply them. Select transcript text and press Ctrl+C to copy through a supported desktop helper, with OSC52 as a terminal-dependent fallback; Ctrl+V pastes into the prompt draft that started the read. LORE facts, beliefs, and pending proposals have TUI review controls; verified pending proposals affect local rail urgency. Project headings can use a verified-root hue and an explicit /collection project-label; /collection view panes groups live tabs by pane and names a hidden tab needing attention. Bounded local Markdown images and opt-in Mermaid previews appear in the transcript; Mermaid PNGs use a private session cache. /codegraph opens bounded Rust and Python syntax queries and reviewed LORE snapshots with source and complete-scan freshness checks. Background preparation reuses parsed declarations while every answer rechecks the complete source inventory and hashes; queries do not write to LORE.
• Attach input. Use Attach or Alt+A for images and UTF-8 files. Linux Ctrl+V pastes a clipboard PNG or text into its owning draft. Images reach direct Claude/Codex in native and Docker sessions; adding files never submits them. Formats, limits and clipboard helpers.
• Choose isolation. Start in native, docker-open, or docker-offline. Linux Docker profiles use a private rootless worker and checkout, with effective cgroup memory, CPU, PID, and swap limits checked before admission and CLI provider turns. Administrator-provisioned docker-hardened sessions add a separate Engine identity, ROOT-controlled policy, enforcing project quota and live kernel authority; start their reserved session ID through the daemon and attach the frontend. The isolation chip shows the verified policy. Change an idle native/open/offline session with /isolation PROFILE --confirm; hardened migration refuses before stopping the provider. Setup and limits.

The Rust guide covers keys, session recovery, worktrees, settings, and review behavior.

Engines and review

Engine	Connection	Setup
Claude	Claude Code CLI	Sign in with the CLI.
Codex	Protected private app server	Linux build and Codex sign-in.
DeepSeek	Rust API client	Supply an API key.
GLM	Rust API client	Supply a z.ai API key.
Model Router (opt-in)	Jev or SubQ Snap selects configured DeepSeek/GLM API or authenticated Claude/Codex CLI targets	Private candidate config, worker credentials and a private Jev/SubQ key.

Engine capability matrix lists model, permission, cost, compaction, and platform support. The picker distinguishes sourced model facts from unknown context or thinking support. API budget admission uses a conservative documented price bound and refuses an unknown priced bound. The Model Router keeps one canonical conversation while selecting an eligible configured worker at each turn. /model auto enables routing; a target ID pins it. Native Claude and protected Codex workers retain their tool and permission reviews. Their account charges remain unknown and are excluded from the tracked routing/API allowance.

Enable it in /settings → Session → default engine → Model Router. Choose Jev 1.13.0 or SubQ Snap Preview as the routing decision model and enter its masked API key. Set the private candidate-config path, press Ctrl+P to review current authentication and catalogs, then Ctrl+S to save the default for new sessions. Selecting a fixed engine disables that default. New Session also offers the reviewed Router targets in its clickable model dropdown. Settings walkthrough. doxa model-facts ENGINE MODEL [--review-before YYYY-MM-DD] prints exact sourced facts and flags operator-selected review candidates. Add --check-catalog for an explicit read-only OpenAI API listing check with OPENAI_API_KEY; it reports listed, unlisted, or unknown without changing model or budget admission.

Fleets can run an acting coordinator and workers under a reviewed charter, typed host gates, and spending limits. A separately selected alignment supervisor, including pinned Jev 1.13.0 or SubQ Snap Preview, evaluates fleet scope and host evidence; a distinct fast LLM, Jev or Snap message judge reviews peer messages. Neither reviewer inherits worker authority or history. Dependent Docker-isolated workers wait for a host checkpoint, receiver read-back, sender agreement, and explicit human release; later turns and handoffs invalidate the review. /fleet dependency-review shows the evidence in the TUI. An owner-reviewed offline recipe can produce snapshot-bound test receipts; opt-in --auto-test runs it after host-observed turns. Receipts do not release dependencies. doxa fleet debrief RUN --root PATH summarizes bounded host evidence after a run without opening peer bodies or making model calls. A private scorer can evaluate consented, labeled real-message verdicts; no such corpus ships and evaluation does not change enforcement. Fleet supervision.

Remote access

Remote control is opt in. doxa remote serve exposes a private Rust browser view through Tailscale Serve. A private doxa-hub lets another DOXA installation use browser, CLI, or native TUI control across machines. Native clients can encrypt transcript and control content end to end with a shared key; the hub still sees connection metadata. doxa remote tui HUB_URL --save-layout saves remote-only tabs; /remote-control HUB_URL --save-layout opts in to mixed local/remote pane restore after fresh roster checks. The remote guide covers setup and limits. The Chrome extension supports encrypted hub sessions. The Android client has local and opt-in FCM background alert paths. Its debug APK builds and opens in an offline emulator; provisioned FCM, device and tailnet checks remain open.

See the browser and Android gallery for client screenshots and capture details.

Search and MCP

Open /settings → 0 MCP to save Tavily, Firecrawl, Exa and Brave Search API keys in the masked private editors. Select an owner-private server config, then Ctrl+P checks configured servers without calling tools. MCP is opt-in for DeepSeek, GLM and Router API workers. Configuration and templates, tool review and accounting.

Use /setup docker for rootless Docker prerequisites and reviewed worker image/socket configuration. Docker setup. GLM exposes an owner-declared API bundle profile and a separate optional quota monitor; cash balance and bundle remainder remain unknown. GLM account reporting.

Gallery

These beta.50 screenshots capture the production Ratatui app in a real GTK/VTE terminal, using illustrative session data. The capture record explains each scene and how to reproduce it. Browser and Android screenshots have their own gallery.

Workspace — Three engine tabs, a project rail, and a Markdown turn in the production Ratatui app.

← Code graph · Next: Model Router settings →

The interactive gallery has keyboard and on-page previous/next controls. GitHub's README view shows one static frame above; each one-frame Markdown page also has previous and next links.

Platform and scope

Linux has bounded live checks for all four engines. macOS has build and transport CI, but authenticated provider sessions still need live verification; protected Codex is Linux only. Windows is unsupported. See platform verification. Python 1.x is archived at v1.19.0; its manual is historical.

DOXA loads selected provider plugins with scoped adoption rules. Remote access needs explicit private network setup. The parity tracker and latest provider verification record detailed evidence and open checks.

Documentation

• Rust guide — install, sessions, review, fleets, and remote use.
• Engine capabilities — what each provider supports.
• Jev router — candidate configuration, automatic routing, pins, budgets and evaluation limits.
• Release publication — advertise the current recommended beta as GitHub Latest.
• Session isolation — Docker profiles and their limits, explicit ROOT provisioning, kernel writer/Engine/container checks and typed provider/Git transport. Disposable guest receipts state their exact scope; real Claude/Codex streaming and login acceptance remain unclaimed. Historical advisory quota fixtures grant no admission.
• Fleet supervision — independent review and message judging.
• Code graph queries — automatically prepared syntax indexes with full source revalidation and explicit incomplete coverage; index and latency measurements. The optional Linux semantic broker requires an external operator trust anchor, immutable source and verified Engine/analyzer lifecycle. Its plain-Rust definition claim excludes compiler execution and arbitrary dependency-cache hydration.
• Native plugins — owner-approved text commands and status files, plus Linux TUI execution under a separate signed operator permit. The permit binds the exact frontend/worker and instance; expiry, revocation and panel/window closure stop workers. Disposable-host containment and actual TUI lifecycle proofs passed. The owner must explicitly provision and issue authority; review-only receipts grant none.
• Plans and open work — current implementation status.

DOXA is licensed under AGPL-3.0-only, with a commercial licence available. The name and mark follow the trademark policy.