[!IMPORTANT] Alethe is an early public release. The desktop app is free, open source, and local-first. Optional hosted services, such as sync or cloud backup, may be offered separately later.

Supported Platforms

What Alethe Is

Alethe is a cross-platform desktop workspace for running and resuming multiple coding agents and shells in parallel on Windows, macOS, and Linux. It combines projects, groups, containers, split panes, terminal sub-tabs, real PTYs, local history, session resume, and memory controls in one app.

It is built for developers who use Claude Code, Codex, OpenCode, and local terminals across multiple repositories or client contexts.

Built with Tauri, Rust, React, TypeScript, Vite, portable-pty, and xterm.js.

Product Philosophy

Alethe is intentionally not a maximalist desktop suite. Its purpose is to provide a calm, reliable workspace for coding agents, terminals, and project context — then let each user decide which additional capabilities belong in that workspace.

The product follows a principle similar to Obsidian: a focused core, a durable local foundation, and optional capabilities that can be brought in when they are useful. Alethe should grow with the user's workflow rather than forcing every workflow to carry the same interface, controls, and background services.

For that reason, new capabilities should be introduced behind explicit feature flags or opt-in settings whenever they are not essential to the core workspace. Optional features must be possible to discover, enable, disable, and maintain without making the default environment feel crowded or unfinished. A clean installation should remain a first-class experience as the product evolves.

This is a deliberate response to a common failure mode in developer tools: accumulating every possible feature until the product becomes harder to understand, harder to configure, and noisier to operate than the problem it was meant to solve. Alethe values coherence over volume, and user choice over forced completeness.

What It Gives You

  • Keep coding agents, shells, and project context in one durable workspace.
  • Close visual containers without killing the underlying terminal process.
  • Resume local sessions and scrollback instead of rebuilding context from scratch.
  • Organize work by project, group, pane, and terminal sub-tab.
  • Suspend noisy or expensive groups when you need memory back.

Core Concepts

  • Workspace: the persistent desktop surface where active work lives.
  • Project: a saved working context with terminals, layout, color, and local state.
  • Group: a collection of projects that can be opened, collapsed, or suspended together.
  • Container: the visible frame for an opened project.
  • Pane: a terminal view inside a container.
  • Terminal sub-tab: a separate shell or agent session inside the same terminal space.
  • PTY: the real backend terminal process that keeps running even when the UI changes.

Capabilities

  • Project and group based workspace.
  • Real terminal processes through a Rust PTY backend.
  • Split-pane containers with automatic, spotlight, sidebar, and custom grid layouts.
  • Multiple sub-tabs per terminal for agents or shells.
  • Persisted local projects, layouts, scrollback, sessions, and preferences.
  • Close containers without killing running processes.
  • Suspend groups to free memory.
  • Local backup export/import.
  • alethe terminal command to open any folder as a project.
  • Spotify Now Playing through the user's own Spotify app credentials.
  • Experimental agent planning canvas.
  • GitHub Actions release workflow for Windows, Linux, and macOS.

Install

Use the published installers from Releases.

Windows SmartScreen / Defender warning

[!WARNING] Windows builds are not code-signed yet. Windows Defender may flag alethe.exe as Trojan:Win32/Bearfoos.A!ml and quarantine or delete it. This is a false positive.

The !ml suffix means the detection came from Defender's machine-learning heuristic, not from a malware signature. Alethe trips it because it does exactly what a terminal multiplexer must do: spawn child processes, create PTYs, write commands into them, and self-update — all from an unsigned binary with no download reputation yet.

If Defender removes the app:

  1. Open Windows Security → Virus & threat protection → Protection history.
  2. Find the Alethe entry and choose Actions → Restore.
  3. Add an exclusion for %LOCALAPPDATA%\Alethe (and for src-tauri/target if you build from source, otherwise your dev binaries get quarantined too).

You can also report the file at Microsoft Security Intelligence as an incorrect detection. Code signing for Windows is tracked on the roadmap; it will remove these warnings for good.

macOS builds are not notarized yet either, so Gatekeeper will show an unidentified-developer warning. Right-click the app and choose Open to bypass it.

