Tools

Start a pane’s configured process; accepts no command payload. Create a detached session and return it with its first window and pane, so you can start working without listing anything first.

Inspect tmux metadata; accepts no client-supplied executable input. The tmux server this process drives: its socket, version, daemon pid, and totals, and the oldest tmux release this server drives. Check the version before using a feature that needs a recent tmux.

Inspect tmux metadata; accepts no client-supplied executable input. Every session on this server with its id, name, window count, and whether anyone is attached. Metadata only — for what a pane shows, use tcapture_pane or tsearch_panes.

Start a pane’s configured process; accepts no command payload. Add a window to a session and return it with its pane.

Inspect tmux metadata; accepts no client-supplied executable input. Return metadata for one session without listing every session.

Delete tmux state; accepts no command payload. Remove a session. Windows and panes shared with another session remain available there.

Inspect tmux metadata; accepts no client-supplied executable input. Windows on this server, optionally restricted to one session by id or name.

Change tmux state; no client-supplied executable input. Rename a session. Its id does not change, so targets by id keep working.

Inspect tmux metadata; accepts no client-supplied executable input. Return metadata and placements for one window.

Delete tmux state; accepts no command payload. Close a window and every pane in it.

Inspect tmux metadata; accepts no client-supplied executable input. Panes on this server, with the command each is running and its directory. Marks the pane this server runs in (isCallerPane) and panes a person is watching (isAttended). Metadata only — tsearch_panes reads their contents.

Change tmux state; no client-supplied executable input. Move a window to another index, or into another session.

Change tmux state; no client-supplied executable input. Rename a window. Its id does not change.

Change tmux state; no client-supplied executable input. Set a window’s size in cells. A detached window is whatever size tmux guessed, and a program that formats to its terminal width truncates to that at the source — no capture option recovers those columns, because they were never printed. tresize_pane only redistributes space inside a window and cannot grow one. A client attached to the window will overwrite this when it next changes; window-size manual makes a size of your own stick.

Change tmux state; no client-supplied executable input. Rearrange a window’s panes using a named layout, a unique abbreviation for the running daemon, or a checksummed saved layout from a window whose metadataComplete is true. tmux may adapt dimensions or prune extra cells; the returned window.layout reports the observed result.

Change tmux state; no client-supplied executable input. Make a window the current one in its session.

Start a pane’s configured process; accepts no command payload. Split a pane and return the new one. Direction is where the new pane goes relative to the one you split.

Read pane output; accepts no client-supplied executable input. Returned content may be sensitive or untrusted. The text a pane is showing, or its scrollback. Negative start reaches back into history (-100 is a hundred lines above the top of the screen). For repeated reads of the same pane use tcapture_since instead — it returns only what is new.

Read pane output; accepts no client-supplied executable input. Returned content may be sensitive or untrusted. What a pane has printed since you last looked. Call it once with no cursor to start watching and get the current screen; keep the cursor it returns and pass it back each time after that, and you are charged only for what is new. This is the tool for watching a build, a log, or a test run — not a tcapture_pane loop. Set waitMs to block until something arrives rather than returning empty. Reports the stream in the order it was written, so a program that draws by moving the cursor (a progress bar, a full-screen TUI) reads jumbled here — tcapture_pane renders those.

Delete tmux state; accepts no command payload. Discard the retained scrollback history for one pane.

Inspect tmux metadata; accepts no client-supplied executable input. Find the pane occupying a named corner of a window.

Inspect tmux metadata; accepts no client-supplied executable input. One pane’s metadata: what it runs, where, how big, and whether it is yours or watched. Does not read its contents — tcapture_pane does that.

Delete tmux state; accepts no command payload. Close a pane and the process in it. Refuses the pane this server runs in and every pane a person is watching; force confirms only this server’s exact caller pane.

Send input to a pane’s program; a shell that receives it runs it with your user’s permissions. Put text into a pane without tmux interpreting any of it as key names. Use for content — a password, a code block, anything with characters a key parser would claim.

Change tmux state; no client-supplied executable input. Resize a pane, either to a size or by an amount in a direction. Give width/height for an absolute size, or direction with amount for a nudge.

Start a pane’s configured process; accepts no command payload. Restart a pane’s command in place, keeping the pane and its id. Use to recover a pane whose process died, rather than killing and re-splitting.

Run a shell command in a pane with your user’s permissions. Run a shell command in a pane, wait for it to finish, and report its exit status and output. Prefer this over tsend_keys plus tcapture_pane: it frames the command so a pane’s echo of what you typed can never be mistaken for what the command printed, and it knows when the command actually ended rather than guessing from the screen. The command runs in a subshell, so cd and export do not persist to a later call. A pane is effectively single-writer: this server reserves it until the command settles, but another process with the same tmux socket can still write into it.

Read pane output; accepts no client-supplied executable input. Returned content may be sensitive or untrusted. Find which panes are showing something. Searches pane contents, not their names — use tlist_panes for metadata. Returns the matching lines with their pane, so you can target one without capturing them all. Literal matching stops at one 256 KiB aggregate UTF-8 byte budget.

Change tmux state; no client-supplied executable input. Make a pane the active one in its window. Moves the cursor of anyone attached to that window.

Send input to a pane’s program; a shell that receives it runs it with your user’s permissions. Send keystrokes to a pane. Use for TUIs, control keys (C-c), and partial lines. For a shell command whose result you want, use trun_shell_command — it waits for completion and reports exit status, which this does not.

Send input to a pane’s program; a shell that receives it runs it with your user’s permissions. Send an ordered batch of pane-input operations, resolving and checking each row’s configured cohort immediately before input. Stop or continue on error.

Change tmux state; no client-supplied executable input. Give a pane a title. Useful for labelling what an agent put where, since the title shows in tlist_panes and survives the command changing.

Change tmux state; no client-supplied executable input. Set the window default for synchronized pane input. Pane overrides still determine each effective configured cohort.

Read pane output; accepts no client-supplied executable input. Returned content may be sensitive or untrusted. Return bounded terminal content and pane metadata in one MCP response. The metadata and capture come from separate tmux requests and are not an atomic snapshot.

Change tmux state; no client-supplied executable input. Exchange two panes’ positions. Their ids and contents travel with them.

Read configured tmux commands; accepts no client-supplied executable input. Returned values may contain executable configuration. Read the hooks a server or session runs. Read-only: a hook set here would outlive this process and keep firing in somebody’s tmux. Put hooks a server should keep in its config file.

Change tmux state; no client-supplied executable input. Set the default retained scrollback line limit through a bounded integer.

Change tmux state; no client-supplied executable input. Set the global tmux mouse option through a closed boolean schema.

Read the tmux environment; accepts no client-supplied executable input. Returned values may contain secrets. The environment tmux gives processes it starts, at server or session scope. This is what a new pane will inherit, not what a running one has.

Read configured tmux commands; accepts no client-supplied executable input. Returned values may contain executable configuration. Read one named tmux option at server, session, window, or pane scope.

Change tmux state; no client-supplied executable input. Signal a tmux $wait-for channel.

Change tmux state; no client-supplied executable input. Wait until a tmux $wait-for channel is signalled.

Read pane output; accepts no client-supplied executable input. Returned content may be sensitive or untrusted. Invoke a serial batch of at most 16 inspect tools. One client approval covers every nested name; inner tools receive no separate approval. The structured result is capped below 1,000,000 bytes, preserves every operation row, and reports explicit stop and truncation accounting.

Read configured tmux commands; accepts no client-supplied executable input. Returned values may contain executable configuration. Resolve validated tmux variable names without accepting raw format syntax.

Read pane output; accepts no client-supplied executable input. Returned content may be sensitive or untrusted. Wait until a pane prints something, streaming tmux’s notifications rather than polling. Use for output you did NOT author — another process, a person, a background job. For a command you wrote, use trun_shell_command: it knows when the command ended and reports exit status, which no text match can. This discounts text this server itself typed into the pane, for as long as it is unsubmitted or was submitted within the last ten seconds, so a command you just sent cannot match its own echo — but a pane not yet reading input can still echo type-ahead back once it starts, so wait for a prompt before typing into a cold shell. Whatever happens you get back what the pane printed and why the wait ended — a timeout is never an empty answer.