⚡ Termcp

English | 中文

Introduction

Termcp is an AI-native terminal platform: many hosts and many sessions at once, fully visualized. Those sessions are managed and maintained by humans and AI together, each side free to take over from or hand back to the other at any time; connection profiles are maintained independently by the platform, so an Agent can use a connection without ever reading its credentials.

• You (human) — a browser-based Web UI for live observation and instant takeover of any session;
• AI Agents — drive the same real terminals through MCP or SKILLS;
• Scripts / programs — a full REST API plus WebSocket channel for programmatic session, forward, and file operations.

On the platform layer, long-lived sessions with read-only replay, parallel multi-host / multi-session orchestration, and a full SSH connection lifecycle keep the whole loop observable, programmable, and easy to hand off between human and AI. Cross-platform and cloud-native, written in pure Go with no CGO: it ships as a single lightweight binary that runs persistently with low overhead, and goroutine concurrency keeps it high-throughput and low-latency.

Demo Video

https://github.com/user-attachments/assets/d06a3c36-250a-4eeb-aefa-e80d13d1551c

Why Termcp

Multi-session visual management

A powerful Web UI manages many hosts and many sessions in one place: start it locally with a single command or deploy the container to the cloud — the browser gets the same interface either way.

• Multi-session dashboard: every running session listed by name, switch or take over at any time.
• Real-time observation: watch htop's live display, vim's editing process, or an installer's prompts in the browser, just like a local terminal.
• Tabs and tiling workspace: one SSH session can open several shells, each its own tab; sessions can also be tiled side by side and tracked together.
• Port forwarding at a glance: local/remote ports and protocols for every session, all in one panel.
• File management: browse, upload, download, rename and create directories from the UI.
• Centralized connection templates: a unified SSH config store; the Agent opens sessions by profile name and never reads the config itself.
• Read-only replay of closed sessions: output stays browsable after a session closes, crashes, or survives a restart.

AI-native by design

Seamless human–agent interaction and pair operation: the Agent is a standing user of the terminal, alongside you and your scripts.

An Agent natively runs only one-shot commands, while real work is largely multi-turn interaction — SSH login needs a password first, a Python REPL is debugged line by line, an installer asks [Y/n], tools like top/htop/impacket need a terminal. Termcp hands the Agent a real terminal: one session stays alive and gets reused, so TUIs, REPLs, GDB, msfconsole and vim can be driven continuously the way a human would — through MCP or through the instance's own Agent Skill over plain curl.

• One session layer, peer entrances. MCP, SKILLS and REST/WebSocket sit at the same level as the Web UI, sharing the same real sessions. You can watch every Agent step in the browser and take over at any time; the Agent in turn can pause and hand a password/MFA prompt to you.
• Built for token and turn budgets. Tool schemas are compact and can be deferred-loaded (see docs/mcp-tools.md); shell_output pages by tail/offset cursors so only the slices you ask for ever enter the context window; shell_notify sends a bare wake-up signal.
• Self-describing instances. Every running Termcp serves its own /api.md and /skills.md (no token needed) and registers them as MCP resources plus a learn-api prompt, so a fresh Agent can drive this exact instance straight away, using only these two files.
• Secrets stay server-side. Passwords, private keys and passphrases written through ssh_config are stored only on the host, and the MCP read interface returns profile names only; the SSH-config write tools stay off unless the operator opts in with --mcp-manage-ssh-configs.
• Failure-tolerant, resumable work. A closed, crashed or restarted session stays in the session list as a read-only DEAD tile with its output readable, so an Agent (or you) can pick up from the interrupted state; reconnecting the same termcp://<entry> starts a fresh session.
• Humans always keep the option to step in. notify_user reaches you directly, privileged prompts are meant to be typed by you in the Web UI, and writes to one shell are serialized, so a human and an Agent can type on the same terminal with their inputs applied in order.

Quick Navigation

• Features
• Quick Start
• Usage
• Docker Deployment
• Connecting AI Clients (MCP)
• Agent Skill (curl-only, no MCP)
• Connecting Scripts / Programs (REST API)
• Examples
• Tool Reference
• Known Limitations & Security Model

Features