General FAQ
Straight answers to the questions people ask before they install TermFlow: what it is, what it does not do, how agents connect, licensing, supported platforms, and whether the local API is safe.
TermFlow is a cross-platform terminal emulator whose differentiator is that AI coding agents can drive it — open terminals, split panes, run commands, and read output — over local interfaces. It is currently version 0.1.0, labelled "Early access · pre-release."
Does TermFlow ship its own AI?
No. TermFlow bundles no model, no agent, and no API keys, and it sells no AI usage. You bring your own agent (Claude Code, Codex CLI, Gemini CLI, or any other MCP-capable tool) and your own provider keys.
The relationship is deliberate: agents are complements, not competitors. TermFlow is the terminal; your agent is a client that connects to it and drives it.
TermFlow is "the terminal for AI agents." It exposes the terminal as something an agent can control programmatically. Whatever agent you already pay for plugs in — TermFlow never gets between you and your model provider.
An honest note: Hosting an agent inside TermFlow (so the app itself runs the loop, via ACP) is on the roadmap, not shipped today. See "Is ACP supported?" below. Everything TermFlow does right now assumes the agent lives in your own tooling and connects in.
How does an agent connect?
Through one of two local interfaces. Every agent chooses whichever fits how it talks to tools:
| Interface | What it is | Default endpoint | Best for |
|---|---|---|---|
| MCP server | A built-in Model Context Protocol server over streamable HTTP | http://127.0.0.1:42032/mcp | Agents that speak MCP (most modern coding CLIs) |
| REST + WebSocket API | A localhost HTTP API plus a live WebSocket stream | http://127.0.0.1:42031/api and ws://127.0.0.1:42031/ws | Building your own orchestrator or custom tooling |
Under the hood a local API server (Axum, written in Rust) runs on the API port, and a separate MCP sidecar process bridges MCP clients to that API on its own port.
MCP clients with a copy-paste config. Three clients get paste-ready configuration generated by the in-app Connect an AI agent modal (Settings → Connections). For all three, the server key is auto-terminal and the URL is http://127.0.0.1:42032/mcp:
- Claude Code
- Codex CLI
- Gemini CLI
Any other MCP client (for example Cursor, Goose, or aider) also works, because they all speak MCP — point it at the same streamable-HTTP URL. There is no generated snippet for those, and aider needs an MCP wrapper.
If your agent supports MCP, use MCP — it is the least setup. Reach for REST + WebSocket only when you are building your own tool and want direct control over terminals, batch fan-out, and the live output stream.
See Connect an agent → Overview for step-by-step setup, or REST/WS alternative for the API path.
Is ACP supported?
Not yet — it is on the roadmap. ACP would let TermFlow host an agent inside the app rather than having the agent connect in from the outside. No ACP support exists in the current release. Until it lands, connect your agent over MCP or the REST/WebSocket API as described above.
Is it free? What license?
TermFlow is released under the Apache-2.0 license. Downloads are published at termflow.app/download, and release notes at termflow.app/changelog.
Which platforms are supported?
TermFlow is cross-platform. The following are recommended minimums (guidance, not an installer-enforced check):
| Platform | Recommended minimum |
|---|---|
| Windows | Windows 10 / 11 |
| macOS | macOS 12 or newer |
| Linux | glibc 2.31 or newer |
The app is built on Tauri 2 (Rust backend) with a React + xterm.js front end — it is not an Electron app.
For installer formats and the full walkthrough, see Getting started → Installation.
Is the local API secure?
Yes, in its default configuration. By default both the API server (port 42031) and the MCP server (port 42032) bind to 127.0.0.1 — the loopback address. Nothing off your machine can reach them, so in this default localhost-only mode every endpoint is intentionally unauthenticated: the trust boundary is your own machine.
The picture changes only when you deliberately turn on "Expose on local network" (Settings → Connections). Then the servers bind to all interfaces, other devices on your LAN can reach them, and a bearer token is required on every request.
| Mode | Bind address | Auth |
|---|---|---|
| Default (localhost-only) | 127.0.0.1 | None required — safe because only your machine can connect |
| Expose on local network | 0.0.0.0 | Bearer token required on every request |
The /health and /api/health endpoints are always open in both modes.
The credential is the auth token shown in Settings → Connections (masked, with reveal / copy / Rotate). Send it as Authorization: Bearer <token> on HTTP requests; WebSocket clients pass it as a ?token= query parameter because browsers cannot set WebSocket headers. Rotating the token takes effect without a server restart, and existing UI connections keep working.
An honest note: TermFlow does expose a
POST /api/auth/tokenendpoint, but its JWT is not what the auth gate checks — do not rely on it to authenticate your calls. The real credential is always the config auth token in Settings → Connections.
For the full model, see Core concepts → Local API and auth.
Next steps
- Getting started → Installation — download, install, and launch TermFlow on your OS.
- Connect an agent → Overview — wire up Claude Code, Codex, Gemini CLI, or any MCP client.