Tabtivity — A tab for each project. A tab for everything in it.
▶ Watch the 90-second promo with sound · made with Tabtivity, by an AI agent working in a Tabtivity tab
Tabtivity is a project-centric desktop layer that swaps your entire working context — windows, files, apps, Git state, layout, and especially AI agent terminals — as a single unit when you switch projects.
| Who should try Tabtivity | Who should look elsewhere |
|---|---|
| You work across several projects and want each one to bring back its own desktop, files, apps, and agent sessions. | Your main need is an autonomous agent platform that dispatches, supervises, and recovers multi-day work without your involvement. |
| You work on multiple remote machines or an HPC cluster over SSH and want easy reconnection and simple distribution of tasks across machines. | You want Tabtivity to manage the agent workflow. Tabtivity is a project workspace and control cockpit, not an autonomous agent scheduler. |
| You want to monitor or answer your agents from your phone or iPad independently of developer apps. | |
| You need structure and control and are tired of switching between your agent tabs. You use many different models (claude, openai, meta, google, ...) in parallel. |
- Install. Grab a package from the
latest release
(see Download) or build from source.
On Linux, agent tabs also need
bubblewrap(the first agent tab offers a one-click install if it is missing); beyond that, optional tools unlock single features. - Add a project. Click + in the project bar. New project creates
~/tabtivity/projects/<name>/with Git, an agent doc (AGENTS.md) and aREADME.mdalready in place (more docs are one click away in the file tree's Project docs group); Import project registers an existing folder in place, or copies or moves it. - Start working. Opening a project gives you a tab running your default agent. Set that command in Settings; any new tab can pick another installed agent CLI or a plain shell.
- Add your favorite CLI. Settings → Manage CLIs lists the agent CLIs Tabtivity knows (Claude, Codex, Gemini, Vibe, Qwen, OpenCode, Copilot, ...): install one with a single click, no administrator rights needed, and it shows up in every tab's + menu; Check all for updates and Update all keep the installed ones current. One that isn't listed? Choose + Add agent… in that menu and give it a label and its command (a binary name or full path), optionally arguments, a resume flag so the tab survives a restart, and an install command (details).
- Switch projects. Click another project pill: its windows, tabs, files, and layout come back, and the previous project's desktop is parked until you return.
- Go further when you need it. Point a project at an SSH host or HPC cluster, or opt a project into Tabtivity Mobile (Settings, needs Tailscale) to answer your agents from your phone or iPad.
One project = one desktop. Tabtivity is a project-centric desktop layer, not just an app that launches or embeds other apps: projects own their windows and desktop context, and selecting a project swaps that whole context — windows, files, apps, Git state, and layout — as a single unit. The AI agent terminals, file viewers, and app launcher ride on top, living inside a project once its desktop is restored.
One project = any machine. A project is not tied to the computer in front of you. Point it at an SSH host — or extend an existing local project onto one — and its agent tabs, shells, Python runs, and jobs execute there, while the file tree, viewers, and Git views keep working exactly as they do locally. No sshfs or FUSE mount is involved, a project can span several machines at once, long runs survive an SSH drop or a laptop lid, and SLURM clusters are driven from the same cockpit. The goal is that running a project on a cluster costs about as much ceremony as running it locally.
Every agent = one phone or iPad. An opt-in companion web app, Tabtivity Mobile, reaches the same agent and shell tabs from a phone or an iPad over your own private tailnet — read what an agent is doing and answer it from another room, or mark up the PDF it built with the Apple Pencil and hand the marks back. That is remote control for every agent CLI Tabtivity runs — Claude, Codex, Gemini, Qwen, Grok, Cursor, Copilot, OpenCode and the rest — whether or not its vendor ships a phone app for it, and without any vendor's relay in between.
Built with Tauri 2 + React + TypeScript for Linux (X11 / KDE Wayland), Windows, and macOS. Linux X11 is the reference platform and is used regularly on Ubuntu; Windows is partially tested and macOS untested. See Platforms and current limits for the rest.
Are you also annoyed by switching between agent tabs or apps, keeping track of which tab or agent works on which project? When you juggle several projects at once, every project's windows — browsers, terminals, file managers, docs, agent sessions — pile onto one desktop, and switching means digging for the handful that belong where you're going.
Tabtivity flips the model. Select a project, and the desktop becomes that project: its windows come forward, the previous project's windows park out of the way, the default-app mappings re-route, and time tracking switches. Need two projects at once? Box them — the box behaves like one project with a shared desktop, file tree, and agent tabs — and unbox afterwards.
How it compares. Agent orchestrators (Vibe Kanban, Conductor, Claude Squad,
the Claude Code desktop app) manage agent processes inside one repo but have
no notion of your desktop. T3 Code comes closest on the agent side — one
interface for Claude Code, Codex, Cursor, OpenCode and other CLIs, a worktree
per thread, phone apps, agents on other machines over Tailscale — but it is a
chat-and-git front end: its project ends at the repo and its threads, not the
windows, files and cluster jobs around it. KDE Activities, virtual desktops, tmux, and workon
scripts each cover one slice without a project model. Remote tooling (VS Code
Remote, JupyterHub) attaches one editor to one host, leaving the cluster half a
terminal exercise. Vendor phone apps reach only their own agent through
their own relay. Tabtivity fills the gap between them — projects that own
their windows, the machines they run on, and one phone and iPad remote for
every agent — and runs alongside an orchestrator rather than replacing it.
- Project desktop: window parking per project (X11, KDE Wayland, Windows, macOS), external window tracking, per-project default apps, and time tracking.
- Remote machines & HPC clusters: a machine hub, projects that run on an SSH host without a mount, a local copy kept in step through Git, extra worker machines, tmux sessions that survive drops, and SLURM jobs from the UI.
- Every agent from your phone or iPad: an Agents list of who is working, waiting or done, a chat view and touch terminal, files the agent sends you, read-only project files (with the desktop's Project docs group), and PDF markup with a finger or the Apple Pencil that goes straight back to the agent.
- Agents and terminals: 30 built-in agent CLIs plus your own and local Ollama models, per-tab session resume, a Chat view over the running terminal (with diffs you can annotate line by line, earlier chats and subagents), on-device dictation (shown live in the draft) and read-aloud, scheduled prompts and chains, a tiling, pop-out tab layout, agent tabs of one project that can message each other, and experimental per-turn checkpoints that put an agent's files back. Local agents always run inside a sandbox (the agent fence). Tabby, a chat assistant that can search the web but cannot reach your files, sits in the side panel.
- Projects, boxes and isolation tiers: boxes that join projects for a while, one-click publishing to GitHub or GitLab, and container and VM projects.
- Workspace apps: mail with an encrypted local store and OpenPGP, a calendar with CalDAV, a to-do board, a reader-mode browser, a print manager, a deck presenter, and a private daily recap — several of them experimental and off by default.
- Files, viewers, and editing: in-app viewers and editors for code, Markdown, YAML/JSON, BibTeX, LaTeX workspaces with SyncTeX, PDF (with real redaction), images, tables, notebooks, spreadsheets, SQLite, and more.
- Interface and learning: a theme customizer, a guided tour with 30-plus lessons, keyboard navigation where every key can be rebound, built-in help your agents can look things up in, and five languages (English, German, French, Spanish, Italian).
Every built-in CLI runs in a terminal tab. These CLIs do more:
| CLI | Regularly updated | Resumes after a restart | Chat view (desktop) | Chat on the phone | Earlier chats (Resume menu) | Diffs |
|---|---|---|---|---|---|---|
| Claude | ✓ | ✓ own conversation | ✓ | ✓ | ✓ | ✓ |
| Codex | ✓ | ✓ own conversation | ✓ | ✓ | ✓ | ✓ |
| Copilot | ✓ | ✓ own session | ✓ | ✓ | ✓ | |
| OpenCode | ✓ | ✓ own conversation | ✓ | ✓ | ✓ | ✓ |
| Antigravity | ✓ | ✓ own conversation | ✓ | ✓ | ✓ | |
| Meta Muse Code | ✓ | ✓ own session | ✓ | ✓ | ✓ | |
| Mistral Vibe | ✓ | ✓ own conversation | ||||
| Gemini | ✓ folder's latest | ✓ | ||||
| Qwen, Cursor, Grok, Droid | ✓ folder's latest |
Regularly updated: only these seven CLIs are kept in step with their new releases. Every other built-in CLI still installs and runs, but its support may lag behind its newest release.
Own conversation or own session: each tab comes back to the exact chat it had. OpenCode, Vibe, Antigravity and Muse learn a tab's chat from its first prompt on; before that, on a remote host, and for Muse on Windows, the tab continues the folder's latest. Folder's latest: the tab continues the newest chat in its folder, so two tabs of the same CLI in one folder both come back to that one. Picking a chat in the Resume menu pins the tab to it. Antigravity's and Muse's per-tab resume and Muse's chat view are new and have not been tried in a real window yet. The other built-in CLIs start fresh after a restart; a custom agent can bring its own resume flag (details).
The full tour is in docs/guide/features.md.
Prebuilt packages are published on the
Releases page. From the
latest release,
grab the .AppImage (portable Linux) or .deb (Debian/Ubuntu), or the .exe
installer on Windows, or the unsigned universal Intel/Apple Silicon .dmg
on macOS. The CI release workflow publishes each platform whose packaging job
succeeds.
The macOS .dmg is neither signed nor notarized, so Gatekeeper refuses to open
the app as downloaded ("damaged" or "cannot be opened"). After dragging Tabtivity
into Applications, clear the download quarantine once:
xattr -dr com.apple.quarantine /Applications/Tabtivity.appThe Linux packages are built on Ubuntu 24.04, so they need glibc 2.39 or newer
(Ubuntu 24.04+, Debian 13+, Fedora 40+). On an older distro the loader fails
with GLIBC_2.39 not found — build from source there instead.
Once it is installed, Settings → Updates checks the same releases page from
inside the app and can download and install a newer build for you. It only
looks when you open that screen — Tabtivity never checks in the background — and
restarting is always yours to do. A copy installed from the .deb (or by any
other package manager) downloads the new build but leaves installing it to you.
A release build needs nothing beyond the OS, with one exception: on Linux,
local agent tabs run inside a bubblewrap sandbox and refuse to start without
it (sudo apt install bubblewrap; the .deb recommends it, and the app offers
the install in a tab). Each of the rest unlocks one feature and is optional:
- Remote/SSH and HPC projects: nothing to install locally beyond OpenSSH — no
sshfs, no FUSE. On the host:tmuxfor persistent sessions, plusopenvpnlocally for VPN-gated hosts - Containerized projects: Docker. VM projects: QEMU/KVM
- Print manager: CUPS on Linux/macOS — nothing to install on Windows
- Tabtivity Mobile: Tailscale on this machine and on the phone or iPad
- Reading agent answers aloud on Linux: speech-dispatcher (dictation needs nothing: the speech model installs from inside the app)
- Local model features — Vibe tabs, autocomplete, the mail assistant, the root console's agent tools (all off by default): Ollama
| Platform | Status | Notes |
|---|---|---|
| Linux — X11 | Yes (used regularly on Ubuntu) | Reference platform; two-desktop window parking. |
| Linux — KDE Wayland | Yes | Per-project virtual desktops via KWin (KDE 5 and 6). |
| Linux — other Wayland | Partial | No workspace switching; terminals and files work. |
| Windows | Partially tested | No agent fence and no tmux session persistence. |
| macOS | Untested | Builds and passes tests in CI; parks whole applications, not single windows. |
| Phone / iPad | Yes | Tabtivity Mobile, a web app over your own tailnet. |
Per-platform details and the current limits are in docs/guide/platforms.md.
Requirements: a Rust toolchain (rustup) and a current Node.js LTS release.
On Linux, also the Tauri system packages:
sudo apt install libwebkit2gtk-4.1-dev libssl-dev libgtk-3-dev \
libayatana-appindicator3-dev librsvg2-dev libasound2-dev cmake
npm install
npm run tauri:devWindows needs nothing more (it uses the system WebView2); macOS needs the Xcode command-line tools. Development builds, packaging, the stack, and where Tabtivity keeps its state are in docs/guide/building.md.
- Features — the full feature tour
- Platforms and current limits
- Building, development and storage
- Setting up a server — run Tabtivity on one Linux machine for a few people, used from a browser or phone (experimental)
- User help — setup and troubleshooting per feature, also readable from inside the app
- DOCUMENTATION.md — architecture, data schemas, behavior
- STATUS.md — what has been live-verified · ROADMAP.md — remaining work · VISION.md — the long-term strategy
Tabtivity is dual-licensed under either of
- Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
- MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)
at your option.
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual-licensed as above, without any additional terms or conditions.
