Overview
This section covers the three companion tools that grow up around TermFlow for multi-agent work: the tk CLI (project scaffolding), terminal-monitor (a real monitoring dashboard), and agent-monitor (an experimental orchestration sample).
The honest framing
TermFlow itself is the product you run: a terminal emulator that AI coding agents can drive — opening terminals, splitting panes, running commands, and reading output — through a built-in MCP server and a local REST + WebSocket API. That is where the multi-agent story actually lives. You point one or more agents at a running TermFlow, and they work in its terminals.
The tools in this section are companions, not part of the core app. They help you set up, observe, or automate that setup — but none of them is required to run agents against TermFlow, and they sit at very different levels of polish. Read this page to understand what each one is (and is not) before you invest time in it.
TermFlow ships no AI and no model keys. You bring your own agent (Claude Code, Codex CLI, Gemini CLI, or another MCP client) and your own credentials. These companion tools do not change that — they orchestrate around your agents, they don't replace them.
The three companion tools
| Tool | What it is | Maturity | Learn more |
|---|---|---|---|
tk CLI | A project scaffolder (tk init) that lays down an .agent-comms/ folder and agent config files so a team of agents can coordinate through the filesystem. | Working, but its generated MCP config is stale. | tk CLI |
| terminal-monitor | A real React dashboard (browser UI on port 42030) that connects to headless TermFlow instances over WebSocket to monitor and control their terminals. | Real, shipping companion app. | terminal-monitor |
| agent-monitor | An experimental orchestration sample that watches running CLIs and chains prompts between them. | Experimental reference sample. | agent-monitor |
tk CLI — scaffolding for agent teams
tk init (from the terminal-kit package) scaffolds a .agent-comms/ directory — with requests/, responses/, status/, shared/, findings/ subfolders and a README — plus starter agent config (.mcp.json, .gemini/settings.json, .claude/settings.local.json) and a docs/multi-team-agent-workflow.md guide (skipped with --no-docs). It gives a group of agents a shared, file-based place to hand work back and forth.
An honest note: The
.mcp.jsonthattk initgenerates is stale — it points at a placeholder stdio path, uses an old server key, and lists an outdated tool set. Usetk initfor the.agent-comms/scaffolding, but wire up MCP through the in-app Connect modal (Settings → Connections → "Connect an AI agent"), not the filetkwrites. See tk CLI for details.
terminal-monitor — a real dashboard
terminal-monitor is a separate React app that runs its own browser UI (default http://127.0.0.1:42030, behind a login) and connects to one or more headless TermFlow instances over WebSocket. Use it to watch terminals and send input across instances from a single screen. This is a genuine companion tool — see terminal-monitor for how to start it and what it can do.
agent-monitor — an experimental sample
agent-monitor is an experimental orchestration sample (v2.0.0) that watches running CLIs and chains prompts between them. Treat it as a reference/harness you can learn from and adapt — not a polished, supported feature.
An honest note: agent-monitor uses legacy ports (
3001and9876) and expects a freshly minted token, so it does not line up with TermFlow's default prod ports (API42031, MCP42032) out of the box. Read agent-monitor before wiring it in, and expect to adjust configuration.
Which one do I reach for?
- Setting up a multi-agent project? Start with the
tkCLI for the.agent-comms/scaffolding, then connect agents via the in-app modal. - Want to watch or drive terminals across headless instances? Use terminal-monitor.
- Building your own orchestrator? Study agent-monitor as a reference, but prefer building directly on TermFlow's REST + WebSocket API for anything you intend to depend on.
Every companion here is just a client of TermFlow's local interfaces. If you understand the MCP server and the local API and auth model, you can build your own orchestration and treat these tools as examples.
Next steps
- tk CLI — scaffold an agent-team project with
tk init. - Connect an agent — point your first agent at a running TermFlow.