Run From Source

git clone https://github.com/Kc1t/alethe-agents.git
cd alethe-agents
npm install
npm run app

Requirements

  • Node.js 18+
  • Rust stable
  • Windows 10/11, Linux, or macOS
  • Visual Studio Build Tools on Windows
  • Tauri system dependencies on Linux

Linux dependencies:

sudo apt update
sudo apt install -y libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf

Commands

# run the desktop app in development mode
npm run app

# run only the frontend in the browser
npm run dev

# build the frontend
npm run build

# build the desktop app/installers
npm run tauri -- build

Build artifacts are written to:

src-tauri/target/release/bundle/

Typical Workflows

  • Keep one project open with a shell, a coding agent, and a test runner in separate panes.
  • Split a workspace by repository, client, feature branch, or debugging session.
  • Leave long-running terminals alive while changing layouts or closing visual containers.
  • Suspend inactive groups to free memory and restore them when the context is needed again.
  • Export a local backup before moving machines or testing risky changes.

Terminal Command

Install the alethe command from Settings ▸ Integrations ▸ Terminal command to open a folder as a project without leaving the terminal:

alethe                # opens the current folder
alethe .              # same
alethe ~/some/project # opens the given folder

If the folder is already a project, Alethe brings it into the workspace instead of duplicating it. If it is not, the project is created with a terminal already pointing at that folder. When Alethe is already running, the existing window is focused rather than starting a second instance.

The command is installed to ~/.local/bin/alethe on macOS/Linux and to %LOCALAPPDATA%\Alethe\bin\alethe.cmd on Windows (added to the user Path). Reinstall it after moving or reinstalling the app — the settings screen flags a stale command.

Spotify

To use Now Playing, create an app in the Spotify Developer Dashboard and register this Redirect URI:

http://127.0.0.1:8888/callback

Then add your Client ID and Client Secret in Preferences > Spotify.

For local development, a .env file can also provide:

SPOTIFY_CLIENT_ID=
SPOTIFY_CLIENT_SECRET=

Releases

The release workflow builds installers for:

  • Windows x64
  • Linux x64
  • macOS Apple Silicon
  • macOS Intel

Create a release from a tag:

git tag v1.0.0
git push origin v1.0.0

[!NOTE] macOS builds distributed outside the App Store should be signed and notarized with an Apple Developer certificate. Without that, users may see an unidentified developer warning.

Roadmap

  • Workspace with projects, groups, and containers.
  • Real PTYs with spawn, attach, resize, and scrollback.
  • Automatic layouts and custom grid.
  • Sub-tabs per terminal.
  • Local desktop build.
  • GitHub Actions for Windows, Linux, and macOS.
  • Windows release signing.
  • macOS notarization.
  • Linux/macOS validation on real machines.
  • Visual documentation with screenshots/GIFs.
  • Optional cloud sync/backup.
  • Agent marketplace/library.

Contributing

Contributions are welcome. Read CONTRIBUTING.md for setup, project layout, and house rules.

The easiest ways to help right now are:

  • Pick an issue labeled good first issue or help wanted — comment on it to claim it.
  • Open a bug report with clear reproduction steps.
  • Request a feature with the workflow it would improve.
  • Improve docs, screenshots, setup notes, or platform validation — Linux and macOS are the least tested.
  • Open a focused pull request with a short explanation and screenshots/GIFs when the UI changes.

For larger changes, open an issue first so the direction can be discussed before implementation.

Built with Alethe

Projects and products built with Alethe as the workspace — agents running in parallel, shells alongside them, sessions resumed across days.

Nothing here yet. Built something with Alethe? Add it to SHOWCASE.md — it's one line and a pull request, and you end up in the contributors list too.

See SHOWCASE.md for the full list and how to submit.

Contributors

Thanks to everyone helping shape Alethe.

License

The source code is distributed under AGPL-3.0-or-later. See LICENSE for details.

Official hosted services, such as sync, backup, billing, or cloud features, may be proprietary and offered separately.

The Alethe name, logo, and official branding are reserved for official builds. See TRADEMARK.md.

Community