Alethe: a local-first desktop workspace for running multiple coding agents in real PTYs

The problem Alethe targets: five agents, three repositories, one window

The README frames the problem precisely: one agent in one terminal is easy, but five agents across three repositories is the actual job. Terminal tabs break down there in specific ways. Sessions get lost when a tab closes, MCP server configuration drifts out of sync between agents, and you lose track of which agent is working in which directory.

Alethe is aimed at developers who already run agent CLIs as part of their daily work and treat them as long-lived processes rather than one-shot commands. The README lists Claude Code, Codex, GitHub Copilot CLI, Cursor, Antigravity, OpenCode, Mimo and Freebuff as supported agents, plus plain pwsh, bash or zsh shells in the same pane model. If you run one agent occasionally, the workspace overhead buys you little. The value shows up when agent count and repository count both climb.

How the pane and PTY model works

Each agent runs in a real PTY, not a simulated stream. The README states that one agent can occupy a pane, or several agents can sit as sub-tabs inside the same pane, each with its own PTY, working directory and session. Closing a container hides it while the process keeps running, which is the design decision that separates Alethe from a tabbed terminal: the UI is a view over processes that outlive it.

Layouts (auto, spotlight, sidebar and custom grid) are editable directly on the grid and persisted. Scrollback is persisted per PTY, so reattaching after a restart shows what happened before. The frontend stack is React with xterm.js, and the shell is Tauri with a Rust backend in src-tauri/, which is where PTY handling and the heavier system probing live.

Session resume is uneven across agents, and the README is explicit about it. Claude Code, Codex, Cursor and OpenCode resume sessions; Copilot CLI, Antigravity, Mimo and Freebuff are listed without that capability. If resume is why you are evaluating Alethe, check the agent table before assuming your CLI is covered.

Installing Alethe and opening a first project

The README points at the GitHub releases page for downloads, and the repository ships release tooling rather than an install script. If you want to build from source instead, the package.json defines the commands. Install dependencies first, then start the Tauri dev shell:

npm install
npm run app

The app script runs tauri dev with src-tauri/tauri.dev.json, which is the development configuration rather than a release build. Expect a compile of the Rust backend on first run, which takes noticeably longer than subsequent starts.

For a production build, the repository uses the standard Tauri path:

npm run build
npm run tauri build

Once the window opens, the README describes the working pattern: create a project for a repository, which becomes a container with its own panes, then open an agent inside a pane. Alethe probes the machine for Node, npm, WinGet, Scoop and Chocolatey and offers only the install methods that work there, preferring each vendor's official installer. Already-installed CLIs are discovered across PATH, the Windows registry, npm, pnpm, Volta, fnm, nvm, Bun, Cargo, Scoop and Chocolatey, and can be pointed at a custom path. The .env.example file only covers an optional local Spotify fallback for development, so it is not part of agent setup.

The MCP tab and what atomic writes actually mean

The MCP tab reads MCP server configuration from Claude Code, Codex, Cursor, OpenCode and Antigravity, groups servers by name, and shows which agents have each one. You can add, remove, copy a server from one agent to another, search the official registry, and ask each agent to verify it can actually reach a server.

The implementation detail worth noting is the write path: the README says every write is backed up, re-parsed and committed atomically. That matters because MCP configs are shared files that multiple tools read at startup, and a half-written JSON file breaks every agent that depends on it. Atomic commit plus re-parse is the right shape for that failure mode.

The Skills tab follows a similar idea, resolving links and shared stores so a shared skill appears once rather than once per agent. Graphify builds a code graph of the project and serves it to agents as an MCP server, which is a different kind of integration: Alethe is not just reading agent config, it is also acting as a server those agents connect to.

Handing a conversation between agents, and where redaction stops

Alethe can hand a Claude Code conversation to Codex, and back, through what the README calls a locally redacted context packet. The goal is avoiding manual copy-paste of a long thread between two CLIs with different session formats.

The limitation is stated plainly in the README: redaction is best effort, and it tells you to review the packet before starting the target agent. That is the correct posture. A redactor that scans free-form conversation text cannot guarantee it caught every secret, path or credential, and the README does not claim otherwise. Treat the packet as a draft you inspect, not a sanitized artifact you trust blindly. If your conversations routinely contain production credentials, that review step is not optional, and it may be enough friction to skip the feature.

Local-first is not local-only

The README uses a specific phrase for this: Alethe is local-first, not local-only. Update checks and provider usage polling are on by default. Other network features are described as optional or action-triggered. Manual GitHub Gist Sync is available now, and the README says first-party hosted sync or cloud backup may be offered separately later.

This is the section to read before deploying Alethe on a locked-down machine. A tool that polls provider usage and checks for updates by default will make outbound requests you did not explicitly initiate. The README directs you to docs/PRIVACY.md for current network defaults, credentials and retention, and that document, not the marketing phrase "local-first", is the source of truth for what leaves the machine. The .env.example file is unrelated to this, covering only an optional Spotify fallback for development.

Alternatives: tmux, Zellij, and agent-native tools

The closest general-purpose alternative is tmux or Zellij. Both give you real PTYs, split panes, persistent layouts and session reattachment, and both are far older and more widely deployed. The difference is scope. A terminal multiplexer knows nothing about agent CLIs: it will not read Claude Code and Codex MCP configs, will not show which agents share a server, will not resume an agent's own session format, and will not hand a conversation between two agents. If your needs are strictly terminal layout, a multiplexer is lighter and has no GUI dependency.

Agent-native alternatives exist too, but the README does not name or compare against any of them, so there is no basis here for a feature-by-feature claim. The honest framing is that Alethe's differentiation is the agent-aware layer: CLI discovery and installation, MCP config management with atomic writes, session resume per agent, and the handoff packet. Strip those away and what remains is a Tauri terminal workspace, which is a crowded category.

Licence, maintenance and upgrade cost

Alethe is licensed AGPL-3.0-or-later per package.json, with the repository also carrying a NOTICE and TRADEMARK.md file. AGPL-3.0 is a strong copyleft licence with a network-use clause. If you only run the desktop app locally, the practical effect is limited, but if you modify Alethe and expose it to users over a network, the licence's source-availability obligations are the part to raise with counsel. This is not legal advice, and TRADEMARK.md governs the name separately from the code licence.

The repository is not archived, and the last push was on 2026-09-14, one day before this writing. Releases are frequent: v1.4.1 on 2026-08-07, v1.5.0 on 2026-08-09, and v1.6.0 on 2026-08-17. That cadence cuts both ways. You get fixes quickly, but the README itself opens with a warning that Alethe is an early public release, so expect breaking changes between minor versions and read release notes before upgrading. The Tauri and Rust stack means upgrades may involve a backend rebuild, not just a frontend refresh.

Editorial conclusion

Adopt Alethe if you already juggle three or more agent CLIs across repositories and want their PTYs, sessions and MCP configs in one window. Skip it if you need a fully offline tool, since update checks and provider usage polling are on by default, or if you cannot ship AGPL-3.0 obligations. Before installing, read docs/PRIVACY.md and check the latest release tag, since the README still calls this an early public release.

Frequently asked questions

Official sources

1. Kc1t/alethe-agents on GitHub
2. License: AGPL-3.0
3. Project website
4. README
5. Releases