Dev Terminals

  • Desktop, mobile and web
  • All plans

What it does

A per-project terminal manager that lives next to your agents. Every command a project needs (dev server, backend, mobile bundler, Docker, worker, tests) is saved once, sorted in folders with a framework icon, and started in one click in a real terminal at the right working directory. A command is either a Process (a long-running service, included in "Start all") or a Snippet (a one-shot command run by hand). You can also open blank shells, split panes, detach the whole terminal strip to a floating window on a second screen, arm a bell that notifies you when a long command finishes, and start any saved command from your phone while the output streams back to it.

Video (1 min 18 s): Dev Terminals, shown in the real app. A project with an API and a storefront and no saved command: one click on the magic wand has an agent write the start command of each service, then one click on Start runs each server in its own terminal tab, in its folder.

Where to find it

  • Inside a project, the terminal bar at the bottom of the room carries four buttons: New terminal (empty shell at the project root, or in a worktree you pick, see below), Commands (your saved commands), Servers and Databases. The bar stays visible even with zero tab open. The tabs, the filters, these buttons and the window buttons share one row as long as everything fits. With too many terminals or a narrow window, the filters and buttons drop to a second row below the tabs. When the tabs overflow their row, left and right arrows appear at its edges to scroll them (the mouse wheel and the trackpad work too).
  • The room dock: Commands & connections ("Commands · Servers · Databases · Secrets").
  • Command palette (Cmd K / Ctrl K): a command result starts it or refocuses its tab (prefix >).
  • Detach: the detach icon of the terminal strip opens it in its own window; Reattach terminals to the main window brings it back.
  • One terminal in its own window (since 2026-10-23): right-click a terminal tab, in the main window or in the detached Commands window, then Open in a new window. That terminal gets a window of its own (900 x 600, put it on any screen); the other terminals stay in the bar. Its tab stays in the bar and its pane shows "This terminal is open in its own window" with Show the window and Bring it back here. The window carries the same chip as a pane (bell, Stop, Restart, close). Closing the window, or Bring back to the dev command bar in its title bar, puts the terminal back in its tab; the process keeps running either way. Right-click the tab again for Show its window. One window per terminal; database, cluster, file and diff tabs stay in the bar.
  • Switch project from a detached window: since 2026-10-20 every detached window that shows a project (dev terminals, agent terminals, agents, backlog, prompts) carries the same row of opened projects as the main window's title bar, with the project name. Click a tile, or use the main window's shortcuts (Cmd/Ctrl+1 to 9, a project's own shortcut, Left / Right outside a terminal, Cmd/Ctrl+Alt+Left / Right everywhere): the detached window and the main window both move to that project, so the dev terminals shown are that project's. Changing project in the main window moves the detached window too. In the detached Commands window (since 2026-10-28) the project folds into a single tile at the left of the title bar, with a small arrow: click it for the list of opened projects (with their shortcut), the shortcuts work as before. The rest of the title bar shows the window's terminals as tiles, like the projects of the main window, followed by the name of the open terminal (hovering a tile shows its name instead, like the main window): click a tile to show it, its cross (on hover) closes the terminal, right-click it for the tab menu (split, open in a new window, close), drag it onto another tile to split or onto its edge to reorder. The other machines' terminals stay in the strip.
  • The Commands window carries a video tutorial icon (a help icon with a small play badge) in its header that opens the video (since 2026-10-20).
  • Feature switch: Settings > Features > Dev Commands.
  • The same bar also lists, after your local tabs, the terminals open in this project on your other online machines (same account), with the machine's name after the tab name; clicking one follows it under the banner "Remote terminal on <device>". Detail in Remote Fleet.

How to use it

  1. Open Commands and click New Command: name, command line, working directory (relative to the project root), folder, Type (Process or Snippet), Auto-execute on click (off = the line is typed but not run), category, and scope (this project only, or every project of your account).
  2. Or click the magic wand (Auto-detect project commands with AI), the icon just left of New Command in the header of the Commands window: it turns into a spinner while an agent reads package.json, Dockerfiles, Makefiles and similar files, then the list fills with the persistent services it finds, one row per service with a name the agent chose (for example API Server, ./api/npm run dev) and its working folder. One-shot scripts such as tests are left out. On a small two-service repo it took about 15 seconds; the commands are saved straight away (edit or delete a row afterwards).
  3. Hover a command row: Start appears on its right, next to edit, duplicate and delete. Press it (or the global start button for every Process). The row gets a dot and View replaces Start, the header counter reads "3 commands · 2 running", and the command opens in its own terminal tab in the bar at the bottom of the room, already in its folder. The tab shows a dot: busy, idle, or nothing when the state is not known yet. Running commands are pinned at the top of the list. A saved command's tab that runs nothing yet shows "Run this command to see its output here", the command line and a Run button that starts it from the pane itself (since 2026-11-09).
  4. Bell: each pane label has a bell. Arm it and you get a desktop notification (and a push on your phone) when the command running there hands back to the prompt, with its name and duration.
  5. Restart: the label's restart button kills what runs in that pane and retypes the command (or, for a blank shell, the last line you typed, shown in the tooltip first).
  6. Stop: while a command is detected running in a pane, a Stop button (filled square) sits on its label between the bell and Restart. It interrupts the command exactly like pressing Ctrl+C; the terminal stays open at its prompt with its output. It is hidden when nothing runs. Available in the main window and in the detached one.
  7. Tidy up: the eraser opens Tidy up terminals with three actions: close the finished ones, close duplicates of the same command, close every terminal. The tab's context menu also offers Close this tab when the command ends.
  8. Right-click a pane for Copy (greyed when nothing is selected) and Paste at the top, then Clear buffer, Restart, Settings and Split right / Split down, or Remove from split. The menu opens on every right-click, selection included, in dev command terminals, agent terminals and remote terminals alike (since 2026-09-24; before, a right-click over a selection did nothing). Since 2026-10-01 a right-click over a selection also copies it at once, as in VS Code: the menu still opens and its first row shows Copied with a check, so there is no second click to copy. Only a selection made before the right-click is copied, so on macOS the word the right-click selects by itself never overwrites your clipboard. A right-click without a selection does not paste directly: use Paste in the menu. Tabs can be dragged between panes, in the main window and in the detached one.

Public commands are stored in .agentsroom/commands.json (commit it, the team gets the setup). Personal commands go to commands-personal.json, gitignored automatically. Use Duplicate command to start a copy from an existing one. Search covers name, command, folder, category and type, with a All / This project / Global filter.

When a worktree is in view (the focused agent works in its own worktree, or a worktree is picked in the Worktree selector of Changes), every new blank terminal (New terminal, a new tab or split from the right-click menu, the shortcut) first shows a small Open in card next to the click: Project folder or the worktree's folder name (selected by default, its full path on hover). Click one, or use the left / right arrows and Enter; Escape or a click outside opens nothing. Without a worktree in view, the shell opens at the project root at once, as before. Terminals already open are never moved, and saved commands keep their own folder, relative to the project root. The detached Commands window asks the same question.

Settings

  • terminalCommandAlerts (global, Settings > Notifications > Terminal command alerts): notify when a long command finishes. On by default. Project override in Project settings > Terminals ("Notify me when a long command finishes"); the bell on each tab overrides both (commandAlertOverrides, read-only, written by the bell).
  • commandCloseOnFinish (project, read-only): the per-terminal "close this tab when the command ends" choices, written from the tab menu.
  • openCommandsInSamePane and openCommandsSplitDirection (global, also as Open commands in the same pane in the Commands modal): new commands open as a split of the focused pane instead of a new tab.
  • restoreDevCommands (global, Restore commands on launch in the Commands modal; a project can override it): re-launch the command terminals that were still running when the app closed. Commands that had already finished come back as idle tabs. Off by default.
  • terminalStartupCommand, terminalFontFamily, terminalThemeOverride, terminalGpuAcceleration, terminalLinkTarget (global, Settings > Terminal): apply to every terminal, dev terminals included.
  • focusAgentCommandTabs (global, Settings > Agent behavior > Bring dev command tabs started by agents to the front; project override in Project settings > Agents; on by default): when an agent starts a saved command with commands_run, its tab comes to the front (and the detached terminal bar window is raised). Off: you stay where you are, the tab still appears in the bottom bar with the agent's avatar, one click away. Whatever this setting, the focus never moves while you are typing (a key pressed in the last 10 seconds, or an unsent draft in the focused field). Commands you start yourself, and commands started from the phone, always come to the front. Since 2026-11-13 (asked by Mykhailo, #3151).
  • terminalEnvSource, terminalShellPath, terminalExtraPathDirs (global, Settings > Terminal > Shell and environment / Extra PATH folders): which shell every terminal starts with (default shell, Ghostty's configuration or a custom shell) and folders added in front of PATH. Dev terminals included. See Terminal Shell and Environment.

Agent tools (MCP)

  • commands_list / commands_get: the saved commands of both scopes, each with running and the ids of its live tabs, plus the open terminals that have no saved command behind them.
  • commands_create: save a command (scope: "project" | "global"); refuses a line + directory already saved and returns the existing id. Records which agent saved it (createdByAgentId) and an optional ticket, so a one-off can be found when that ticket closes.
  • commands_update / commands_delete: change a saved command in place, or remove it for good (scope: "global" for an account command). An agent does this without asking only for a command it saved itself or one carrying the ticket it works on; for any other, it needs you to name the command. Both refuse the blank Terminal. A delete, or a new command line or directory, is refused while a tab of that command is open. An agent never edits a command holding a {{secret:NAME}}. Each one can be undone from the Changes tab.
  • commands_run: start a command in a visible tab. When the command's tab is still open but its last run has finished (back at the shell prompt), it runs the command again in that same tab instead of opening another one. It refuses a command that is still working, or whose state cannot be read (a Windows terminal nobody watches, a project whose commands run over SSH), unless allowDuplicate is set. The tab shows the agent's avatar ("Command launched by X"). Since 2026-10-23 it answers only once it has checked that the command STARTED (a few seconds): started: true with the name of the process seen running; started: false with ok: false when nothing was seen running, together with what the run printed; started: null when the machine cannot tell (a project whose commands run over SSH). When the terminal is held by another program instead of a shell at its prompt (a tmux started or attached by your shell startup files, a program launched with exec), the line is not typed at all and the agent gets an error naming that program.
  • commands_output: the last lines a live tab printed, ANSI stripped (80 by default, 300 max). commandId accepts a saved command id, a tab id, a PTY id or the connection id of an SSH tab. When the same command has several live tabs, ptyId picks one; without it the most recently opened tab is read, and the answer lists every live tab id. A ptyId that matches no live tab is refused, never silently replaced by another tab. Refused for a command whose line contains a {{secret:NAME}} reference. An SSH tab can be read but not typed into. For a tab where commands_run typed a line, it returns only what that current run printed (with when it was typed), never the previous run of a reused tab; includeEarlierRuns: true reads the whole tab.
  • commands_close: close completed tabs after reading their output; refuses executing or unknown states without closing any matching tab.
  • commands_stop: stop what runs in a live tab. By default it kills the tab's whole process tree and closes the tab, like its close button; with closeTab: false it only sends Ctrl-C and keeps the tab, so commands_run then reruns the command in that same tab. Addresses tabs with the same ids as commands_output; without ptyId every live tab of that id is stopped. This is how an agent cleans up its own tabs instead of leaving them for you to close.
  • commands_propose: ask you to run one shell line the agent's own sandbox refused. Nothing runs until you click Play on the card in that agent's panel; the tab it opens is a throwaway, never saved and never restored. See Command Proposal.

Completed command tabs

Agents can use commands_close to close completed dev-command terminal tabs after reading their output. It refuses running commands, queued launches and unknown execution states. commands_list distinguishes execution from open shells: completedPtyIds lists idle tabs, while runningPtyIds lists busy or unknown tabs. commands_run reuses a finished tab, so no manual cleanup is needed before rerunning. If another instance is still executing, the duplicate guard remains.

Providers

All providers, no difference for running commands. The magic-wand auto-detection launches a Claude agent to scan the project.

Mobile

Yes, and in both directions. The project screen lists the saved commands (project and global); starting one creates the terminal on the desktop and streams the output to the phone over the encrypted relay, with the same busy/idle dot and the launching agent's avatar on the tab. Since 2026-10-30, a search field at the top of the sheet ("Search a command (name, command, directory)") narrows the list as you type, like on the desktop; folded folders open while you search so no match stays hidden, and an empty result says "No matching command". A throwaway terminal opened from the phone also appears as a tab on the computer, sharing the same process, the same scrollback and the same take-over, so a command started from the sofa can be picked up at the keyboard. Each terminal screen also has the Invoke an agent button (lightning, in the header), to put an agent on a crashed command from the phone; see Invoke an Agent from a Terminal. Not on the phone: tidy-up menu, close-on-finish, split panes, detached window. The Fleet view of another machine also lists that machine's open terminals, one row per tab ("<device> · terminal"), and a tap follows it; see Remote Fleet.

Limits

  • Free plan: 2 saved commands running at once; Plus: 3; Pro and Team: unlimited. Blank shells never count.
  • The bell only knows "finished", not "succeeded": there is no exit code. Commands shorter than a minute stay silent unless the bell was armed while the command was already running. Nothing fires while you are looking at that terminal. What runs inside ssh, tmux or docker exec is invisible to it; cmd & counts as finished immediately.
  • Agent launches: a command that ends in less than about a second can finish before the start check sees it; it is then reported as "not confirmed" with its output, never as started. A terminal held by tmux, screen or another program the shell startup files start is refused, even when that program would have run the line in a fresh session.
  • Close-on-finish closes on failure as well as success, which is why it is off by default and per terminal only.
  • The detached window layout is not persisted across restarts.
  • A terminal opened in its own window is not reopened in its own window after a restart of AgentsRoom: it comes back in its tab. The window closes by itself when its terminal is closed or ends.
  • Windows: the finished-command detection polls the shell's descendants (no foreground process group), so it runs as long as a dev terminal is open and alerts are on.
  • Remote tabs from other machines are a projection: no close, no drag, no split with a local tab, not shown in the detached window, gone when their machine goes offline. Stopping what runs there is done on that machine.

Common questions

  • An agent keeps starting test or harness servers and each tab jumps in front of what I am doing. Can I keep them in the background? Yes, since 2026-11-13. Turn off Settings > Agent behavior > Bring dev command tabs started by agents to the front (or only for one project in Project settings > Agents). The command still starts and its tab appears in the bottom bar with the agent's avatar; the app just does not switch to it. Even with the setting on, it never switches while you are typing. For agent consoles started by team runs, the matching setting is Bring agents started in the background to the front.

  • Can I put one terminal on another screen while the others stay in the bar? Yes, since 2026-10-23. Right-click its tab, Open in a new window: it works from the main window and from the detached Commands window. Close that window to put the terminal back in its tab; the command keeps running.

  • How do I get AgentsRoom to write my project's start commands? Open Commands in the bar at the bottom of the project, then click the magic wand (Auto-detect project commands with AI) next to New Command: an agent reads the repo and adds one command per long-running service, with its folder. Hover a row and press Start to run it in a real terminal. Video: https://youtu.be/tyc4mV7lsC0

  • Is there a video that shows it? Yes, 1 min 18 s, the magic wand writing two start commands and both servers started in one click each: https://youtu.be/tyc4mV7lsC0

  • How does it know a command finished if the tab stays open? It watches the terminal's foreground process group: when it returns to the shell, the prompt is back. Nothing is written into your shell configuration.

  • Why did an agent's command refuse to start? It was still running: commands_run returns the live tab instead of opening a second one. The agent can read it with commands_output. Once the command has finished, the agent can run it again: it reruns in the same tab. To restart a server that is still up, the agent stops it with commands_stop (Ctrl-C, tab kept) then runs it again.

  • An agent says the command it launched did not start, or it is "not confirmed". Since 2026-10-23 commands_run checks that a process really started before saying so. Before, it answered "ok" as soon as the tab existed, and an agent could report a server or a test run it had never seen start. "Not started" naming tmux (or screen) means your shell startup files hand every new terminal to it, so a typed line would land in your own tmux session instead of a shell: change those files so they do not start tmux in the terminals AgentsRoom opens, or start the command yourself. "Not confirmed" means the line was typed but nothing was seen running within 3 seconds: either it finished at once (its output comes with the answer) or the shell was waiting on something else (an update prompt, for instance).

  • An agent read the logs of an earlier run as if they were the new one. Fixed on 2026-10-23: when a finished tab is reused, commands_output returns only what the new run printed, and says so when it has printed nothing yet.

  • Can an agent delete or edit a saved command? Yes, with commands_delete and commands_update. Commands an agent saved for a ticket carry that ticket, so it can remove them when the work is done. Ask it to remove any other command by name.

  • A command an agent saved disappeared, or commands_run could not find it. Fixed after 1.251.0. When two agents, or an agent and an open window, saved at about the same time, one save could overwrite the other even though both reported success. Each save now states which version of the list it read: if the list changed in between, the save is replayed on the latest list, so nothing is overwritten. If it still cannot go through, the agent gets an error instead of a false success. A brief server error such as HTTP 520 is retried too. Update AgentsRoom on every computer of the account: an older version still overwrites the list.

  • Can an agent close the terminal tabs it opened? Yes: commands_stop kills the process and closes the tab, so dead tabs no longer pile up in the Dev Commands panel.

  • Do I have to close a finished terminal before an agent can run the command again? No. A finished command is rerun in its existing tab; only a command that is still working is refused.

  • Where are the commands shared with the team? .agentsroom/commands.json in the project. Personal ones are in commands-personal.json, gitignored.

  • My new terminal opened on the main checkout while my agent works in a worktree. Since 2026-10-27, a new blank terminal asks Open in: Project folder or the agent's worktree (see Git Worktrees). The question only appears when a worktree is in view. On a project opened on a server, a worktree outside the project folder has no remote equivalent and the remote shell stays at the project root.

  • Can a command exist in every project? Yes: choose the global scope when saving. Its working directory is still resolved against the current project.

  • My auto-executed command lost its first character (PORT=8811 npm run dev ran as ORT=8811 npm run dev). Fixed after 1.173.0. The line used to be typed a fixed 300 ms after the shell opened, inside the window where a slow startup file could still swallow a keystroke, so it happened only now and then. It is now typed once the shell has printed its prompt and gone quiet (2 seconds at most), whatever the shell.

  • After restarting the app, my command tabs are back but nothing runs. Expected since 2026-09-24. Restoring the previous session reopens the tabs and their layout idle: press Start on the ones you need. To have the servers that were running re-launched on their own, turn on Restore commands on launch in the Commands modal; even then, a command that had finished (a test run, a one-shot script) comes back idle.

  • The AgentsRoom window reloaded after a crash: did my dev server and my tunnel stop? No, since 2026-10-14. When the window's display process crashes or runs out of memory and reloads on its own, or when you click Reload on the crash screen, the commands started from Dev Commands keep running: each one comes back in its tab with its output, its bell and its place in the split. Before, every one of them was stopped silently. Quitting AgentsRoom still stops them all. Agent terminals are restarted on their conversation instead (see Crash Screen).

  • How do I stop a dev server without closing its tab? Click Stop on the pane label (or press Ctrl+C in the terminal). Restart stops and re-runs it; closing the tab ends the shell.

  • Text is clipped at the bottom of a terminal. Turn off GPU acceleration in Settings > Terminal, or resize the pane once.

  • A tab in my terminal bar carries the name of my other computer. It is a terminal open there in the same project (since 1.182.0). Click it to read and type into it; it is not a local tab. See Remote Fleet.

  • An agent read the wrong terminal after starting a second copy of a command. Fixed: a named tab is now found or refused, never swapped for an older tab of the same command, and without a tab id the most recently opened one is read.

  • How do I copy and paste in a terminal with the mouse? Select the text and right-click: it is copied already (the menu shows Copied); right-click, Paste to type the clipboard into the terminal. Copy and Paste return keyboard focus to the terminal so you can keep typing immediately. Cmd+C / Ctrl+Shift+C copy; Cmd+V / Ctrl+V paste. On Windows, Ctrl+C also copies selected text; with no selection, it still interrupts the running command. An empty clipboard or one that holds only an image pastes nothing through the menu.

  • I cannot select text in a terminal: my click goes to the program instead. The program running there captures the mouse (oh-my-pi with its Mouse Click-to-Focus option or a full-screen view open, OpenCode, htop, vim with the mouse on). Hold a key while you drag: Option on macOS (since 2026-10-12, before that nothing could be selected on a Mac), Shift on Windows and Linux. The selection then copies like any other. When nothing captures the mouse, Option-drag on macOS keeps selecting a rectangular block.

  • How do I select more text than fits on the screen? Drag the selection to the top or bottom edge of the terminal and hold: since 2026-10-15 the terminal scrolls as soon as the pointer reaches its edge (no need to leave the pane), in agent and command terminals, local or on a server. Only what the terminal still holds in its history can be selected.