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

At a glance

Works with
Universal · cross-platformCodex · Claude Code
You'll need
macOS 14+termiod daemonSSH (for remote sessions)Shell / CLINetwork accessLocal filesystem
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.

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.

  1. Developers running Codex, Claude Code, and several shells in parallel who need to be interrupted the moment one agent blocks on a permission prompt.
  2. Teams that want one git worktree per parallel task and a sidebar that shows each worktree's sessions and their live status.
  3. 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.
  4. 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.
  5. Builders orchestrating multiple agents, where one agent spawns a sibling, hands it a task, and reads back the reply through the termio CLI.
  6. 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/termio

For 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 termio

How 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 --wait

Enable 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?

Pros
  • 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.
Limitations
  • 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?

FollowAgents source review · FARS-2.1
Major gaps
51/ 100 5-point scale 2.6 / 5
Trust 11/29
Reliability 8/14
Adaptability 10/18
Convention 10/18
Effectiveness 7/13
Verifiability 5/8
Why each dimension lost points
Trust11 / 29 · 1.9/5

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.

Reliability8 / 14 · 2.9/5

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.

Adaptability10 / 18 · 2.8/5

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.

Convention10 / 18 · 2.8/5

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.

Effectiveness7 / 13 · 2.7/5

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.

Verifiability5 / 8 · 3.1/5

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.

Risks and how to mitigate them
  • 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.
Evidence confidence: Low Reviewed Nov 05, 2026 Reviewed revision 819658751635
See the full review method →

FAQ

Does quitting the Mac app interrupt the agents that are running?
No. Each session's shell lives in the termiod daemon, so quitting the app only detaches the client; agents and scrollback are preserved. Only Close Session (⌘W) actually ends a session.
What has to be installed on a remote VPS?
Nothing up front. Termio reads your existing ~/.ssh/config without rewriting it and, from Settings ▸ Devices ▸ Set Up, copies one binary into ~/.local/bin over SSH, starts the daemon, and installs the agents' hooks — as long as you can ssh to the Linux host.
Does Termio call an LLM itself, and do I need an API key?
No. Termio is the environment; the actual models come from the CLI agents you already installed and configured (for example Claude Code or Codex), which manage their own credentials. Termio hosts the sessions and aggregates their status.
Does the iPhone app connect to my Mac or to the server?
It attaches by wss directly to whichever machine runs termiod, not through the Mac. A session on a VPS and one on your laptop are the same kind of object to the phone.
Can it be driven entirely from the command line?
Yes, via the termio CLI: session list, spawn, run, send, read, watch, focus, close, and notify, with --json for machine-readable output and --wait to block until a turn settles. A standalone TUI client is still on the roadmap.
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents