Claude Code, Codex and Terminal

Three kinds of window on the desktop are terminals on the machine exe runs on. Claude Code and Codex each run that coding agent's CLI, and Terminal is a plain shell. Where the machine has tmux, a program that keeps a terminal session running with no window on it, what runs in them does not stop with the window: close the window, the tab or the laptop and it works on.

What they are for

For you:

• Work that outlives the browser. A session keeps running with no window open. Open the window again, from any device, and you are back in the same conversation.
• Several conversations side by side. A column in the window lists the agent's sessions, and a dot marks one that is still working or one that waits for you.
• Usage in view. The status line shows a Claude Code session's model, context, tokens and cost, and for either agent how much of the plan's usage windows is spent.
• Word when a turn ends. With notifications on, a push says the agent has finished, and a tap opens the window on that session. The desktop says how to turn them on.
• Conversations started elsewhere. A Codex thread from the ChatGPT app on your phone, a claude run over SSH or in an IDE: the window lists them, and a click continues one here.
• A shell on the machine. A Terminal window keeps its shell through a reload, a closed browser and a restart of the daemon.

For a coding agent:

• A session not tied to a browser. The CLI runs in a tmux session on the machine, so a long turn goes on while nobody is looking.
• Files by drag and drop. A file you drop on the window is uploaded and its path typed at the prompt, so the agent reads a screenshot or a log from disk.
• Its state shows. When it finishes a turn, or stops for a permission or a question, its row is marked, and the end of a turn can send you a push. It is not left waiting unseen.
• Other tools can start it. Over the API a script, or another agent, opens a session with a first message, types into a running one and ends it: work you can watch in the window and take over.
• exe close at hand. The session runs on the machine exe runs on. Hand the agent the Agent Skill Guide and it uses exe's VMs as its sandboxes. The coding agent has the guide.

Install Claude Code or Codex

Help → Welcome…, the Claude Code and Codex card, says which of the two is installed on this machine, with its version, and its Set Up… button opens Agent Setup, a window of three steps: a page for Claude Code, one for Codex, and a review.

• A CLI that is installed shows its version and where it is, and what exe adds to it: the window that outlives the browser, the session column, usage in view and word when a turn ends. Open Claude Code or Open Codex opens its window.
• A CLI that is not installed shows the command that installs it on this kind of machine: Anthropic's installer for Claude Code (curl … | bash on Linux and a Mac, irm … | iex in PowerShell on Windows), npm or Homebrew for Codex, with another way in small type where the machine has one. Copy Command copies it; Install in Terminal… opens a Terminal window on the desktop that runs it and leaves you at a prompt after. Then open the CLI's window from the desktop and sign in the first time.
• Check Again looks at the machine again, and the window also looks whenever it comes forward, so an install made meanwhile shows on its return. A CLI installed while the desktop is open gets its icon without a reload.
• Review lists both, with the version of each that is here, and whether tmux is on the machine: with it a session outlives its window, without it each window is a fresh run of the CLI.

exe finds a CLI on PATH, in ~/.local/bin, where npm, bun and Homebrew put programs, and in every nvm Node version's bin. A script can ask too: GET /v1/agents/cli names each with its path and version, and what an installer would lean on here (curl, node, npm, brew).

Open a window

Double-click the Terminal, Claude Code or Codex icon on the desktop. An agent's icon is there only when its CLI is installed on this machine; hover it for the folder its sessions start in.

• An agent has one window. Its icon brings that window forward when it is already open.
• Every double-click on Terminal opens another window: Terminal, Terminal 2 and so on.

The desktop menu can open all three too, and can run one command in a terminal window of its own. Desktop context menu lists its actions.

Codex sessions use standalone mode when the installed CLI supports it. This keeps their notifications and session status without the shared background server warning. With tmux, they still keep running when the window closes.

The agent window

A Claude Code or Codex window has three parts. The session column, on a machine with tmux, runs down the left. The terminal with the conversation fills the rest; in the Claude Code window a line over it shows the session's latest prompt. The status line at the foot shows the connection at its left and usage at its right.

In the installed exe app, the screen stays awake while Claude Code or Codex is the active window. Switching to another window, closing or shading the agent window, or leaving the app lets the screen sleep normally again. Returning to the agent window asks to keep it awake again. This works on supported devices, including iPhone and iPad Home Screen apps on iOS 18.4 or later; the device can still refuse it to save power. Ordinary browser tabs keep their normal screen-sleep behaviour.

