tty7 Terminal Workbench
A pure-Rust terminal workbench with persistent sessions, remote development, and agent awareness — GPU-rendered, no tmux required.
CI declares least-privilege contents: read explicitly; agent status hooks are opt-in via Settings; SSH secrets use the system keyring with a secret-free CredentialRef; the remote server deliberately excludes gssapi and the HTTPS download path with a documented rationale. Deducted for: remote-install pushes a server binary onto target machines, the Windows updater uses elevation and HKCU registry writes, the publisher is unverified, and there is no security documentation or threat model. No explicit rollback mechanism beyond the stable/nightly channel split, so rollback scores 1. Upstream attribution (gpui, alacritty_terminal, russh patch, issue numbers) is thorough — full marks for source_attribution.
README, Cargo.toml, and CI are mutually consistent (versions, target matrix, feature gating), but deducted because multiple dependencies come from the author's own forks (gpui, gpui-component, alacritty, russh) under an unverified single-maintainer identity — a real supply-chain availability risk, hence dependency_availability = 1. No actual error-handling code is in the reviewed set; failure messages can only be inferred from comments (test-hang diagnostics, libtest timeout output), scoring 1. The CI itself admits the test suite hangs roughly one run in ten for unexplained reasons, further reliability evidence against.
The audience (developers, remote work, AI coding agents) is clearly scoped; environment fit is well evidenced: three-platform matrix, static musl server, per-platform gssapi feature trimming, documented Linux tray degradation. The support matrix honestly tiers detection vs. status vs. fork. Deducted for: trigger precision (when hooks fire, under what conditions) is described only at settings level without detail; no FAQ.
Documentation architecture is clear (docs/, skills/, bilingual README); install notes are thorough and consistent between CI and prose; the LICENSE file is complete Apache-2.0 with copyright notice (full marks); naming is stable across tty7/tty7-core/tty7-server/tty7-cli. Deducted for: CHANGELOG is only a link, contents unseen; known limitations are buried in source comments (deprecated notify-rust API, GNOME tray absence) rather than user-facing docs; maintenance is concentrated in one unverified publisher with no governance or signing commitments.
The CLI is well designed for agents (run propagates exit codes, capture, wait --until free, split/send), giving good output usability; persistent sessions without tmux and 19-agent awareness are real marginal value. Deducted for: the ~2x throughput claims come only from self-reported benchmarks, unverifiable in static review, so marginal_value is not full; maintaining several long-lived forks (gpui, alacritty, russh) with single-person upkeep weighs on cost_benefit.
Benchmarks link methodology and one-command reproduction; CI includes post-packaging verification (version checks, codesign, static-link assertions, checksums.txt), giving decent claim traceability. Deducted for: no independent third-party source in this review corroborates performance or stability claims (cross_source_corroboration = 1); source comments distinguish 'verified locally' from expected behavior well, but no test code is present in the reviewed set, so 2.
- Core dependencies (gpui, gpui-component, alacritty_terminal, russh) all come from the author's own forks or patches, and the publisher is unverified: verify pinned revs against Cargo.lock yourself and assess fork longevity.
- Remote workspaces push tty7-server onto target machines, and the Windows updater involves elevation and registry edits: confirm the remote install's permission scope and uninstall path before deploying.
- Performance claims (~2x throughput, 888 fps) are self-reported benchmarks only; reproduce them via scripts/bench/ before relying on them.
- The CI notes the test suite hangs roughly one run in ten with no root cause identified; this static review covers no runtime behavior — test in a controlled environment before production adoption.
- No security documentation or data-flow threat model is provided; independently review credential handling in crates/tty7-core before adoption.
What does this agent do, and when should you use it?
tty7 (GitHub: l0ng-ai/tty7) is a terminal workbench written in pure Rust, GPU-rendered with Zed's gpui and built on Alacritty's alacritty_terminal VT core. Its defining architecture is a background daemon server that owns shells and panes rather than the window, so sessions survive quitting the app or rebooting — persistent sessions without tmux. It is agent-aware, detecting 19 CLI coding agents (Claude Code, Codex, Gemini, Copilot, and more) per pane and surfacing status dots, notifications, branch and diff context, and a tray icon when input is needed. It ships a native russh-based SSH stack with SFTP, port forwarding, and jump hosts, plus a Git panel that follows the focused pane (stage, commit, branch, worktrees, commit graph). Input is editor-grade out of the box: ghost suggestions, explained completion, syntax highlighting, and fuzzy history search, with shell integration auto-injected for zsh, bash, fish, PowerShell, WSL, and remote panes. Native builds exist for macOS, Windows, and Linux under the Apache-2.0 license, and the README's benchmarks claim roughly 2× the throughput of Alacritty, Ghostty, or Kitty.
tty7 starts a background daemon server that holds all PTYs (shells and agent processes); the GUI window is a client of that server. Shell integration is injected automatically when a pane starts — prompt marks, working directory, exit codes, and command-finished notifications require nothing to install across zsh, bash, fish, PowerShell, WSL, and remote panes. On the input side it provides ghost suggestions from history, explained tab completion, syntax highlighting, multi-line editing, click-to-place caret, and ⌃R fuzzy history search. It detects 19 agent CLIs per pane; installing each agent's hook via Settings → Agents unlocks the status dot, notifications, tray icon, tty7 wait, and resume after reboot; forking is supported for agents that expose their own fork command (Claude Code, Codex, Grok, OpenCode, Oh My Pi, Droid, Qwen Code, Goose have full support). The bundled tty7 CLI is designed for agent scripting: run (streams a command and exits with its code), split, send, wait --until free, and capture. Remote workspaces keep files, repos, diffs, and panes on the remote machine over the native russh stack, with reconnection from any client. The Git panel follows the focused pane and supports staging, committing, amending, branching, pushing, stashing, side-by-side/unified diffs, a commit graph with cherry-pick/revert/reset, and worktrees that open their own tab. Window features include tabs and splits, a ⌘P palette, ⌘F scrollback search, a ⌘J panel with process tree and listening ports, 13 themes with custom YAML and iTerm2 import, and IME support.
- A developer running Claude Code or Codex sessions across several repositories: the tab sidebar groups agent sessions by repo, showing status, branch, and diff, with a tray icon when an agent needs input
- Users who need sessions to survive reboots: shells and supported agent sessions are owned by the background server and can be resumed, without learning or maintaining tmux
- Engineers developing on remote servers: SSH workspaces keep files, repos, and panes on the remote machine, and you can reconnect from any client and continue where you left off
- Automation scenarios where agents collaborate: one agent opens a pane for another via the tty7 CLI, hands off a task with send, waits with wait --until free, and reads results with capture — even with the GUI not running
- Power users who want editor-grade input (completion, highlighting, fuzzy history) and an integrated Git panel (stage, commit, worktrees) without leaving the terminal window
- Multi-platform users moving between macOS, Windows, and Linux: all three have native installers, and themes can be imported from iTerm2
What are this agent's strengths and limitations?
- The background-server architecture makes sessions genuinely persistent: shells and supported agent sessions keep running across app quits and reboots, replacing tmux with no extra learning curve
- Documented performance lead: README benchmarks show 95 ms for an 11 MB cat (vs. Alacritty 239 ms, Ghostty 179 ms, Kitty 185 ms) and 888 fps on DOOM-fire, with one-command reproduction in scripts/bench/
- Deep agent integration without wrapping: 19 agent CLIs are detected, and agents run in a normal PTY with their own interface — no wrapper or proxy — reducing compatibility risk
- A complete agent-facing CLI (run/split/send/wait --until free/capture) enables scripted agent-to-agent handoffs, with or without the GUI running
- Native russh SSH stack and a full Git panel bring remote files, diffs, and worktrees into the same window as the terminal
- Full agent status/resume/fork features require manually installing a hook per agent (Settings → Agents); fork also depends on the agent's own fork command, and only 8 of 19 detected agents have full support
- Built on Zed's gpui and a custom persistent server — a relatively new technology combination with limited long-term stability evidence; Gemini and Copilot lack fork support
- Cold-launch memory is 116 MB (GUI 105 MB + persistent server 11 MB), higher than Alacritty's 105 MB — not ideal for minimal-footprint purists
- Remote mode requires a tty7-server install on the remote machine (one-time and unprivileged, but may be blocked in locked-down corporate environments)
- Linux ships only an x86_64 AppImage — no ARM build and no package-manager (apt/brew/winget) channel is documented
How do you install or deploy this agent?
Download a native build from GitHub Releases (https://github.com/l0ng-ai/tty7/releases): macOS — …-macos-arm64.dmg or …-x86_64.dmg, drag into Applications; Windows — …-setup.exe or portable ….zip; Linux — …-x86_64.AppImage, run chmod +x and execute (X11/Wayland libraries are bundled). To install the agent-facing skill, run: npx skills add l0ng-ai/tty7 (later: npx skills update tty7). Configuration lives in config.; full documentation is in docs/ (keyboard shortcuts, configuration, CLI reference).
How do you use this agent?
Launch tty7 and open tabs and split panes; shell integration is injected automatically — nothing to install. To enable agent awareness, go to Settings → Agents and install the hook for your agent with one click; this unlocks the status dot, notifications, tray icon, session resume after reboot, and tty7 wait. Forking additionally requires the agent's own fork command. Agents and scripts use the bundled CLI: tty7 run <command> (streams output and exits with the command's code), tty7 split, tty7 send, tty7 wait --until free, tty7 capture. For remote development, configure SSH profiles (keychain secrets, jump hosts, port forwarding); the first connection performs a one-time, unprivileged tty7-server install. Agent wrapper scripts can be mapped to known agents by name via agent_commands in config..
How does this agent compare with similar options?
The README benchmarks tty7 against Alacritty, Ghostty, and Kitty, claiming roughly 2× the plaintext I/O throughput (95 ms vs. 239/179/185 ms) and 888 fps vs. 485/552/617 fps on DOOM-fire; its differentiators are persistent sessions without tmux, agent awareness, and built-in SSH/Git, whereas those three are pure terminal emulators.