Termio
A terminal-first development environment that runs your CLI coding agents and tells you which one needs you.
- Source repo
- termio-sh/termio
- Stars
- ★ 785
- Last updated
- 2d ago
- License
- MIT
- Primary language
- Swift
- FA score
- 51/100 · Major gaps
At a glance
- Works with
- Universal · cross-platformCodex · Claude Code
- You'll need
- Typical use
- Developers running Codex, Claude Code, and several shells in parallel who need to be interrupted the moment one agent blocks on a permission prompt.
- Main limitation
- The desktop client ships for macOS 14+ only; the TUI client, Android, Windows, and web support are all roadmap items, not delivered features.
- Source review
- 51/100 · Major gaps
What does this agent do, and when should you use it?
Termio is a native macOS desktop app (written in Swift) that treats a real terminal as the cockpit for command-line coding agents. On first launch it wires up each agent's own hooks so every session reports working, idle, or needs-you through a sidebar dot, a menu-bar tray, and a matching signal on your phone. Sessions live in a daemon called termiod, so quitting the app only detaches — the agent keeps running and reattaching restores the same process and scrollback. A bundled termio CLI lets one agent spawn a sibling, hand it a task, read back the screen, and wait for the turn to settle. For remote work, Termio reads your existing ~/.ssh/config without rewriting it and copies a single binary into ~/.local/bin on any Linux VPS you can ssh to, so local and remote sessions run through the same protocol.
Termio organizes work as projects (one per checkout) holding terminals and agents, with git worktrees nested beneath the project they came from and project-independent chats above that. Panes split right with ⌘D and down with ⇧⌘D, optional horizontal tabs sit above the terminal, and every row carries a status of working, idle, done, or needs you. A file tree opens into a syntax-highlighting, autosaving editor; a read-only git pane shows the current unified diff; project-wide content search jumps to the matching line; ⌘⇧P opens a command palette for splitting and focusing. The termio CLI talks to the running app and exposes session list, spawn, run, send, read, watch, focus, close, plus notify; --wait blocks until the turn settles and returns the final status with the transcript range to read, --json makes output machine-readable, and --agent picks which agent spawn starts. Termio installs a termio agent skill into ~/.claude/skills and ~/.codex/skills and refreshes it on every launch. In remote setups the iPhone attaches by wss straight to termiod on the box rather than through the Mac, and the companion iPhone beta ships a key bar (esc, tab, ctrl, arrows) and hold-to-speak transcription into the prompt.
- Developers running Codex, Claude Code, and several shells in parallel who need to be interrupted the moment one agent blocks on a permission prompt.
- Teams that want one git worktree per parallel task and a sidebar that shows each worktree's sessions and their live status.
- People who relied on tmux to keep long jobs alive but would rather close the laptop and find the agent exactly where they left it without learning tmux.
- Engineers running long coding agents on a Linux VPS who need a dropped connection to leave the agent working and reattach to the identical screen from a Mac or an iPhone.
- Builders orchestrating multiple agents, where one agent spawns a sibling, hands it a task, and reads back the reply through the termio CLI.
- Mobile-first users who want session status pushed to their phone and to answer prompts with a key bar and voice input.
How do you install or deploy this agent?
On macOS 14 or later, download the DMG, or install with Homebrew Cask:
brew install --cask termio-sh/tap/termioFor iPhone, join the public beta on TestFlight, then pair by scanning the QR code under Settings ▸ Mobile in the Mac app. Remote Linux hosts take no manual install: under Settings ▸ Devices ▸ Set Up, Termio copies one binary into ~/.local/bin over SSH, starts the daemon, and installs the agents' hooks there. To give other agents the same session-control skill the repo publishes:
npx skills add termio-sh/termio --skill termioHow do you use this agent?
After first launch, open a directory as a project — Termio hooks any CLI agents you already have installed:
termio .Inside the app, ⌘D splits right and ⇧⌘D splits down; start whichever CLI agent you like from the terminal. Query and drive sessions from the command line:
termio session list
termio session spawn "fix the flaky test"
termio session run "pnpm test --watch"
termio session send ab12cd34 "1"
termio session read ab12cd34 --lines 40
termio session watch
termio session focus ab12cd34
termio session close ab12cd34
termio notify "the migration finished"Add --wait to block until the turn settles, and --agent to choose which agent spawn starts:
termio session spawn "run the migration" --agent codex --waitEnable horizontal tabs under Settings ▸ Appearance ▸ Tabs. Remember that quitting the app only detaches; ⌘W (Close Session) is what actually ends a session.
What are this agent's strengths and limitations?
- Sessions are owned by the termiod daemon, so quitting the app or losing the link never kills an agent, and reattaching restores the same process and scrollback — a real behavioral difference from a plain terminal.
- First launch auto-installs hooks for Claude Code, Codex, OpenCode, Amp, Cursor, Copilot and others, giving one consistent working/idle/needs-you signal without per-agent configuration.
- The termio CLI makes the environment scriptable: spawn siblings, send input, read the screen, and wait for a turn to settle, which enables agent-to-agent orchestration.
- Remote mode reuses your existing ~/.ssh/config untouched; one Setup step deploys the daemon and hooks to a VPS, and the phone attaches to the box directly instead of relaying through the Mac.
- MIT licensed, free to download, no account required, with desktop, CLI, and an iPhone companion covering both local and remote work.
- The desktop client ships for macOS 14+ only; the TUI client, Android, Windows, and web support are all roadmap items, not delivered features.
- Core behavior depends on termiod running on the target machine, so remote use means writing a binary and starting a daemon on the server — a real cost in locked-down environments.
- The file editor and git pane are deliberately narrow: diffs are read-only and commit, push, and PR review stay in the terminal, so it does not replace a full IDE.
- The project states it is looking for long-term maintainers, and the TUI, Android, and Windows tracks have no delivery dates, which raises maintenance-risk questions.
- Status reporting rides on each CLI agent's hooks, so agents Termio has not adapted get weaker session control than the listed ones.
How does this agent compare with similar options?
The README positions Termio explicitly as a tmux alternative: like tmux, sessions live in a daemon and closing the client does not end them. The difference is that Termio is a GUI desktop app that installs hooks into coding agents and aggregates their needs-you state, and it pairs that with a termio CLI and a phone companion, whereas tmux is a pure terminal multiplexer you must learn and orchestrate yourself.
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| Termio This agent | 51 · Major gaps | — | ★ 785 | 2d ago | Swift | Codex · Claude Code |
| Poracode | 55 · Major gaps | Desktop appFree + model costs | ★ 121 | today | TypeScript | ChatGPT · Claude Code |
| tlbx | 52 · Major gaps | Self-hosted serviceFree + model costs | ★ 116 | today | C# | Codex · Claude Code |
| pitwall | 70 · Some gaps | — | ★ 18 | today | Go | Codex · Claude Code |
How does FollowAgents rate this agent?
Why each dimension lost points
Evidence shows Termio runs agents in a real PTY on the user's own machine, and the design docs explicitly acknowledge the agent has full access; the previously implemented Seatbelt sandbox (default-deny for ~/.ssh, Keychain, .env, with deny rules emitted last) has been removed entirely, so the current version has no enforced isolation, hence least_privilege is only 1. On permission confirmation, the phone-side permission prompt design was shelved and the author states they run locally with --dangerously-skip-permissions, so user_confirmation is only 1. Data flow transparency: the README explains that the iPhone connects directly to termiod and SSH only reads ~/.ssh/config, but there is no systematic description of where session data, hook payloads and telemetry go, so data_flow_transparency is 1. Sensitive data handling: the design docs discuss trade-offs around Keychain and credential mounting, but none of it shipped, so sensitive_data_handling is 1. Dependency security: only docs.yml is seen using Node built-in modules, with no third-party dependency declarations or audit records, so dependency_security is 1. External effects: the CLI can spawn/close sessions, send notifications and write ~/.claude/skills, which are real side effects, but there is no unified confirmation or dry-run mechanism, so external_effects is 1. Rollback: the sandbox-removal doc gives a git revert recovery path and sessions can be recovered via detach, but there is no user-facing operation rollback, so rollback is 1. Source attribution: NOTICE and the docs clearly credit nono (Apache-2.0) as the baseline data source, so source_attribution is 2.
The README architecture diagram, CLI command table and termiod tests agree on socket names, legacy fallback and the --wait exit code 3, so self_consistency is 2. Dependency availability: installation only offers a macOS dmg and a Homebrew cask, iOS goes through TestFlight, and Windows/Android/TUI are all roadmap; the Rust client requires cargo build and no dependency list appears in the evidence, so dependency_availability is 1. Failure messages: cli_compat.py shows clear non-zero exits and diagnostics for unknown flags, invalid ratios, missing sockets and silent timeouts, so failure_messages is 2.
The README clearly targets CLI/TUI agent users and covers local, SSH VPS and iPhone scenarios, so audience_and_scenarios is 2. Capability boundaries: the docs explicitly list what is not done (live resize, cross-VM control plane, network domain allowlist, Windows/Web), so capability_boundaries is 2. Trigger precision: the CLI's distinction between spawn/run/send, treating 7-digit hex as text, and requiring a target for --no-enter are constrained by tests, so trigger_precision is 2. Environment fit: Apple Silicon + macOS 14 only (the sandbox once required macOS 26), and Linux only as a remote attach target, so environment_fit is 1.
The README is clearly sectioned and docs/design is archived by date and status, so information_architecture is 2. Install notes: dmg, brew cask, TestFlight and npx skills add are provided, so install_notes is 2. Naming stability: the CLI changed from sessions to session while keeping an alias, and the socket changed from session-control.sock to app.sock with a fallback, showing naming has changed, so naming_stability is 1. Examples and FAQ: the README has many CLI examples and a screenshot table, so examples_and_faq is 2. Known limitations: multiple design docs list known defects and reasons for shelving, so known_limitations is 2. License: LICENSE is the full MIT text, so license is 3. Versioning and changelog: the README links an external changelog, there is no CHANGELOG file in the repo, and a docs.yml comment admits the changelog once lagged twelve versions, so versioning_changelog is 1. Maintenance responsibility: the README states it is looking for long-term maintainers and the publisher identity is unverified, so maintenance_responsibility is 1.
The CLI provides machine-readable output such as --json, --wait and session read, so output_usability is 2. Marginal value: compared with tmux it offers session state, hook notifications and iPhone mirroring, so marginal_value is 2. Cost benefit: it requires a macOS-only app, rewrites each agent's hook configuration on first launch, and the security benefit drops to zero after the sandbox capability was removed, so cost_benefit is 1.
The design docs give specific commit SHAs, file line numbers and a measured version number (claude 2.1.220), so claim_traceability is 2. Cross-source corroboration: the README, design docs and cli_compat.py corroborate each other on socket paths, exit codes and command semantics, so cross_source_corroboration is 2. Fact/inference separation: the docs clearly distinguish verified facts, open questions and proposals (e.g. launchPrefix marked NOT built), so fact_inference_separation is 2.
- All sandbox code has been removed in the current revision; agents run with the user's full host privileges and the README does not surface this security posture change.
- First launch writes hook/skill configuration into each agent's directories, and the docs admit release and dev apps clobber each other's ~/.claude/settings.json.
- Publisher identity is unverified and the README states the project is seeking long-term maintainers, so update and security response continuity is uncertain.
- Apple Silicon macOS only; Windows, Android and the TUI client remain roadmap items, so cross-platform claims should not be relied on.
- No in-repo CHANGELOG; changelog lives on an external site, weakening version traceability.