Usage on the status line

Hover the figures for the long form, which adds when each usage window resets. A figure at 90% or more turns red.

• Claude Code. The figures follow the session on screen. The plan's usage windows show on a subscription, after the session's first reply. A status line of your own in ~/.claude/settings.json keeps working inside the terminal.
• Codex. The figures are read on the ChatGPT sign-in under Configuration → OpenAI, and without it the status line shows the connection alone. The coding agent says how to sign in.

The Control Strip's agent usage meter counts what both agents have used on the whole machine today. The desktop describes it.

Sessions: several conversations in one window

On a machine with tmux, the column down the window's left lists the agent's sessions, one row for each tmux session. Each is a conversation of its own.

• Switch. Click a row and the window moves to that session.
• Start another. New, under the list, starts another conversation in a session of its own, at the top of the list.
• Start one in a project's folder. In Projects, right-click a project and choose Open in Claude Code: the Claude Code window opens, or comes forward, and a new session starts in the project's working directory, at the top of the list. The item is greyed for a project without a working directory, or whose folder is not on this machine.
• Work on an issue. Right-click an issue in Projects and choose Send to Claude Code or Send to Codex. Only detected agents appear. A new session starts in the project's folder with the full issue and comments as its initial task. This needs tmux and a working directory on this host; the agent keeps its usual sign-in, trust and permission prompts.
• Resize the column. Drag the line between the list and the terminal. The width is kept with the window's layout.

The list runs newest first, so the session the icon first opened is normally at the bottom. On a phone the column is a strip of tabs above the terminal.

A row is titled the way the CLI titles its terminal. Claude Code keeps that on its current task. Codex, which the desktop starts with its terminal title set to the thread, keeps it on the thread's name. Until the CLI has set a title, a row reads the agent's name and the session's number, such as Claude Code 2.

A window opens on the session it showed last, with its row scrolled into view. That holds from any browser and after the daemon restarts, because tmux itself remembers where the window was.

See which session needs you

While the window shows another session, a mark before a row's title says how that session stands:

Hover a row for which of these it is. The session on screen has no mark, since the terminal shows how it stands. A turn you stopped with Escape leaves no mark either: you saw it stop.

How the desktop learns it:

• Claude Code reports through its hooks.
• Codex reports through its notify command, which the desktop points at the session, and through the terminal bell, which the desktop has Codex ring at the end of a turn and for an approval, so tmux notes it while no window is looking.

The desktop gives each session these settings as it starts it and does not write to your own settings files. A notify of your own in ~/.codex/config.toml still runs after the desktop's, and Claude Code hooks of your own keep running.

Archive a session

Right-click a row for its menu:

An archived conversation stays on this machine. In the Claude Code window, Search finds it again (below), and /resume inside Claude Code or Codex brings it back too. The desktop keeps no list of its own: it reads the conversations the CLI keeps. Claude Code deletes a conversation 30 days after its last write unless cleanupPeriodDays in ~/.claude/settings.json says otherwise.

• Archive… shows only once the conversation exists.
• Once the session's processes are gone, a note at the foot of the screen says what it gave back — the memory those processes held, and the swap — and how much memory the machine has available now. On a Mac or a PC, where the daemon cannot read what a process holds, it says only the latter.
• A turn still in flight when you archive is lost.
• When the window was showing that session, it moves to the one started before it, or failing that the one after. Archiving the agent's only session leaves the window with none, and it stops as it does whenever the last session ends.

Get Info on a conversation

In the Claude Code window, right-click a row and choose Get Info for a dialog over the window about that conversation, read from the transcript Claude Code keeps on this machine. It tells you what a session was before you archive it:

• The row is only asked about: the window stays on the session it was showing.
• Archive… in the dialog is the row's own. A conversation no session holds — one started elsewhere — gets OK alone.
• Return and OK put the dialog away, and so does Escape.
• The figures are the transcript's: a sub-agent's turns are in a transcript of its own and are not counted.
• A long transcript takes a moment to read; the status line says so, and the dialog opens filled.
• The Codex window has no Get Info yet.

The prompt line: the latest prompt, and every prompt

