Use MCP to let AI operate Claude Code, Codex, OpenCode, Pi Agent, Grok Build, and Antigravity terminals.
Give a connected AI an instruction. Through Termexo, it can find another agent's terminal, send a prompt, submit it, and read the actual reply. Watch the process or take over in the same Windows or macOS workbench, with working, approval, and completion states in view.
All six agents run in real terminals on your PC. Termexo also organizes projects into workspaces, resumes native sessions, and lets you reconnect from your phone through your own relay, a trusted LAN, or a VPN.
Watch 30 seconds of real v0.10.6 desktop use: completion notifications, return to a session, reply, and review two Antigravity sessions side by side. Includes Chinese and English captions; waiting intervals are cut.
Download for Windows and macOS · Watch the demo · Share first-use feedback
| Let AI operate other agents | Know who needs you | Continue from your phone |
|---|
| Find terminals, send prompts, submit them, and read replies through MCP. | View real terminals side by side, grouped by project, and spot an agent waiting for input or approval. | Connect across networks through a self-hosted relay, or directly over a trusted LAN or VPN. |
The problem it solves
With several AI coding tools running, you spend time sending requests, checking progress, and copying replies between windows. Termexo's local MCP lets a connected AI handle those terminal operations. Workspaces, the task board, and status alerts help you follow the process; native sessions and handoff packages help you resume work, and remote access lets you continue away from your desk.
Scenarios for individuals and enterprise developers
| Scenario | Individual developers | Enterprise team members | How Termexo helps |
|---|
| Multiple projects | Maintain work projects, a side product, and open-source repositories | Organize each business project's development environment | Workspaces group project folders, terminals, layouts, and configuration, reducing window switching. |
| Agent task allocation and progress | Assign agents to implementation, tests, and code review | Engineers assign tasks, follow progress, and approve results | Side-by-side terminals, a task board, status indicators, and approval reminders reduce repeated output checks. |
| Resuming and handing off work | Resume yesterday's session or continue with another agent | Summarize goals, progress, and next steps to help another engineer take over | Search and resume supported native sessions; carry task context in a handoff package. |
| Long tasks and remote access | Check progress, answer approvals, and send instructions from your phone | Leave tasks running on a development PC and reconnect through a controlled entry point | A self-hosted relay or trusted LAN / VPN connects to the same running terminal; the host PC must stay on. |
| Models and account configuration | Manage subscriptions and API profiles; choose a model for each task | Manage providers, compatible gateways, and network configuration | Model, account, and network profiles in one place, with quota visibility for supported providers. |
| Control over the development environment | Run projects and agents on your own PC and host your own remote entry point | Run the workbench in an environment controlled by your organization and manage your relay | Workbench state stays local and remote access is optional; agent and model configuration determines where model requests go. |
Available today and planned: These scenarios center on individuals and team members operating their own workbenches, with people assigning tasks and handling approvals. Shared workspaces, granular permissions, centralized audit, and broader automatic orchestration are part of the long-term product direction, not a ready-made enterprise administration platform.
Get started on Windows or macOS
- Download v0.11.0 — choose Windows EXE/MSI or the Mac DMG for Apple Silicon (
aarch64) or Intel (x64). No Rust or build tools needed.
- Open Termexo and create a workspace for a project folder on your PC.
- Start a terminal with an installed agent. If none is installed, check detection and install a CLI from Settings.
- Run a task and watch its status in the terminal tab and right panel. Enable phone access later if you need it.
Already have Node.js 18.18+? Run:
npx termexo@latest
Windows requires Windows 10 build 17763+ and WebView2 Chromium 111+. Mac builds require macOS 12+ on Apple Silicon or Intel. The same npm package includes all three applications; on Mac, the matching complete app is cached and opened through Launch Services.
Windows code signing is awaiting SignPath approval. Mac builds use ad-hoc signing and are not notarized; macOS may require allowing the app in Privacy & Security. Broader Mac GUI testing is still needed.
Install and configure your chosen agent CLI and model access; Termexo does not include a model subscription.
MIT licensed. No Termexo account required.
Let one AI operate another: start in three steps
MCP connects AI to Termexo. Ask in everyday language; no tool names or code required. Install and sign in to the agent CLIs you want to use, then:
- Open Settings → AI control (MCP). Enable the local server, keep automatic connection checked, and allow terminal access; also allow task access if you want to create and execute tasks. Click Apply and check for Running.
- Start a new agent terminal in Termexo, or restart an existing one. Claude Code, Codex, OpenCode, Pi Agent, Grok Build, and Antigravity CLI support automatic connection, with no address, token, or configuration file to copy.
- Send this to the AI terminal and check that it returns the actual workspaces and terminals on your PC:
Use Termexo MCP to list my workspaces and terminals, and tell me which are running. Do not change anything yet.
A diagram of implemented capabilities, not a software screenshot. Keep the Termexo desktop running during use.
For a first exchange, open an OpenCode terminal in Termexo, then tell the connected AI:
Use Termexo MCP to find the running OpenCode terminal in the current workspace. Send hi, submit Enter, and read its reply. If several terminals match, list their names so I can choose.
After that, try a project task:
Use Termexo MCP to create a Claude Code task in the current project titled “Map the project.” Use its configured default model. Read the project and explain its main folders, how to run it, and its test entry points without changing files. Start the task, inspect the terminal to confirm the prompt was submitted, and summarize the actual output.
Existing-terminal interaction works with all six agent types. Task-board execution supports Claude Code, Codex, OpenCode, Pi Agent, and Grok Build. Start Antigravity in the workbench first, then operate its terminal through MCP. The terminal creation tool creates a Shell.
“Sent” and “started” do not mean “finished.” Continue reading output and task status, and check code changes and test results as the task requires. MCP is off by default and available only on the host PC; phone remote access is a separate feature, and the agent's own tool approvals still apply.
Online illustrated guide · MCP reference and troubleshooting
From your desk to your phone, through your own relay
- Open a project on your PC and start Claude Code, Codex, OpenCode, Antigravity, or Grok Build.
- Follow the termexo-relay documentation to deploy an HTTPS relay reachable by both devices, or use an entry point from its administrator.
- Enable Remote Access in Settings, enter the relay address, and enroll with an enrollment code or relay account.
- Open the generated relay link or scan its QR code on your phone. Complete the required relay login and desktop access-token check to reconnect to your terminal.
The desktop opens an outbound tunnel, with no public IP or router port forwarding required. Keep the PC on with Termexo running and connected to the relay. Direct access over a trusted LAN or controlled VPN is also available.
Relay login and the desktop access token are independent checks. After the v2 handshake, session frames use AES-256-GCM; the relay forwards encrypted terminal sessions. The relay has Linux, macOS and Windows x64 / arm64 binaries and container deployment; Termexo desktop packages are available for Windows x64 and macOS Apple Silicon / Intel.
The image shows the mobile interface. Read the phone connection guide for the complete setup.
Remote access is off by default. The relay browser entry point requires HTTPS; direct desktop access uses self-signed HTTPS by default.
Keep the token private. Closing Termexo or stopping the PC ends the running processes.
Latest release
v0.11.0 adds multiple content preview tabs with syntax highlighting, smoother saved-action discovery, third-party notifications, and macOS builds. Desktop installers and the Windows/macOS npm package are built and published by GitHub Actions.
Full changelog.
If Termexo helps your workflow, a Star on this repository helps other developers discover it.
Found a problem? Open an issue with your operating system, CPU architecture and reproduction steps.
Trying it for the first time? Tell us what worked or where you got stuck. A short report is enough.
One Ring is built into Termexo, including its engine and runtime. No separate plugin, Node setup, or directory configuration is required. See the built-in orchestration guide (Chinese).
What Works Today
Termexo is local by default: it has no account, cloud service, or required sync. Workspace
state stays in local SQLite storage, credentials stay in Windows Credential Manager / macOS Keychain, and
Claude/Codex session histories are read-only. The agent CLIs still connect to the providers
you configure under their own terms and privacy policies.
The interface is available in Simplified Chinese, English, Spanish, French, German, Japanese,
and Korean. It follows the system language automatically, or you can choose a language from
the main toolbar and keep that choice across restarts.
Why Termexo
AI coding tools usually run in isolated terminals and sessions. As the number of projects
grows, developers have to remember:
- which terminal belongs to which project, branch, and agent;
- which sessions are running, waiting for input, or waiting for approval;
- how to resume a specific Claude session;
- how model, endpoint, API key, and MCP configurations fit together;
- which parts of a workspace can actually be restored after an application restart.
Termexo uses the Workspace as its organizing unit and turns this scattered state into
a local control plane that is observable, recoverable, and extensible.
Pi Agent
Termexo supports detecting, installing and launching Pi Coding Agent, status tracking, native session resume, task-board execution and remote terminal operation.
npm install -g --ignore-scripts @earendil-works/pi-coding-agent
pi
Run /login in Pi to configure a provider, then select Pi Agent from Termexo's new-terminal menu. Leave the model blank to use Pi's configuration, or enter provider/model. The continue option uses --continue; Session Center resolves a native session ID to its transcript file before launching --session.
Termexo stores its extension in its own runtime directory and injects it with --extension. Pi transcripts, credentials, model settings and extension configuration remain read-only. Current Pi releases can register Termexo MCP through the extension; older releases without registerMcpServer retain launch, session and status support. Pi has no per-tool confirmation CLI flag, so its launch dialog does not offer one.
Set TERMEXO_PI_PATH to override the executable. Session discovery respects PI_CODING_AGENT_DIR (default ~/.pi/agent) and PI_CODING_AGENT_SESSION_DIR.
Implemented Features
| Capability | Current implementation |
|---|
| Workspace management | Create, rename, theme, drag to reorder, and switch workspaces; persist paths, layouts, and terminal configuration |
| Multi-terminal workbench | Unlimited tabs, explicit pane selection, configurable 1–6 row/column grids, pane/workspace maximize, and real PTYs |
| Content previews | Multiple file, image or website tabs, adjustable width, whitespace-preserving code highlighting and MCP opening |
| Saved project actions | Discover, select all, edit and deduplicate in one window, with a fixed confirmation footer |
| Third-party notifications | Toolbar master switch and messages with time/session context; desktop WeChat delivery on Windows |
| Agent detection | Detect the Claude Code, Codex, OpenCode, Pi Agent, Antigravity, and Grok Build executables, their versions, and health on Windows and macOS |
| Start agent sessions | Launch Claude, Codex, OpenCode, Pi Agent, Antigravity, or Grok Build with a working directory and the available account, model, and confirmation options for that CLI |
| Session center | Read-only discovery of Claude/Codex/OpenCode/Pi/Antigravity/Grok Build sessions, search, workspace filtering, native resume, and reclaim of a Claude session the CLI still holds open |
| Agent status tracking | Isolated hooks per terminal for thinking, tool use, approval, user input, completion, and failure states |
| MCP agent control | Automatic local MCP connection for all six agents; a connected AI can find real terminals, send prompts or control keys, and read output. Task tools support Claude Code, Codex, OpenCode, Pi Agent, and Grok Build |
| Model and MCP profiles | Manage endpoints, keys, and MCP configuration; switch Claude CLI across Anthropic-compatible backends |
| Network and npm profiles | Scope HTTP/HTTPS/SOCKS and npm settings globally or per workspace, test reachability, and inject them at launch |
| Account management | Manage multiple isolated Claude and ChatGPT/Codex logins, defaults, authentication status, and launch-time choice |
| Managed CLI lifecycle | Pick an agent to install or check for updates. Termexo chooses the installer, verifies the result, and offers recovery steps; version selection and logs stay in advanced options |
| Allowance visibility | Show reported quota where supported, including Grok Build's exhausted free allowance; unknown percentages remain unavailable |
Design Goals
- Local first — Project paths, terminals, session indexes, and configuration stay on
the local machine by default. Termexo does not require a Termexo cloud service.
- Preserve native agent semantics — Prefer native session and configuration
mechanisms instead of pretending that a terminated process is still alive.
- Coordinate terminals, do not replace them — Termexo provides the workbench,
state, and orchestration layer. Commands still run inside real PTYs and agents.
- Make agent state observable — Map agent-specific events into common running,
thinking, input, approval, completed, and failed states.
- Keep security boundaries explicit — Secrets belong in the operating-system
credential store, not in SQLite, snapshots, hook payloads, or logs.
- Grow into a multi-agent architecture — Evolve around adapters, PTY, hooks,
snapshots, and routing boundaries so more CLIs can be added without rebuilding the core.
- Extend workspaces across trusted devices — Add sharing, remote access, mobile
approvals, and collaboration without weakening local ownership or security boundaries.
Current Boundaries
- macOS updates use a new DMG or
npm install --global termexo@latest; in-app automatic updates and Windows system-proxy discovery are not provided on Mac.
- Windows and macOS builds support detection and launch for all six Agent types, with native sessions discoverable and resumable from the session center. macOS runtime coverage varies by Agent; see the release notes for known limits. Status events and launch options vary by CLI; compatible-provider model switching currently applies to Claude terminals.
- Termexo restores terminal configuration after an app restart. An exited operating-system process is not treated as still running; resume a historical agent session explicitly from the session center.
- Native session files remain read-only. Cross-agent handoff uses a redacted context package rather than rewriting a provider's private transcript.
- Git session changes are repository deltas observed since terminal start; concurrent editors or other terminals may contribute.
- Cross-network phone access needs a running PC connected to a self-hosted relay. Shared workspaces, granular permissions, and centralized audit are long-term plans.
See Termexo.md for the complete product plan and
V0.2 architecture for current technical boundaries.
Build from source
These requirements are for contributors building Termexo, not for installing the release.
Requirements
macOS source builds require macOS 12+ and Xcode command-line tools. The Windows-specific runtime requirements below do not apply to Mac builds.
- Windows 10 build 17763 (October 2018) or newer, the first to carry the pseudo console the
terminals run on;
- the WebView2 runtime at Chromium 111 or newer — the interface states its colours through
color-mix() and oklch(), which older runtimes drop. Termexo says so and offers the download
when it finds an older one, and Windows 11 and the installers both provide a current runtime;
- Node.js
^22.22.3, ^24.15.0, or >=26.0.0;
- Rust stable, with Visual Studio C++ Build Tools on Windows or Xcode command-line tools on macOS;
- a local installation of at least one agent CLI (Termexo can also install and upgrade them).
1. Clone and install frontend dependencies
git clone https://github.com/gemron/Termexo.git
cd Termexo
npm --prefix apps/desktop-ui install
2. Run the browser preview
npm run dev
Open http://127.0.0.1:4200. Browser mode uses a simulated terminal with help,
status, git status, and clear, making it suitable for UI development and review.
3. Run the desktop application
npm run tauri:dev
On macOS, use npm run tauri:dev:mac for development and npm run tauri:build:mac for packaging. GitHub Actions also builds both Mac architectures and publishes the npm package.
Desktop mode uses real PTYs. If Claude Code is not available on PATH, specify it:
$env:TERMEXO_CLAUDE_PATH = "C:\path\to\claude.exe"
npm run tauri:dev
How It Works
flowchart LR
UI["Angular Desktop UI"]
IPC["Tauri Commands"]
PTY["PTY Service"]
Adapters["Agent Adapters"]
Hooks["Hooks / Event Pipeline"]
DB[("SQLite")]
Vault["Windows Credential Manager / macOS Keychain"]
Agents["Claude Code / Codex"]
UI <--> IPC
IPC --> PTY
PTY --> Agents
IPC --> Adapters
Adapters --> Agents
Agents --> Hooks
Hooks --> DB
IPC <--> DB
IPC --> Vault
- Angular UI — workspaces, terminal layouts, session center, settings, and Inspector.
- Tauri Commands — a minimal IPC boundary between the frontend and desktop core.
- PTY Service — creates, writes to, resizes, and closes real terminal processes.
- Agent Adapters — Claude/Codex installation detection, read-only session scanning, and native launch/resume.
- Hooks Pipeline — receives agent lifecycle events, deduplicates them, and maps common terminal states.
- SQLite / Credential Manager — stores structured local data and sensitive credentials separately.
Data and Security
| Data | Storage | Policy |
|---|
| Workspaces and terminal configuration | SQLite | Local persistence |
| Claude/Codex session index | SQLite | Upserted from read-only native session files |
| Agent events | JSONL spool + SQLite | Deduplicated by event_key |
| Model and MCP profiles | SQLite | Plaintext API keys never enter the database |
| Prompt assets and handoff packages | SQLite | Common credentials are redacted before save |
| API keys | Windows Credential Manager / macOS Keychain | The frontend can read only hasCredential |
| Native agent sessions | Claude/Codex data directories | Read-only; never modified or deleted |
For compatibility with early installations, the database filename and some internal Tauri
identifiers still use a legacy name. This does not affect the Termexo product name or new
TERMEXO_* environment variables.
Roadmap
| Version | Delivered scope | Status |
|---|
| V0.1–0.5 | Workspaces, real terminals, native session resume, model profiles, and handoff | Released |
| V0.6 | OpenCode, task board, and agent confirmation options | Released |
| V0.7 | Custom window chrome, GPU terminal rendering, and account workflows | Released |
| V0.8.0–0.8.4 | Phone access, first-run guidance, input latency and mobile scrolling improvements | Released |
| V0.8.5 | Bundled ConPTY and WebView2 startup diagnostics | Released |
| V0.8.6 | Screen-accurate terminal replay and reconnect stability | Released |
| V0.8.7 | A screen parser that cannot strand a terminal | Released |
| V0.8.8 | A storage panel, and data that can be moved | Released |
| V0.9.0 | Antigravity as a fourth agent, and vendor installers | Released |
| V0.10.0 | A self-hosted relay, and end-to-end encrypted remote access | Released |
| V0.10.1 | Phone keypad, keyboard-aware remote pages, and settings that keep unsaved edits | Released |
| V0.10.2 | Reliable agent status and notifications, and a multilingual task board | Released |
| V0.10.3 | Clean agent prompts with several viewers, Ctrl+click links, and copying from OpenCode | Released |
| V0.10.4 | Grok Build, reliable Git changes, quieter terminals, and workspace ordering | Released |
| V0.10.5 | Todo board persistence and snapshot transfer, and lightweight Antigravity quota queries | Released |
| V0.10.6 | OpenCode v2 proxy reliability and current CLI installer | Shipped |
| V0.10.7 | Guided first run, CLI readiness and reliable project creation | Released |
| V0.10.8 | Accurate agent status and workspace state indicators | Released |
| V0.10.9 | Compact agent states, completion confirmation, and verified branch display | Released |
| V0.10.10 | Local MCP control and automatic connection for five Agents |
See open issues for ongoing work and
CHANGELOG.md for released changes. Planned work has no promised delivery date.
Repository Layout
Termexo/
├── apps/desktop-ui/ # Angular desktop UI and browser preview
├── src-tauri/ # Rust core, PTY, agents, hooks, database, and commands
├── docs/architecture/ # Architecture notes for implemented versions
├── docs/images/ # README screenshots
└── Termexo.md # Product design and long-term roadmap
Development and Verification
npm run build
npm test
cargo test --manifest-path src-tauri/Cargo.toml
npm --prefix apps/desktop-ui run e2e:smoke
npm run tauri:build
With the local development server running, regenerate the README screenshots with:
npm run capture:readme
Contributing
Use Issues to report bugs, discuss design
decisions, or propose features. Before submitting code, make sure the change fits the
current release scope and add tests for behavior changes.
Code signing policy
An application to the free open-source SignPath Foundation program was submitted
on 27 October 2026 and is awaiting review. Read the Code signing policy
and Privacy and network connections. Current build metadata records
whether signatures were requested and verified.
License
Released under the MIT License.
