Conversations

A conversation is one session with one agent: the composer at the bottom, where you write and send, and the transcript above it, where the agent's work streams in. This page covers both — from the screen you see before the first message to the ways a long conversation keeps up with you.

The window around it — the sidebar, tabs and splits, the terminal — is The Workspace, and the panel on its right — session details, files and diffs, your git changes — is The Side Panel.

The welcome screen

Before a session starts, the conversation pane asks "What would you like to do today?" and offers Quick Actions in three tabs — Code Development, Office Work, and Scientific Research. Each card drops a ready-made skill (and, for Office and Research, a prompt template) into the composer with one click; anything not yet enabled for your chosen agent shows a lock that links to where you turn it on. Below it sit the agent picker and a rotating tip.

The row of skill shortcuts under the quick actions stops at its ends rather than drifting on its own: an arrow at each end moves it, and each arrow is live exactly while there's somewhere left to go.

Start a session — the composer

Everything begins in the composer, the input at the bottom of the conversation. Choose an agent and its settings, point it at a working folder, type a prompt, and send.

• Agent. Pick from your enabled agents. (The agent picker appears when you start a new conversation, and since 0.35.2 it stays usable while the agent you picked is still connecting: the last one you pick is the one that connects, and if it fails to start, the reason shows in a banner on the composer. It locks once the conversation is saved.) The row fits the width it's given: as many pills as there's room for, and the rest behind a More agents button — with the selected agent never among them, so the one pill that names your choice is always on screen and always readable.
• The agent's settings, on one button. The model, the mode — a plan-first mode, an accept-edits mode, and so on — and whatever other session options the connected agent advertises sit on a single settings button beside +, since 0.37.0. It reads like Opus 5.5 / High / Plan: the current values, model first, then effort, then mode and the rest, joined by "/". A value whose id is literally default is left off — though the model always shows, and when that would leave nothing at all, the first setting's value shows anyway (Gemini's Default mode, say) — and a switch is named only while it's on; in a very narrow box only the agent's icon is left. Click it and one panel opens with every setting in place — a short list as a row of buttons, the model as a list, any list longer than eight with a search box, a switch as a switch, and the agent's Recommended value marked wherever it has one. A pick applies at once and the panel stays open, so changing three settings is one visit. All of it comes from the agent itself, so what you see depends on which one you're running — and an option whose kind this build of Codeg doesn't understand is quietly left out rather than being allowed to break the session. Since 0.34.0 (adapter 0.86.0) Claude Code adds an Agent option once you've defined custom subagents — the agents/*.md files Claude Code reads from your user folder, the project or a plugin — and choosing one runs the conversation as that subagent from your next message on. Like the other options it's remembered for Claude Code on this device, so your next Claude Code conversation starts as that subagent too, until you pick the default entry again; a subagent that's no longer defined is skipped.
• Working folder & branch. A row just below the box shows where the agent will work: a folder chip and a branch chip. The folder chip is switchable while the conversation is still a draft (its list shows folder aliases and searches them, and a pinned Chat mode row runs folderless for a quick chat); once a conversation is bound to a folder, the chip stays as a label. The branch chip is the full git menu — see Branch and run git.
• Context and connection. At the right of that same row, a small ring tracks how much of the model's context window you've used — click it for the token breakdown (input, output, cache write, cache read, total, and since 0.31.0 a cache hit rate under the total, to one decimal; a session whose agent reports no cache counters at all leaves that row out rather than claiming a confident 0.0%) — and a heart icon shows the agent's connection status: connected, connecting, error, or disconnected. That heart is a button — see below.
• The + menu. Attach files, insert a saved quick message, leave live feedback while the agent is working, run a slash command, or drop in a skill from the Experts, Office Work, or Scientific Research packs. Live feedback opens a dialog for a note to the agent that's already running — the same channel the composer's mid-turn send rides, described below. → Settings → Collaboration
• Rich input. Type @ to mention a file, an agent, an assistant, a past session, or a commit — which of those tabs the panel offers, and in what order, is yours to set under Settings → General → Mention panel since 0.35.2. Type / for slash commands — the match is fuzzy, so rvw finds review, and since 0.35.0 a command that takes arguments shows what goes after it. Long messages you've sent fold up with a show more toggle so the transcript stays readable.
• Both panels behave like panels. The @ list takes the composer's own width and edges and opens above it, exactly as / does, instead of a narrow box pinned to the cursor — the extra room goes to the description, which used to be cut off. It stays with the composer it belongs to, so one left open while you switch to To-dos doesn't float over the new page. And / works while the agent is still connecting: slash commands only exist once the agent is up, so typing / early used to do nothing at all; now the panel opens with a loading row and fills in when they arrive, with no need to retype.
• @ after CJK text, and on a phone. The mention panel used to trigger only after an ASCII space — which Chinese, Japanese and Korean don't write — and refused to open mid-composition on a soft keyboard. Both are fixed, and it keeps clear of the on-screen keyboard.
• Send, queue, stop. Enter sends; Shift+Enter makes a newline. While the agent is working, Send turns into a red Cancel button — and once you have typed something on a session that can take a message mid-turn, a split send appears beside it: its button is Queue message, which is what Enter has always done there, and its chevron holds the one action that doesn't wait. Either way, type ahead and your messages queue until the agent is ready for them. → Talk to an agent mid-turn

Approvals come from the agent

Codeg has no global "auto-approve everything" switch. How freely an agent acts is governed by the mode you pick plus the permission prompts it raises mid-task (below) — so control stays with the agent's own safety model. Terminal runs have a per-run --permissions policy for answering the requests an agent raises.

Let Claude Code suggest the next prompt

Since 0.37.0, with its adapter at 0.92.0 or later, Claude Code guesses what you'll ask next. Between turns, an empty message box shows the guess in grey — … (Tab to use) — and a bare Tab fills it in without sending, so you can edit it or send it as it is. Typing hides it, a new turn spends it, and none is offered on the first turn, while a turn is running, or while you're editing a queued message. A conversation you reopen gets its first suggestion after its next turn.

The guess costs one more request after most turns: Claude Code sends the conversation to the same model again, built to be read mostly from the prompt cache, but it still counts in your usage — and since it never reaches the transcript, Token Usage can't include it. Automations, chat-channel bots, and, since 0.38.0, codeg-cli runs don't ask for it. Codeg has no switch of its own to turn it off; Claude Code's own promptSuggestionEnabled: false setting, or CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION=false in its environment variables, stops it.

Follow along — the conversation

As the agent works, its transcript streams in: replies as formatted Markdown (code, math, and diagrams included), its reasoning, and a live plan checklist for multi-step tasks. A plan long enough to bury the rest of the turn caps its height and offers show more / show less, the same way a long message you sent already does; the plan's progress, step by step, is also in the side panel's Agent Plan.

Since 0.38.0, Markdown tables and code blocks have a single border, code highlighting works in light mode, and a table's fullscreen controls stay visible. Code blocks keep the language label and copy/download buttons in their header.

• Every reply sits under a header. It reads Working… while the agent writes and Worked for 1m 9s once the turn settles — which is where the per-turn duration lives now, rather than in the footer stats row. Clicking the header folds away the reply's intermediate work — the tool calls and reasoning it went through — and keeps the final answer on screen, which is the part you came back for. Sending your next message folds the work above it, and that's also the state a conversation opens in when you return to it. A reply with nothing to fold away is a plain label rather than a button: one that stopped on a tool call, or whose answer is a card, stays open, because folding it would leave a lone header where the substance was. Since 0.36.0 a conversation tab you keep open across several prompts shows each reply's full working time and token usage, where a reply that ran for an hour could read a few seconds until you reopened the conversation.
• Thinking stays folded until you open it. An agent's reasoning arrives as a collapsed row — Thinking… while it streams, Thought once it's done — and opening it is your call. Until 0.31.2 it opened itself on the first token and closed itself a second after the block ended, which shoved the reply down the viewport mid-turn and then pulled the text out from under anyone who had started reading; the timer didn't care whether you'd opened the panel by hand. One you open now stays open, and one nobody opens renders nothing at all while it streams.
• Tool calls appear as collapsible cards tagged with their status — Running, Awaiting Approval, Completed, Denied, Error and the like. Since 0.36.0, when you stop a Claude Code turn, the cards it left open — its sub-agents' included — show how they actually ended instead of reading Completed until you reload. Shell commands stream their output live — Codex's too, since 0.32.0, instead of sitting on a [Terminal: …] placeholder until the command ends — and repeated actions fold into a single summary like "Ran 3 commands." Since 0.35.2 Claude Code's cards show what actually ran: a Bash or Grep card reads the description and output mode Claude Code used even when the model misnamed those arguments, and a Read past the usual size limit is badged Over size limit.
• A search that finds nothing isn't a failure. rg and grep exit with 1 when nothing matches, which used to paint a command like rg --files src | rg foo red and count it as an error in its group. Since 0.33.0 a single pipeline ending in rg or grep that exits 1 with no output reads as completed, with the exit code still on the card. Anything else — exit 2, a line of error output, a && chain — still shows as failed.
• A result with no card of its own — an MCP tool Codeg has never seen, say — renders as a collapsible tree rather than a wall of JSON: small payloads open fully, large ones show just their outline, and long strings fold to one line. Show raw JSON switches back to the plain text whenever you want it.
• What the agent touched is summarized at the end of each reply, in two groups: New files (shown by default) and Files changed (folded up, with a count and +/− totals). Click a card to open that file in the editor, or use its View Diff button to see just what this reply did to it — and on the desktop, Show in file manager to reveal it on disk. Deleted files are listed too, marked Remove.
• File names are live. A file the agent mentions — and any file you attached with @ — renders as a badge you can click to open in the file pane. Right-click it for the same actions the file tree offers: reveal it in Finder / Explorer / your file manager, Copy relative path, or Copy absolute path. (The reveal option is hidden where it couldn't work — in the browser, or a desktop window attached to a remote workspace — and the relative form is greyed out for a file outside the current folder.) Since 0.32.2 a relative link opens too — ./index.html, ../docs/a.md, a.ts:12, Dockerfile, resolved against the active workspace folder, and ~/notes.md against your home folder — in thinking blocks as well as replies, where it used to read [blocked]. A link that's still streaming in shows as plain text until it closes.
• A /word is a command only when it is one. In a message you sent, a /word — or a $word in Codex — badges as a command since 0.35.0 only when the agent actually offers a command or skill by that name, so a path like /tmp stays plain text. Until the agent is connected again, the transcript goes by the commands it last offered in that folder. Since 0.37.0 a command whose name carries a colon — Qoder's /sites:sites-building, say — badges as one command and reaches the agent exactly as named.
• Permission prompts. When the agent needs the go-ahead — to run a command, apply an edit, follow a plan — a card docks just above the composer: "Agent requests permission to continue this turn." Its buttons are the agent's own choices (Allow, Reject, and the like). A separate card handles multiple-choice questions the agent asks you; since 0.31.0 that one collapses to its header with a click, giving the message list its space back while the question stays pending — and it re-opens itself if the agent replaces the question set or your answer comes back failed. An agent that asks for several at once — Codex does this routinely — gets a queue: one card at a time, with a +n waiting count beside it, and the next one arrives as you answer. So a batch of approvals reads as a batch rather than as a hang. A card the agent withdraws — for a Claude Code sub-agent you stopped, or a tool that was interrupted — closes by itself, rather than lingering unanswerable and holding up the ones queued behind it.
• What each option grants. Where the agent tells Codeg — Claude Code and Codex do — a panel above those buttons spells out what each choice would actually allow, and each line is tagged with how long it lasts: This run, This session, Saved to user settings, Saved to project settings, Saved to local project settings, or Saved permanently. It's the difference between waving a command through once and writing a rule into a file your teammates will inherit, said before you press anything. Since 0.30.1 Claude Code's own buttons carry it too — this session versus always in this project — so the scope is on the thing you click, not only in the panel above it.
• An empty reply says why. If a turn ends with nothing in it, the alert doesn't just tell you to check your configuration — it names which of three things happened: the agent genuinely produced no response, it produced output Codeg couldn't parse (usually an agent/protocol version mismatch), or it sent only status updates (plan, mode, usage) and no reply. The agent's own output — its error tail, scrubbed of anything that looks like a credential — sits behind a collapsed Details in the status bar's Alerts, which is the one surface with room for it. Since 0.37.0 a reply that arrives just as a turn ends stays in that turn, rather than occasionally going missing with the turn reported as empty.
• Context compaction. When an agent compacts its context — because it ran out of room, or because you asked it to — Codeg marks the spot: a divider drawn across the conversation, sitting between turns rather than folding into the reply above it, because a boundary is what it is and not a tool call. It reports tokens before → after where the agent supplies them, says on hover whether it was manually or automatically triggered, and is still there when you reopen the conversation. How much of that you get depends on the adapter: Claude Code from 0.75.0 supplies the whole set, live and in history alike; Codex supplies no counts, so its divider reads just Context compacted; DeepSeek reconstructs what its log happens to carry. On Claude Code a compaction also resets the context ring beside the composer to what's left, which used to go on measuring a window that no longer existed.
• The summary a compaction kept. Since 0.32.0 a Claude Code or Codex divider can carry a Summary toggle, opening what the model retained of the dropped history — streaming in while it's written. Reopened conversations show it the same way since 0.32.3, instead of the summary turning up as a message of its own or tacked onto the end of the previous reply. Two Codex compactions in one turn get a divider each.
• A compaction that fails says so. The divider turns red and reads Context compaction failed, with the reason on hover — the service's own message where Codex sends one, rather than raw JSON — and Grok's failed compactions land the same way. One that was interrupted or cancelled stops spinning instead of sitting at in progress.
• Goals. /goal on Claude Code and Codex renders as a card carrying the objective, the status, and the tokens, budget, remaining and elapsed counters — live, and still there when you reopen the conversation later. Its controls are whatever that agent actually implements, so Codex offers Pause and Clear while Claude Code offers Clear alone. Both genuinely stop the work: they used to only take effect at the agent's next idle point, which meant a paused goal kept running and a cleared one kept continuing itself.
• Delegated work. When one agent hands off to another, each hand-off is a card in the reply, and the side panel's Message navigation lists the sub-agents of every message — the heart of Multi-Agent Collaboration. A sub-agent that's waiting on you can be answered from the lead's own status row, since 0.37.0.
• Each turn ends with its model and token stats — the duration having moved up to the reply's own header — and you can export a whole conversation to image, Markdown, or HTML. While a turn is running, the row above the composer adds its output speed in tokens per second beside the elapsed time and the file count — an estimate covering the text and the thinking. It shows on conversation tabs too, and in the read-only transcripts — a to-do's session, a sub-agent's — where you're watching work you didn't start.
• Turn a message into a task. Beside the copy button — on your own messages and on finished replies alike — sits a checklist icon: Create task from message. It takes that text over to To-dos, pre-filled with the project folder, for the follow-up you noticed but don't want to do now.
• Select part of a message. Highlight text anywhere in the transcript and a small toolbar pops up over the selection with three actions: Copy; Quote, which appends it to your draft as a Markdown blockquote — so replying to one paragraph of a long answer doesn't mean copying, pasting, and adding the > yourself; and Ask. Blockquotes render with a proper quote rule now, in the composer and in the agent's own replies. The bubble follows the selection as the thread scrolls and reflows, flips below it when there's no room above, and stays inside a narrow tiled column. Read-only transcripts get Copy alone, since there's no composer to quote into.
• Ask about a passage, without derailing the thread. Ask swaps the bubble's buttons for a question box; type and submit, and Codeg opens a new conversation carrying the quoted passage followed by your question. It starts on this conversation's agent and in the same split group, so the answer comes from the same agent that produced the passage rather than whichever one a blank conversation would have defaulted to — and "why this approach?" about one paragraph doesn't cost you the thread you were reading. From a folder conversation the new one opens on that folder and working directory; from a Chat-mode one it starts as a fresh folderless chat, since chat conversations don't share a folder.
• Copy an image out. Right-click a picture for Copy image — in the transcript, in the blown-up preview, and since 0.28.2 on one you've staged in the composer but not sent yet. On the desktop this used to fail outright for JPEG, WebP and GIF; all three work now.
• Images the agent points at show up. Since 0.36.0 an expanded Read card for an image — Codex viewing a screenshot, say — shows the picture, for a file outside your workspace folders such as /tmp too: click it for full size, right-click for Copy image or Download image. A reopened Codex conversation shows the same card, not a block of base64. And since 0.37.0 a Markdown image in a reply shows even when the file is outside the conversation's folder — a sign-in QR code an agent saved in /tmp, for one — where it used to be a broken-image icon. It loads by itself as the reply renders, up to 8 MB, from the machine Codeg's backend runs on; image files only, and nothing on a network share unless your workspace itself is there. Since 0.38.0, absolute image paths also work in conversations with no known folder, and local Markdown images appear in permission requests, plan approvals, and a to-do's result summary, resolved against the conversation or task folder. → Privacy & Security
• Diagrams get a viewer of their own. A mermaid fence — and since 0.36.0 a plantuml or puml one, in replies, thinking and file previews alike — renders as a diagram with its own controls: zoom from 0.2× to 8×, drag to pan, reset view, and fullscreen. It stays sharp the whole way up, because zooming re-lays-out the drawing at its real size rather than stretching a picture of it. The palette follows your interface theme, and switching theme redraws what's already on screen. Take it with you via Copy source or download it as SVG, PNG or the source — .mmd or .puml. A diagram that fails to render says so and offers Show source and Retry, rather than leaving a blank where a diagram should be. PlantUML is drawn on your machine, by PlantUML's own browser engine loaded on first use, so no PlantUML server is involved — which also means standard-library includes such as <C4/…> aren't available; PlantUML says so inside the drawing, as it does for its own syntax errors.
• A system message shows a preview. A summary an agent writes into the transcript — Pi's branch summary, Qoder's compaction summary — used to be a shut accordion you had to open to learn anything. It renders clamped instead, with a toggle only when there's more underneath. (Claude Code's and Codex's compaction summaries live in the divider's Summary now.)
• Background work gets a strip you can watch. When an agent kicks off work that outlives the turn — Claude Code's background tasks, and since 0.30.3 the long-running commands Codex pushes to the background, badged Background in the transcript — a strip pins itself above the transcript, one row per task that's running or paused: the tool it last ran, what it has cost in tokens, a Stop button, and an Output link opening the task's log in a file tab — each of those appearing once the task actually reports one, so a row can start out as little more than a name. Only unfinished tasks are listed; a task that settles leaves the strip at once, because its outcome belongs in the transcript and a permanent list of finished jobs would just grow all session. Stopping needs a live connection you own, and a stop that's declined says so — a successful one announces itself by the row disappearing, and silence would look the same as a click that did nothing. Grok's background workflows join the strip in 0.32.3, with their phase and the agent currently working and no Stop of their own; the reply Grok writes once one finishes lands in the conversation. One subtraction: from Claude Code's adapter 0.88.0 (Codeg 0.35.0) a running Monitor isn't reported as a background task any more, so it no longer appears on the strip and can't be stopped from there. Since 0.36.0 a Claude Code background sub-agent that stops while its own background work is still running reads Background task: interim result, and no finished notification goes out until it really ends.
• Inserting a message backgrounds what's running — on Claude Code 2.1.286 and later. That version moves a running command, MCP call or sub-agent to the background when a message arrives mid-turn — Insert into current turn — instead of waiting for it or interrupting it, and Codeg badges such a command Background like any other; a question card still open is dropped when you insert, as before. An ordinary send still queues until the turn ends. Since 0.33.0 a background command's card is no longer overwritten with internal marker text when it finishes.
• Notices pop up, they don't interrupt the reply. What Claude Code and Codex announce about a session — a model fallback, a hook that blocked your prompt, a config or deprecation warning — arrives since 0.32.0 as a toast titled with the agent's name, not as a bold line written into the reply; warnings also stay in the status bar's Alerts. Since 0.32.3 that includes a Claude Code plugin that fails to load, named with Claude Code's reason, instead of the plugin silently losing its commands, skills, agents or MCP servers.
• What an agent builds in HTML shows up in the reply. Since 0.32.3 a Codex visualization — and Claude Code's, when it uses the same skill — or a Hermes preview renders as a card right where the reply references it, instead of as raw markup. Any other local .html file a reply mentions gets a Preview row under the reply once it's finished, up to four per reply, opening into the same card. A card's header carries Reload and Open file, and a tall one folds behind Show all. A complete page starts with its scripts off: Enable scripts runs them and lets that card reach the network, for that card only and only until it's gone — nothing is remembered. A Codex visualization's own fragment runs its scripts from the start, inside a sandbox that loads code and fonts only from a few public CDNs, fetches nothing else, and can't reach your files. Paths resolve against the folder the conversation ran in.
• Cards, tables and charts. Since 0.35.0 a reply can carry interactive components drawn right in the conversation — cards, tables, tabs, badges, progress bars, and since 0.35.1 charts in your theme's colours — growing as the reply streams. An agent writes them once you've enabled the UI Render skill for it; ask it to show something as a table or a chart, or start with /ui-render. → Cards, tables and charts in replies

Fork from a reply

A finished reply offers a fork in its stats row: the new session inherits the conversation and the original is untouched, live or reopened alike. Since 0.30.2 this is the whole feature — the composer's old Fork & Send shortcut is gone, a redundant second door to the same thing that couldn't say which reply it branched from. The action appears on a connected session whose agent advertises forking, read off the handshake rather than a fixed list — so the set grows as adapters adopt it, and already reaches past the ones below. ZCode is the exception: Codeg doesn't offer a fork there yet, whatever its bridge advertises. Where it forks from is the part worth knowing, and that part is a fixed list: Claude Code, Codex and DeepSeek Harness can name the individual reply, so the fork lands exactly there — DeepSeek since 0.30.2, and Claude since 0.30.4 even when the reply you picked sits on a branch an earlier fork abandoned. Everywhere else, and on any turn carrying nothing to name it by, the fork lands at the end of the conversation instead of failing. Since 0.33.0 Codeg also asks the agent to close the original session once the fork exists, wherever the agent supports closing one — so Claude Code no longer keeps a process running for every fork, and Codex lets go of the original within about a minute. The request isn't waited on, so it's a tidy-up rather than a guarantee. Open the original on Codex straight after forking and it may still say This session is open elsewhere — reload in a minute.

When a fork isn't offered, it says why. The button greys out with a tooltip instead of vanishing: Can't fork while a turn is running, because naming a message the agent is still writing can't mean anything; and Can't fork from this reply just yet — try again in a moment for a reply Codeg streamed but hasn't finished re-reading, where forking would quietly land at the end of the conversation instead of where you pointed. You hit the second one on the half of a reply that came before a mid-turn message. It usually clears in a second or two, when the re-read names the turn — though a turn you steered right at its end can leave the reply short of the thread's tail with no name ever arriving, and there it stays greyed.

Talk to an agent mid-turn

Watching an agent go the wrong way and having no way to say so until it finishes is the oldest annoyance in this kind of tool. Since 0.30.3 any session with a delivery channel offers a way in: type into the composer while the agent is working, and the split send's chevron holds one extra action beside the ordinary Queue message.

There are two channels, and Codeg words the action differently for each because they promise genuinely different things:

• Insert into current turn ⚡ — the note goes into the work already running and the agent sees it right away. This is Claude Code, on adapter 0.65.0 or newer — and since 0.35.0 a custom agent running that same adapter, recognised by the name the adapter reports when it connects rather than by how you installed it. The floor is a policy decision rather than a version pin: Codeg checks the adapter that's actually running, not the one it would have installed.
• Send note for next check 🕐 — the note is recorded and waits. The agent picks it up the next time it checks, which is the honest description of a tool the agent has to volunteer a call to. This is any other session whose agent was handed the check_user_feedback tool when it launched — Codex, Grok, Gemini, OpenCode and the rest, given the companion and Live feedback switched on before the agent started. Turning the switch on mid-session can't retrofit the tool onto an agent already running. Because those agents typically only check when prompted to, adding "check my live feedback regularly" to your original message is what makes the channel reliable.

A session with neither keeps the plain Cancel-only form it always had.

Attachments come along. A draft holding an image or an @-mentioned file steers as the same block list a normal send uses, so nothing is silently stripped — and the image shows on the message inside the running turn rather than only after you reopen the conversation. On a note session the backend won't take blocks, so the whole draft, attachment included, goes to the queue instead.

Keep typing while it goes. A send into the turn takes a moment to be confirmed, and since 0.34.0 whatever you change in the composer during that moment is kept: the box is cleared only if it still holds exactly what you sent. Kept means the whole draft — a line you added stays together with the text that was already delivered, so trim that part before you send again. Before 0.34.0 the confirmation wiped the composer, edits and all.

A message you already queued can go in too. Queued messages wait as numbered rows above the composer: drag one by its handle to change the order, Edit it back into the composer, or Remove it. Since 0.30.10, while a turn is running on a session with a delivery channel, each row also carries that channel's action — ⚡ Insert into current turn, or 🕐 Send as note for next check — so a message you queued a minute ago reaches the running agent without being retyped. Two rows don't offer it: the one you're editing, whose current text is in the composer rather than the row, and, on a note session, one carrying an attachment, which still goes out whole with the next turn. Only one insert runs at a time — the other rows' buttons grey out until it settles — and since 0.34.0 two quick clicks can no longer slip two messages in at once.

Sent notes show as rows above the composer — waiting until the agent reads one, then received. On the push channel a note is also a real message: it lands in the transcript as its own turn, the agent's answer to it starts a new turn rather than running into the previous answer mid-paragraph, and once the transcript has adopted it that way its row goes, since showing both would print the same thing twice. On the note channel there's no turn to adopt — the row is the whole of it until the agent's next check picks the text up. Since 0.35.0 what you insert into a Claude Code turn also stays in its history — and in a custom agent's, whose transcript Codeg writes itself — so a reopened conversation still shows it where it landed.

Two ways it can miss, both of which say so:

• The turn ended before it got in. The draft is queued instead and sent with the next turn — announced, not silently rerouted. A queued row you clicked moves to the front of the queue since 0.34.0, so it goes out first instead of waiting behind the messages queued before it.
• The agent finished without reading it. The rows survive their turn instead of vanishing, saying "The agent finished before reading your feedback", and each offers Send as message or Dismiss. Notes that were read retire with the turn — they did their job — and your next message clears the rest.

The + menu's Live feedback entry opens a dialog onto the same channel, for a note you'd rather write somewhere other than the composer. → How live feedback reaches a running agent

When a turn fails, it says what kind of failure

A turn that dies used to leave you with a generic error and a guess. Claude Code and Codex report failures by kind — a connection issue, an access issue, a limit reached, a request rejected or a service issue, falling back to a plain session issue for a kind Codeg doesn't recognize — with the agent's own message below it.

The transcript says so too. Since 0.35.0 a turn that fails ends with one muted line where the reply would be — Turn failed: and the agent's own error, or, when the agent gave none, Codeg's reading of what happened. You see it as it happens with any agent; Codex, Claude Code, Cline and Qoder also keep it in their own history, so it's still there when you reopen the conversation, and an export carries it.

Since 0.32.2 a session's warnings and errors arrive the same way: as a notification. Each pops up once as a toast carrying the buttons that would actually help, and stays in the status bar's Alerts list, so a toast you missed isn't gone. Two kinds stay where they belong instead: an agent retrying on its own shows under the composer (below), and a failed compaction shows on its divider in the transcript. The buttons are the agent's suggestion, not Codeg's guess. Three are understood:

• Retry resends the message the failed turn was working on. (If there's nothing to resend, it says so rather than doing nothing.)
• New session starts a fresh conversation.
• Sign in opens Settings in a window of its own, on that agent's page, leaving the workspace you were in where it was. Since 0.32.3 every agent that turns a message away because you need to sign in again gets one, not just Claude Code and Codex.

Retry and New session act on the turn that just failed, so they ride on the toast alone and go quiet once you send another message; Sign in is on the Alerts entry too. A read-only viewer — a to-do transcript, a sub-agent's session — gets the notifications without the recovery buttons.

Alerts is the status bar's right-most entry: a count, red when anything in it is an error and amber when it's only warnings. Entries are newest first, each with its message, a detail line, and — where the agent printed something — a collapsed Details holding that output, its error tail scrubbed of anything that looks like a credential. Dismiss one, or clear the lot. The same message raised again replaces its entry rather than stacking, and the list keeps the latest 50, in memory only.

What stays under the composer is only what's still in progress. When the agent is retrying on its own, an amber line says so with the attempt and the countdown — retrying 3/10, next in 4.0s — and carries no buttons, because there's nothing for you to do while it works through it. Several retries at once collapse into one strip with a +N more count. Once it has recovered, what's left is a single muted Recovered line, which takes itself off after ten seconds instead of announcing a hiccup that's already over.

A crash says why. An agent whose process dies — at launch or mid-reply — is reported with its exit status, and the last lines it wrote to its error output wait behind Details, where a bare Incoming transport closed used to be all you got. A crash mid-reply also closes the connection, rather than leaving a session that looks connected but fails every message. And an agent that asks Codeg for something it doesn't handle is told so and carries on with the turn, instead of waiting forever for an answer.

Opening an old session doesn't replay any of this: a dropped image or a failed compaction from last week stays history instead of surfacing as a live alert and a desktop notification.

A refused prompt costs you the turn, not the session. Every agent Codeg drives rejects some prompt it is perfectly healthy to keep talking to — Qwen Code answers "Slash command not supported in ACP integration" to a /mcp its ACP surface doesn't implement, OpenCode wraps a provider-side rate limit the same way. Until 0.31.2 any of those unwound the whole connection: a terminal error, and a greyed-out composer until a full respawn finished. Now the agent's own message surfaces as a non-terminal error, the turn settles, and the session stays usable — the next prompt just works. Three families stay fatal, because nothing later could survive them either: the agent having no record of the session Codeg just prompted on, an answer saying its session or process is gone, and a response that never arrived at all, which means the transport died rather than the turn. A request for authentication is turn-scoped as it always was.

When the connection looks wrong

The connection heart below the composer is a button. Click it for what Codeg actually knows about that session: the agent, its real state — Responding… is told apart from a resting Connected — the working directory, the session id, and any error. When a connection attempt fails, the heart turns red — Connection error — and its tooltip and popover say why, where it used to fall back to a dimmed Disconnected.

At the bottom sits Reconnect, and it works in every state, including the stuck connecting you'd be clicking it from precisely because it's stuck. It tries to resume the session, so your history comes back with it; where the agent can't load a session, or the load fails, a new agent session starts on the same conversation, which keeps its transcript but not the agent's earlier context.

When a session genuinely can't be reloaded, a banner says which of the known reasons it is rather than the generic "Failed to load session, starting new" — and one of them comes with the fix. A Codex session you've run codex archive on names the exact codex unarchive <id> command with the id filled in, and one click copies it. Before 0.29.0 that case fell outside the recognized failures, so a conversation whose history was one command away from returning was silently orphaned.

Signing out of Claude while a session is open ends that turn and nothing more. Since 0.30.3 the turn stops with "Claude Code needs you to sign in again before it can run this turn" and the session stays where it is — sign in from Settings and send the message again. It used to take the whole connection down with it and leave the conversation reading as cancelled, which said nothing about the actual cause. A delegated sub-agent in the same state reports needs sign-in rather than an unrecognized failure.

Long conversations open fast

A conversation that has been going for weeks doesn't make you wait for all of it. Codeg loads the last 120 turns — nudged back to start on one of your own messages, so a window never opens mid-exchange — and pages in another 120 as you scroll up, without the view jumping under you: the position you were reading holds while the earlier turns are prepended above it. Responses from a server or a remote workspace are compressed on the wire as well.

The window is a display concern only. Exporting still takes the whole transcript, and so does anything else that reads the conversation as a document.

Message navigation reaches past it. Since 0.37.0 it lives in the side panel's Session Details rather than in a chip at the transcript's top-left corner: every message you sent, numbered, with the sub-agents and the files its round involved. It covers the whole conversation, not just what's loaded — pick a message further back and Codeg loads the history up to it and jumps there. A jump stays put, too — a reply still streaming in, or older turns arriving above, no longer pulls you back to the bottom, and the same holds for a reply's jump back to the message that prompted it.

A tab you haven't looked at loads when you first do. Since 0.35.0 a conversation tab sitting behind another fetches its conversation the first time you switch to it, rather than every tab downloading at once on startup — so a workspace with dozens of tabs opens quickly, and such a tab shows a brief loading state the first time you visit it.

A session that fails to load keeps what you can see

If loading a conversation errors, the failure now docks as a small notice above the composer with Reload and New session, instead of replacing everything with a full-page error. The transcript you already had stays on screen and stays readable. Since 0.35.0 it also retries by itself — after 1, 2, 4, 8 and 16 seconds, then every 30 for as long as the view is on screen.

Continue on your phone — Remote Control

Since 0.37.0, with its adapter at 0.93.0, a Claude Code conversation can be picked up on your phone through Claude Code's own Remote Control. Send /remote-control in the conversation — optionally followed by a name for the session — and Claude Code connects it to claude.ai. A strip appears above the transcript, Remote Control is on, carrying:

• the session's claude.ai/code link — click it to open it in your browser;
• QR code, which shows a code to scan with your phone and continue in the Claude app or on claude.ai/code; it's drawn on your machine, with nothing fetched;
• Copy link;
• Turn off, which sends /remote-control off for you. It's available once Claude has finished what it's doing, and waits while a turn runs.

If Claude Code turns Remote Control on but returns no link, the strip says Claude Code returned no link for this session in place of the link, the QR code and Copy link. And a window that's only watching a session another client started has no Turn off.

Claude Code answers the command itself, without a model turn, and doesn't keep that exchange in its history — so after a reload, the strip is what tells you it's on. Sending /remote-control again just brings the link back.

How long it lasts. Remote Control lives in the Claude Code process behind the conversation, so it lasts as long as that connection does. Codeg normally disconnects a session nothing is showing after a few idle minutes; while Remote Control is on, that clean-up leaves it alone, so the session stays reachable from your phone after you've closed the browser page or moved on to other work in Codeg. It ends when you turn it off, when the connection ends — quitting Codeg, a crash, Reconnect — or when you fork the conversation. Closing the conversation's own tab while Claude is idle is a deliberate close too, and ends it.

What it needs. Claude Code signed in with a claude.ai subscription and talking to api.anthropic.com. Through a gateway or a custom ANTHROPIC_BASE_URL — which a Custom Endpoint or a Claude Code model provider sets — Claude Code refuses and says so in the conversation, and no strip appears; Codeg checks none of this itself. The Claude Code process runs wherever Codeg's backend does — your desktop, or the server behind a browser session or a remote-workspace window — and it's that machine's Claude Code that connects to claude.ai. → Privacy & Security

Next steps

• The Side Panel — the session's details, the agent's plan and message navigation, and the files and diffs beside the conversation.
• Working with Agents — enable an agent and get it ready for its first session.
• Multi-Agent Collaboration — hand parts of a task to other agents, or to an assistant, straight from the composer.
• Git & Worktrees — the branch chip under the composer, and the rest of the git workflow.