In the Claude Code window, the line over the terminal shows the first line of the latest prompt in the session on screen, and at its right how many prompts the session has had. It follows the column: switch sessions and it shows the other session's, send a prompt and it shows that one within a couple of seconds. A session with no prompt yet says so.

Click the line for Prompts, a dialog over the window that lists every prompt of the session in order, each with its number, its first line and when it was given. The latest is selected, and the selected prompt stands whole in the box under the list, every line of it, where it can be selected; Copy copies all of it. The arrows move along the list; Return, OK, Escape and the close box in its title bar put it away.

• A prompt is what you typed or pasted. Slash commands and their output, tool results and a sub-agent's turns are not listed, nor is what a background task woke Claude Code with.
• A prompt longer than 20,000 characters is cut there in the list; the row's tooltip says so, and the whole is in the transcript.
• The list is read from the transcript when the dialog opens; a long transcript takes a moment, and the status line says so.
• The Codex window has no prompt line yet.

Continue a conversation started elsewhere

A conversation started on this machine outside the window is a conversation on this machine all the same. Under a rule below its sessions, the column lists the latest ten of them:

• In the Codex window: threads started in the ChatGPT app on your phone (its remote Codex runs here), in the Codex app or in VS Code, titled the way the app titles them.
• In the Claude Code window: sessions started by claude run in a Terminal window, over SSH or in an IDE, titled as Claude Code titles them, your own /rename first.

Each of these rows has a hollow dot, or a green one while a turn runs there. For Claude Code the dot is green too while its CLI is still open there. Hover a row for where and when it started.

To carry one on here:

1. Click the row, or right-click it and choose Continue Here.
2. The status line says opening session… while it starts.
3. The conversation opens in a session of its own, in the folder it was started in, and its row moves up among the sessions.

If that folder is gone, the session opens in the agent's usual one. Leave a row be and the conversation stays where it is. If opening fails, the error is shown and you can click again; a reconnect also allows a fresh attempt once the window is connected.

A Claude Code session whose window or shell died with it, because a Terminal window was closed or the daemon restarted, is right there to click: it continues as claude --resume would.

Not listed: headless runs (claude -p, the turns of a tool that watches a hub), codex started in a terminal of your own, and the conversations the column's own sessions hold.

Search for a conversation

Search, beside New in the Claude Code window, opens a dialog over the window that lists every conversation on this machine:

• the window's sessions, as the column has them;
• under a rule, the conversations no session holds: the ones started elsewhere and the ones you archived, all of them and not only the latest ten the column shows.

Type words to narrow the list. A conversation stays when every word is found in its title, its first prompt or its folder, in any case and inside longer words; a session of the column's also by its name, so exe-claude-90 or 90 finds that session. A session's row says its name and the day it started, any other conversation's row its folder and the day; hover a row for the rest.

Opening a session moves the window to it. Opening any other conversation continues it in a session of its own, as a click on its row in the column does.

• The dialog belongs to the window: the rest of the desktop keeps working while it is up.
• The list is as it stood when the dialog opened. Open Search again for a fresh one.
• In a column too narrow for both words, and on a phone, Search shows as a magnifier.
• The Codex window has no Search yet.

Closing and reconnecting

• Close the window and its sessions run on. Open the agent's icon again to come back to them.
• The window belongs to the browser. Open in one tab, it is open in every tab of that browser, and it comes back after a reload or when the browser is opened again. Its close box closes it in all of them. Another browser or device opens its own from the icon, at the same place and size.
• A window whose link drops reconnects on its own, in the background, to the session it showed: a tab left behind while the laptop slept, a network that came and went, the daemon restarted. A window whose tmux client was detached with the sessions still there does the same.
• When the agent's last session has ended, and only then, the window stops and says so. Close and reopen it for a fresh conversation.
• The same session in two windows at once, a phone beside the desktop, works. The terminal takes the size of whichever was attached, typed in or resized last.

Scroll back

The mouse wheel scrolls back through the conversation in either window.

• Claude Code takes the wheel itself and scrolls its own transcript.
• Codex keeps a transcript of its own as well, since version 0.160, and the wheel scrolls that, three lines at a time. While you are scrolled back Codex shows "Back to bottom" above its composer, and what you type goes into the composer without moving the view. Esc returns to the latest line.
• An older Codex, or one started with --no-alt-screen, leaves its transcript to the terminal, and on a machine with tmux that is the tmux session's history. The wheel scrolls it there, in tmux's copy mode, with its [123/980] position at the top right. Typing returns to the live screen first, so the keys reach Codex as in any terminal.

