Steer a fleet of coding agents: integrated, open, and yours to reshape.
Use with any CLI coding agent (Claude Code, Codex, etc).
Coding agents chose the terminal for a reason: nothing is more flexible, and everything composes with it. But run a fleet of them in a generic terminal and the seams show: each session is an identical tab outside and a wall of text inside, no telling which one you meant to get back to, and everything an agent prints (a diff, a plan, a link) is dead text you can read but not act on. AgentTerm keeps the foundation and closes those gaps: find the right session, steer it mid-run, review what it built until it's right. Where that takes conventions that don't exist yet, it defines them as open protocols: the agent prints a review:// link, and the review opens right in the terminal.
Point at anything the agent shows you (a line of terminal output, or a diff) and say what you want; the agent makes the change.
Run many agents and AgentTerm tracks them at two levels. The ones you're actively juggling become Windows taskbar buttons, each with a working indicator and two levels of live preview showing what the session's for and what it's doing. (On a Mac, run each session full screen: each window pins its initial prompt at the top, readable in a Mission Control swipe.) The ones you've set aside are a keystroke away: open the picker and filter your past sessions by what you asked them, or what the agent called the work, while a deeper pass searches every prompt you typed; resume any of them (the hero above). No hunting through look-alike terminals, and no back-and-forth with an agent to find it for you: the filter is instant.
Add the companion viewer (agent-stream-hub) to your phone's home screen as a web app. It shows which agents need you across all your machines ("your turn"), drills into any live session, and lets you steer it by voice: speak, and your words reach the agent as text it knows came from voice, so it repairs the mishears and false starts against the session before acting. That's the part phone dictation can't do: with no view of your code it hears "pie test" and leaves it there; the agent turns it into pytest. Type instead, or drive its menus key-by-key, even from a network that only allows outbound HTTPS.
Agents explain themselves by quoting file:line and symbols. Click any reference the agent mentions (not just files it edited) and your IDE jumps to that exact line so you can verify the claim. It works with URLs too.
Your IDE editor stays read-only by default, so you don't have to worry about a stray keystroke. (Flip a setting on the rare occasion you want to edit directly.)
Paste images and drag-drop files straight into a prompt · fuzzy-search the whole scrollback · click a resource path (.png, .pdf, .csv, …) to open it in your OS default app · right-click to quote a selection into the prompt. Ctrl+K / Cmd+K inserts your IDE's current location into the prompt.
Most of what an agent tells you scrolls past in the terminal. Select any of it (a line, a claim, a command it's about to run) and comment; your note goes back to the agent with the exact text quoted, so a few words are enough. (Works on the rendered markdown viewer too.)
…and what reaches the agent: your words, with the exact context quoted:
When the agent finishes, it prepares your review: it hands you the parts that need your judgment, ordered and explained with trade-offs flagged, and leaves out what doesn't need it: the mechanical noise (renames, imports, boilerplate) and what you already settled during the session. Comment inline, on the code and on its reasoning; it edits, replies in the thread, and the review re-renders in place.
None of this is code-specific. Point an agent at a writing project (essays, notes, research, docs) and the same review-and-comment loop works: your materials are organized as a repo the agent uses as needed and edits for you, and the markdown viewer shows its changes live in the rendered view. You stay in the reading view and comment inline, never touching raw markdown or switching edit/preview modes.
Everything here is modular and agent-sized: the terminal is 18k lines of plain JS (MIT), and the IDE plugin, phone viewer, and review spec are each their own small repo. Take the piece you want and make it your own. Share what you build, and pull in what others make.
Runs on macOS and Windows. I build AgentTerm on a Mac and use it for work on Windows, so both are first-class. Live-session switching is integrated with the Windows taskbar. On a Mac, give each session its own full screen or desktop: the initial prompt stays pinned at the top of the window, so a Mission Control swipe shows every session, readable (a more Mac-optimized UX is welcome). IDE navigation targets JetBrains today, but the protocol's open, so other editors and code viewers are easy to add. PRs welcome on both fronts. All MIT, all free: no telemetry, no upsell.
- Append-only, single-pass decoration engine: pattern detection runs incrementally on new output (O(new rows), not O(total)), so thousands of live links cost ~nothing as the stream grows.
- Open IDE protocol: navigation is newline-delimited JSON over a local TCP socket (a backend plugin resolves files/symbols + moves the caret on
8765; a frontend plugin scrolls the viewport + reports the caret on8766). Any editor can implement it; see the API spec. JetBrains today; VS Code / Neovim / Emacs welcome. - Cross-platform shell: WSL on Windows, native PTY on macOS.
Each capability is a small, documented protocol, not a feature sealed in the app.
- IDE navigation: the local-socket protocol above; any editor can implement it.
- Review: the agent writes a markdown review that organizes and explains the diff, per the open selfreview spec; agent-term renders it and carries your inline comments back to the agent. Other hosts welcome.
- Viewers by URL: one convention routes whatever the agent prints. A
review://link auto-opens the rendered review,http(s)opens the embedded web viewer, and a markdown file renders with the same inline commenting. The URL is the whole API: an agent needs no SDK to drive the host; it prints a line of text. - Fleet coordination: a lock / ownership / HEAD-guard convention so many agents can share one checkout without clobbering each other (agent-lock).
- Conventions by filename: agents bind to docs by name, resolving to the nearest such file up the directory tree (
commit-message.md, the kits' config; agent-cicd's CONFIG shows the rule). No central config. agent-term itself just listens for the references: aproceed-by-branching.mdgoing by is its cue to start watching the work branch and lock. - Voice input: a source injects a raw speech-to-text transcript prefixed with a pointer to a vendored guide (voice-to-agent); the agent, holding the whole session, reconstructs the dictation against context and acts, so no hub-side model has to.
The terminal becomes the host that brokers the work between you and the agent.
- Windows: download the installer (
AgentTerm-x.x.x-setup.exe) from the Releases page. Requires WSL; your agents run in it. - macOS (from source):
git clone https://github.com/yunxin/agent-term && cd agent-term && npm install && npm run start
These are the paths we run daily and verify with each release. If setup snags anywhere, ask your agent to fix it.
- IDE plugins (for click-to-IDE): the two
intellij-navigatorzips are on the same Releases page, with step-by-step install in the release notes. - Phone/web viewer: self-host agent-stream-hub and add it to your home screen.
- agent-term (this repo): the terminal.
- agent-stream-hub: the phone/web viewer + relay.
- intellij-navigator: JetBrains plugins (file/symbol nav + the read-only guard).
Plus the open specs (bring your own host/agent):
- selfreview: the markdown review format the review loop runs on.
- agent-lock: a lock so several agents share one git checkout without clobbering each other (the working tree, branches, and the host-global ports their tests grab).
- agent-cicd: runbooks that drive a Gerrit/Jenkins/SonarQube change to green, serialized through agent-lock; the kits composing in practice.
- voice-to-agent: the vendored guide that tells an agent to reconstruct and act on a raw speech-to-text transcript (what the phone's voice input runs on).
Built with Electron · xterm.js (WebGL) · node-pty · esbuild. MIT licensed. A ⭐ helps others find it.