Agents & Dex

It helps to keep the two apart:

• Dex lives in the voice center, a compact bar at the bottom of the canvas where you can type a question or hold to talk. It can see what is open (your panels, running agents and terminal status) and act on the canvas: open or close panels, run a command, read a panel, or hand work off to an agent. Press Cmd/CtrlL to jump to it from anywhere.
• Coding agents do the long, multi-step work. They run as supervised sessions with a transcript, live tool calls, approval cards and chips for model, effort and mode, either inside a panel on the canvas or as a thread on the Inbox board.

Both surfaces run on the same engine: your own coding agent CLI, signed in under your own account. A rule of thumb: reach for Dex to ask about or rearrange your workspace and kick off quick tasks, and start a coding agent when you want a focused, multi-step session with full control.

Type a question into the voice center and it streams back an answer, using the current canvas as context. What makes it different from a generic chatbot is that it can do things, running small tools inline as it works:

• See the canvas: list your open panels, terminals (idle or running, which ports are listening, which agents are detected) and agents, or pull together the recent errors across all of them.
• Read a panel: pull the live contents of a terminal’s scrollback, a browser’s page, an editor’s file, an agent’s transcript, or a Git panel’s branch and diff summary.
• Move things into view: focus a single panel or highlight several to walk you through them.
• Open and close panels: spawn a browser at a URL, an editor on a file, a terminal that runs a command, or an agent that starts on a task, and close panels when they are done.
• Drive existing panels: type a command into a terminal that is already open, or hand a follow-up task to a running agent.

• @-mention things to point it at specific context: type @ and pick an open panel, or a file or folder from the project, to pin it as context for your message.
• Ref chips in replies: when an answer names a panel or a thread, the reference arrives as a clickable chip that opens the panel or thread it names, so “the errors are in the API terminal” is one click from the terminal itself.

The assistant answers with your own coding agents. Under Settings → Dex, the Who answers section is a ranked list of fallbacks: each rung is a coding agent on this computer (Claude Code, Codex or opencode), optionally pinned to a model, or another of your computers answering with its own signed-in agent. Dex tries the list top to bottom at the start of each turn and answers with the first one available, and when the answer did not come from the first rung the reply says who answered. A dim engine note in the bar names which agent is about to answer. There is no model picker in the bar and no scope to manage: voice and chat act on the current workspace’s live canvas unless you name another machine. The chain itself, including sleeping cloud computers and per-rung ask first, is covered in Settings.

Dex’s hands can reach your other computers, too. Name one of your machines in the request — “create a workspace on Purple Duck”, “start a task on the box” — and the action lands over there, run by that computer’s own rules: its own tool limits, and its own confirmations, which come back to the screen where you asked before anything irreversible runs. Naming a sleeping Deska Cloud computer wakes it; a machine that cannot be reached says so instead of pretending. Ask which computers do I have and Dex lists them.

Every exchange is a durable thread, not a throwaway chat. It survives restarts and the same conversations show up on your phone, so an answer you got at the desk is still there on the couch. And you can go hands-free: double-tap the talk key, fn on macOS or CtrlWin on Windows, to open a conversation where Dex listens, answers aloud and listens again until you double-tap it once more to end it.

Next to Dex sits the Inbox chip: a facepile of the providers currently at work, with a state hint like 2 need you. Hovering it opens a popover with a one-tap Approve for the front request, and clicking it opens the Inbox itself.

Speaking to it works the same way. See Voice for the push-to-talk chord, dictation and spoken replies.

Agent work starts in the New task draft composer, and the composer is the thread until the first send: you write the task, set the chips (agent instance, model, effort, mode and where it runs) and nothing exists anywhere until the message goes out. From then on the same surface is the Thread chat panel, with the transcript, live tool calls, approval cards and a stop button. The Dex fallback chain only orders the composer’s agent list; a task never moves to another computer by itself.

A few controls shape how a thread works:

• Reasoning effort: dial extended thinking from off up through minimal, low, medium, high and extra-high. Higher levels make the model reason longer before acting, at the cost of more time and more tokens.
• Tool approvals: when the agent wants to run a command or edit a file, it pauses and shows an Allow / Deny card right in the thread. The runtime mode decides how often that happens; see the modes below.
• Auto-compaction: as a long conversation approaches the model’s context limit, the agent automatically summarizes earlier turns so the session can keep going without losing track of what you are doing.

Claude, Codex and opencode are not only CLIs you launch in a terminal. Deska can run each of them as a supervised session, speaking their structured protocol instead of scraping a terminal, which is what makes the rest of the agent experience possible:

• Streamed events rather than raw text, so each tool call, file edit and result renders as its own block in the transcript.
• Approvals as real UI: when the agent wants to do something risky it raises an Allow / Deny card in Deska, not a prompt buried in a scrollback.
• Resume: sessions carry a cursor, so an idle session that was reaped, or one interrupted by a restart, picks up where it stopped.
• Token and cost accounting per session, plus model discovery from the provider itself so the picker lists what your account can actually run.

A session can live in a panel on the canvas or as a thread on the Inbox board, where several run side by side and raise their hand when they need you. See Agent threads for the board and Coding agents for the runtime.

The runtime mode is the most safety-relevant setting on an agent. It maps to a real sandbox policy on the provider, not just a confirmation prompt:

• Approval required: read-only until you say yes. Every write and every command waits for an Allow / Deny card.
• Auto-accept edits (the default): the agent edits inside the workspace on its own, and still asks before anything outside it or anything risky.
• Auto (AI reviews risky actions): same workspace-scoped writes, with a reviewer model judging the risky calls instead of interrupting you.
• Full access: no sandbox and no approvals. Use it deliberately, on work you are willing to let run unattended.

Plan mode is the other half. Run a turn in plan mode and the session is read-only: the agent explores, reasons and writes you a plan, and cannot touch a file until you approve and switch it back. It is the safe way to point an agent at unfamiliar code.

One provider can have several named setups. Under Settings → Coding agents → Instances, a page of its own under Agents, you can define, for example, a work and a personal Claude, each with its own binary, its own home directory (so each carries its own sign-in) and its own default model. Pick the instance when you start a session and the agent runs under that account. It is also how you point Deska at a CLI installed somewhere unusual, and one of these instances is the engine behind Dex itself.

Type / in the composer of a structured session and Deska lists the commands and skills the provider itself advertises, filtered as you type, with a badge showing whether each one is a command or a skill. Codex also answers to $ for its own skills. It saves you spelling out in a paragraph what the provider already has a name for.

With Browser preview tools enabled in Settings, a supervised agent can open and drive a browser panel on your canvas through a local MCP toolkit: navigate to a URL, click, type, and take a screenshot to look at what it built. It turns frontend work into a loop the agent can close on its own, and you watch it happen on the canvas rather than reading a description of it. The panel opens on the workspace the agent is working in, not on whatever you are viewing, and it never takes focus; if you wander off to another workspace, the agent keeps driving its preview in the background and the panel is waiting where its work lives when you come back.

Agent conversations are durable threads saved to disk, so picking up where you left off is a click away, and they resume automatically when you reopen the workspace.

The numbers stay visible where the work is: each row on the Inbox board carries a token and context readout, and the Thread panel’s header shows how much of the context window is in use plus the input, output and cached tokens so far.

You can also run the CLIs the plain way, straight into a terminal from the Panel Library: Claude Code, Codex and opencode. The Library checks whether each tool is installed and offers to install it for you, and an auto-approve toggle lets you skip its permission prompts. You get the tool exactly as its authors ship it, without the approval cards, transcript blocks and resume that a structured session adds.

Deska also resumes those conversations after a restart: Claude Code, Cursor, Gemini CLI, Codex and opencode all pick the thread back up. Each CLI handles its own sign-in and models.

On every plan, the assistant and the coding agents run on your own coding agent CLI: Claude Code, Codex or opencode, signed in with your own subscription or provider account, on your machine. Deska does not sell model access and keeps no model catalog of its own.

• Provider keys are optional extras on paid plans. Store your own Anthropic, OpenAI, Groq, Google Gemini, OpenRouter or Fish Audio (voice) key under Settings → Provider keys and Deska uses it for side features like commit-message generation.
• Managed keys cover voice only: transcription and spoken replies run on Deska’s keys, metered in minutes, so voice works without any setup.

The default model is pinned per agent instance: each entry under Settings → Coding agents → Instances names the model it starts with. From there, a thread’s chips can change the model, the reasoning effort and the runtime mode per task, and a change mid-conversation applies from the next turn.

Whichever models your CLI and your provider account can reach are the models you get, including ones released after your copy of Deska. There are no tiers and no upsell in the picker.

The default shortcut for Dex is Cmd/CtrlL, and you can rebind it under Settings → Keybindings. Cmd/CtrlT starts a fresh Dex thread, the way a browser opens a new tab. Cmd/CtrlShiftJ opens the Inbox at the next thread that wants something. The Command Palette has an ask mode too: it opens the New task draft composer prefilled with what you typed, so you review it, pick the agent and send it yourself.