On a phone, drag a finger instead of turning a wheel.

Copy, paste and links

To copy text, drag across it.

• In a Codex or Terminal window the drag selects the text as in any terminal. Right-click and choose Copy.
• In a Claude Code window, Claude Code in its fullscreen mode draws the selection itself, and as the drag ends the text goes straight onto your computer's clipboard. Should the browser refuse the page its clipboard, the text waits for Copy in the right-click menu instead, until your next click or key.
• Shift+drag (Option+drag on a Mac) in a Claude Code window makes the terminal's own selection, for Copy the same way.

The right-click menu also has Paste, which puts the clipboard's text in at the cursor, and Select All. If the browser will not let the page read the clipboard, its own paste keys still work.

On a touch screen, press and hold the terminal for the same menu. Paste asks the browser for the clipboard — an iPhone puts up a Paste bubble to tap — and where the browser will not read it for the page, a small Paste dialog opens instead: press and hold its field and choose Paste, then the dialog's Paste sends the text on to the terminal.

A web address in a terminal is underlined under the pointer, and a click opens it in a new tab.

Hand the agent a file

To give the agent a screenshot, a log or a document, drag the file from your computer onto the window.

1. The file is uploaded to the Workspace root, the same as a drop on the desktop.
2. Its path on this machine is typed at the cursor, quoted if it needs it.
3. "look at this" is all the prompt then needs: the agent reads the file from there. Claude Code shows an image it is given a path to.

Several files arrive as several paths. A file over 10 MB is refused, and a folder cannot be dropped. A plain Terminal window takes a drop the same way; a VM's window does not, since a path on this machine means nothing in the guest.

If the window's link is down when the upload lands, with a laptop back from sleep or the daemon restarting, the file is in the Workspace all the same. Its path waits in a row under the terminal:

Nothing is uploaded twice.

Terminal windows

On a machine with tmux a Terminal window keeps its shell the way an agent window keeps its sessions. Each Terminal is a tmux session of its own, named exe-term-1, exe-term-2 and so on, and tmux attach -t exe-term-2 picks one up over SSH.

• The shell outlives the window's link. Reloading the page, closing the browser by accident, the laptop sleeping or the daemon restarting only takes the window away from the shell, never the shell. The window reconnects on its own.
• Windows come back. The next time the desktop loads in this browser, the Terminal windows it had come back where they were, with whatever ran in them still running. So does any Terminal no window shows anywhere, one left on a phone say. A Terminal another desk is showing stays there.
• The close box ends the shell, as in any terminal app, and so does exit: the window closes with it.
• tmux stays out of the way. These sessions have no tmux status line and no prefix key, so Ctrl+B reaches the shell, and tmux run inside works as it would anywhere.
• The wheel scrolls back through the session's history, in tmux's copy mode, with its [123/980] position at the top right. Typing returns to the live screen.

Start and drive sessions over the API

The session column is also an API, for tools that want a conversation you can watch. The calls are written for Claude Code here; put codex in place of claude for Codex. Like every API call, they need the API token when one is set.

A session's <name> is its tmux session's: exe-claude for the one the icon opens and exe-claude-2, exe-claude-3 and so on after it, or exe-codex and exe-codex-2 for Codex.

A new session takes these fields, all optional. Codex takes prompt and resume alone.

A Codex thread resumed this way opens in the folder it was started in, as a click on its row does.

A message is {"prompt": "…", "say": "…"}. The prompt goes in as a paste, and Claude Code treats pasted text as material rather than as your words. So give the request a say as well: one line, typed ahead of the paste, that tells the session what to do with it.

A tool that watches a hub builds this way. An instruction you post in one of Claude's hub threads opens as a session in the Claude Code window's column, works there in view, reports in the thread when it is done and stays open in the window to be continued.

On a machine without tmux

Sessions need tmux, and a Windows machine has none. Without it the three windows are still there, with less behind them:

• A Terminal is a one-off shell that ends with its window. On Windows the shell is PowerShell.
• A Claude Code or Codex window has no session column, and each time it opens it is a fresh run of the CLI.
• On Windows a Claude Code window's status line has no usage figures.