termesh

A terminal-native, agent-first IDE. The AI coding agent shares your open buffers, diagnostics, git diff and terminal output — and proposes edits as reviewable inline diffs, not a chat box bolted to the side.

GitHub Download 0.1.5 crates.io cargo install termesh --locked

Why this exists

The terminal already has excellent focused tools. Rebuilding those adds nothing. The part nobody has built well in a terminal is the agent being a structural peer rather than a sidebar.

The agent edits through the same spine you do

Human and agent drive one action registry and one transaction-based edit path. Proposals arrive as diffs in the editor — accept, reject, or accept per hunk. Nothing reaches disk until you accept, and a hunk you edited inside is flagged rather than overwritten.

Agent-agnostic, by protocol

An ACP client: bring your own agent and model, no vendor assumed or bundled. Inline diff review engages when the agent checks with the client before touching the file — verified against Codex in read-only and opencode with permission.edit: "ask", where rejecting leaves the file byte-identical. Agents that edit first still show the diff, but as a record rather than a gate; the support boundaries say which is which.

It follows you onto a bare SSH box

GUI agent IDEs cannot. This runs anywhere a terminal runs — SSH, containers, minimal servers — and degrades cleanly to 16 colours or none.

What it actually looks like

A real session: opening a project, quick-opening a file, reviewing git changes, and a rust-analyzer diagnostic arriving. Recorded by driving the editor with real key chords, so it can be regenerated rather than going stale.

termesh opening a project, quick-opening a file, showing the Git Changes overlay, and reporting a rust-analyzer diagnostic
A rust-analyzer diagnostic marked in the gutter with the offending line underlined, and the error count in the status bar
The language server reports; the gutter marks it, the line is underlined, and the status bar counts it. The agent sees the same diagnostics you do.
An agent asking permission to edit pricing.rs, with the proposed line marked in the editor gutter and accept/reject in the agent pane
The agent has asked; the change is marked in the gutter; the file on disk is untouched. Reject and it stays that way — the review is a gate, not a notification.
The Git Changes overlay listing a modified file, with stage, unstage, commit and branch actions on the footer
Git runs on its own worker and never blocks rendering. Commits use the index as an exact boundary — no implicit add.

Nothing above needs taking on trust. The same interface renders headlessly — no terminal, no language server, no agent — and comes out byte-identical on any machine: 

termesh --dump-frame . --lsp-demo        # a diagnostic, a hover, the error count
termesh --dump-frame . --git-demo        # conflicts, staged and worktree groups
termesh --dump-frame . --agent-demo --open README.md

Install

cargo install termesh --locked

Or take a signed binary from the latest release — Linux (x86-64, AArch64), macOS (Intel, Apple Silicon) and Windows (x86-64), each with SHA256SUMS. The macOS builds are signed with a Developer ID certificate and notarized, so a browser download runs without a Gatekeeper prompt. Requires Rust 1.88 or newer to build from source. 

termesh .                    # open a project
termesh                      # reopen the last one
termesh --dump-frame . --lsp-demo    # see a frame without a TTY

This is a public beta, and the edges are written down

The support boundaries say exactly what is tested and what is not, rather than leaving you to find out. The ones most likely to matter: