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:

Enlarge screenshot

• 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. Dex also sees named regions and the panels inside each one.
• 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. While a tour runs, every other panel steps back and stays solid, and in the zoomed-out overview the panels Dex points at keep a highlighted frame. Asking for one panel while you are zoomed out brings you in close to it. Pan, zoom or click a panel to leave the tour where you are and navigate freely. Done or Escape returns to the view from before the tour.
• 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.
• Reach Extras and Project tools: Dex sees every row of Extras, the button at the bottom left (the quick note, the focus timer, music and a row for each community panel that has one), and the pages of Project tools at the right edge. It opens Extras on a row, presses a community panel’s control there, and hides that panel’s row from Extras when you want it gone, or brings it back. It opens, folds and pins Project tools pages. It removes a community panel only when you ask it to, and with Act without asking off it asks you first.
• Tell you which skills you have: ask “what skills do I have installed?” and Dex lists them, the same list as Installed in the Marketplace: the skills every project gets, then each open project’s own, with the agents that use each one, including skills you installed without Deska. The answer ends in a chip that opens that list. Name another of your computers to hear what it has. Skills that came inside a Claude Code plugin are not on the list.

• @-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.

Dex answers the way a person would, because you often hear the answer rather than read it: one or two sentences that say what it did or what it found. It does the steps without listing them first and does not recap at the end. When something failed or is still running, it says so in those same few words, and when it has no way to see something, it says that instead of answering that there is none. Ask for more when you want it (“explain”, “give me the details”) and it goes into detail; ask for a list and you get one short line per item.

The assistant answers with your own coding agents. The quickest way to choose is Dex answers with in Settings → Agents, which sets the agent Dex tries first. Under Settings → Dex, the Who answers section is the full ranked list of fallbacks: each rung is a coding agent on this computer (Claude Code, Codex, OpenCode, Cursor, Antigravity, Pi, Hermes, Mistral Vibe, and Kimi Code), 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 also knows which panels matter before it answers. A small model on your computer reads every panel and task as you work: each turn of a conversation with the agent’s reply, each command in a terminal with its output, the sections of documents and notes, the text of pages. When you ask something, Deska finds the panels that match in a few milliseconds, across every project on this computer and their whole history, and hands them to Dex with the passages that matched, so it answers without opening panels one by one. Ask for a panel by what happened in it, like “take me to the task where we redesigned the hero”, and when the match is clear the canvas moves there as soon as you finish speaking, while your keyboard stays where you were typing. The only panel of its kind moves the same way, like “take me to the pomodoro”. When two panels fit equally, Dex points at both and asks. Spanish and English both work.

The model is a 30 MB download that runs on this computer, and the index sends nothing anywhere: the passages that match a question go to the agent that answers Dex, the same way a panel Dex reads does, with keys, tokens and passwords it recognizes removed first. Deska downloads it by itself the first time it opens, and after an update on a computer that already had Deska; nothing asks first. While it downloads, and while it reads the history you already had, a small status over Dex shows how far it is, and Dex keeps answering as before. If Dex answers while older history is still being indexed, it says so when the answer could depend on it. Settings → Dex → Panel search retries or removes it, and downloads it again after you remove it.

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.

None of this needs a project folder. A canvas of terminals, browsers and notes with no repository behind it is an ordinary desk, and panels, terminals, notes, workspaces and threads all work on it. What does need a checkout is anything touching files or git — finding a file, creating one, saving a panel, starting a coding agent or a supervised task — and there Dex names the limit and offers to open a folder rather than refusing the request.

When Dex starts a task for you, the task’s chat opens on the canvas of the workspace it runs in, in a free spot that covers nothing, so you can watch it work. Ask for several tasks and each one gets its own chat. If you want one out of sight, say so (“in the background”, “don’t open it”) and it starts without a panel; you find it in the Inbox. A task you ask for from your phone opens on the computer too, without moving what that screen is showing.

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. Clicking it opens the Inbox popover: every task across your projects, the ones that need you first, each with its agent and where it runs, and a one-tap Approve when a request is safe to accept. Past five tasks the popover adds a search box, ready to type as soon as it opens, and four tabs that show how many tasks each holds: All, Needs you, Working and Landed. A button at the end of the tabs changes the order: Needs you first (the default), Recently finished, which puts tasks still in progress first and the rest by when they finished, or Newest first. In those two orders each finished task also shows when it finished or, in Newest first, when it was created. The popover reopens on the tab and in the order you last chose. The list keeps filling in as you scroll. Type a few letters and press Enter to open the first task that matches, or move through the list with the arrow keys. Open inbox at the bottom opens the full Inbox.

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. Every New task opens its own composer, so you can write several tasks side by side; drafts you already opened keep their text.

Dex can open those drafts for you. Ask for “three tasks with Claude Code on Opus, I’ll tell you what goes in each” and it opens three New task drafts side by side, already set to that agent and model, and starts nothing. When you then say what goes in each, Dex writes it into those drafts and presses Start, so each draft becomes its task; say you want to read them first and it only writes them in.

Name a region to put those drafts there: “open three task panels in the Review region, I’ll fill them in”. You can also ask Dex to start a task in a named region, or select a region and say “in this region”. The area grows if needed and there is room to fit the panels without covering existing ones. If a panel cannot fit, Dex says so; a task that already started stays in the Inbox. This chooses where the panels appear; the tasks still work in their workspace’s folder. See Regions and selection.

Task chats follow incoming replies smoothly instead of jumping a whole line at a time. Scrolling back pauses following; return to the bottom to resume. The system’s reduced-motion preference keeps following instant.

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. A new task opens on the level you last picked for that agent. A model that does not offer it runs at its own default, and going back to one that does brings your level back.
• 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 Code, Codex, OpenCode, Cursor, Antigravity, Pi, Hermes, Mistral Vibe, and Kimi Code 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 Approve / Decline card in Deska, not a prompt buried in a scrollback. never asks, so it raises none.
• Resume: sessions carry a cursor, so an idle session that was reaped, or one interrupted by a restart, picks up where it stopped.
• Token accounting per session, plus model discovery from the provider itself so the picker lists what your account can actually run. lists no models yet and runs on its own default.

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 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 (the default for new tasks): no sandbox and no approvals. The task composer’s settings chip switches a task to a safer mode before it starts; there the modes read Supervised, Auto accept edits, Auto and Full access.

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.

Agents are set up in one place: Settings → Agents. At the top, Dex answers with picks the agent for Dex and New tasks use picks the one new tasks start on; Use the same agent as Dex makes them match. Below, each agent card offers Install, Connect account or Change account, and separate checks for Dex and for tasks.

Dex reasoning effort, under Dex answers with, sets how hard Dex thinks before it answers. It starts on Default, the lightest level that still reasons: low on most models, and one step up on models whose list starts at none or minimal. You can pick any other level that model lists, those two included. On OpenCode the row appears for models that offer variants, as OpenCode calls its levels. It only changes Dex: new tasks keep their own effort. When you ask Dex to start a task at a given effort, it passes that level to the task, and if the model does not offer it, Dex says which levels it does.

One provider can have several named setups, called provider instances. Add agent adds a provider or another account, for example a work and a personal Claude Code. Every agent can keep separate accounts. 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. See Agents and accounts for the details.

On desktop, click the / button beside the microphone to open Commands and skills in a new task or an existing local task. Opening or dismissing the menu leaves your draft intact. Picking an entry adds it before your text. You can still type / to open and filter the list.

Type / at the start of a message in a task’s composer and Deska lists the commands and skills the agent itself offers, filtered as you type: each one as you would type it, and what it does. Codex also answers to $ for its own skills. It saves you spelling out in a paragraph what the agent already has a name for.

The list is there before a task has ever run. When Deska reads an agent’s models it reads its commands too, from Claude Code, OpenCode and Codex, so a new task, or a task you reopen after restarting Deska, offers them right away. The skills installed in your project are listed as well, from the folders each agent reads (.claude/skills and .claude/commands for Claude Code, .agents/skills for Codex, OpenCode and Antigravity), so a project’s own skills show before any task has run there. A new Mistral Vibe task lists the skills in ~/.vibe/skills and ~/.agents/skills before it runs; the skills of a project show once Vibe trusts that folder. A running session’s own list takes over as soon as it reports one. Cursor, Hermes, Kimi Code, Mistral Vibe and Pi share their commands only once a task starts (for Pi, your prompt templates, skills and extension commands), so a lone / says so in one line instead of showing nothing. With two accounts of one agent, each with its own skills, a new task offers the list of the account it runs on.

A message that starts with one of the agent’s own commands reaches the agent with that command first, also in Plan mode and right after a Stop, so the agent runs it instead of reading it as a request. A command the agent answers itself, such as /help or /compact, is not offered as a plan. A skill or a prompt template is a request to the model, so in Plan mode it still plans. A message that only starts with a slash, such as a file path, is sent like any other.

Codex keeps most of its slash commands in its terminal app, so Deska runs four of them itself. /goal followed by an objective keeps Codex working on it, turn after turn, until it is done. /review reviews your uncommitted changes, or whatever you describe after it. /compact summarizes the conversation to free up context, and /init writes an AGENTS.md for the project. While a goal is set, a strip above the composer shows it with its status and Pause, Resume and Clear. You can also type /goal pause, /goal resume, /goal clear or a bare /goal, from the phone too. Commands that only change Codex’s terminal, like /vim or /theme, are not offered, and the ones Deska already has controls for, like /model or /permissions, use those controls.

Antigravity lists the skills installed in the project and in ~/.gemini/config/skills. A message that starts with one of them runs it as that skill; any other message that starts with a slash stays plain text. /plan followed by a task runs that task in Plan mode, and on its own it turns Plan on.

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.

Some community panels offer actions to a task’s agent: reading the notes on a board, adding an image to it, changing a card. Connect one to a task, and that task’s agent can use them while it works. Such a panel cannot reach the internet, so what the agent hands it stays on this computer. See Panels that work with your tasks.

• Connecting. Press Connect to a task on the strip Deska draws over the panel and pick one of the project’s tasks, or press Connect a panel in a task’s header. The first time, Deska asks Let <agent> use <panel>?, listing every action the panel offers, whether it reads or changes the panel, and its description in the author’s words. Allow connects it. Cancel connects nothing, and the next Connect asks again.
• Which tasks. Supervised tasks on this computer only. Dex, agents in a terminal and tasks on another computer never connect.
• Disconnecting. The same menus hold Disconnect. A connection also ends when the task or the panel closes. Turning Work with your tasks off on the panel’s page disconnects it from every task, and Settings, Agents, Panel actions turns panel actions off for every task.
• What Deska checks. A call reaches only a panel connected to that task, and only once it matches what the panel declared. An image the agent hands over must be in the task’s own folder.

Send to task. A panel can offer what you made in it, such as comments on a board and the images you picked, and Send to task lights up on its strip. The panel cannot press it. Press it to see exactly what goes and where: the connected task, as its next message, or a New task draft that you start yourself when no task is connected. Cancel keeps the offer. Content from a panel only goes to a task on this computer.

The pause for approvals. When a task reads from a panel, or receives what you sent from one, Deska switches it to Supervised for the rest of that turn, even in Full access, and puts your mode back when the turn ends. What Supervised asks you about is each agent’s own choice. A line in the task says why, and once the turn is over a row offers Keep asking, which keeps the task in Supervised until you change it. If you change the mode yourself during that turn, your choice stands. While the pause holds, Deska’s browser preview tools wait for you, and Dex asks you before it loosens the task’s mode or approves anything for it. Claude Code, OpenCode and Antigravity read a panel in the middle of a turn. Codex, Cursor and Claude Code in Plan mode cannot change mode until the next turn, so there what the panel answers waits until the turn ends and then reaches the task as its next message, in a turn in Supervised. Stopping the task or its turn drops it. A message from a panel always runs in a turn of its own, and you cannot edit it. What the pause does not hold.

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.

The agent that answers Dex also does a few small jobs nobody asked for: a short summary when a terminal or thread settles, one read at a time and at most 20 a day on each computer, and a title for each new thread. Each starts a short session on that agent’s plan. Turn off Background work in Settings, under Dex to keep every token for what you ask; Summarize and Generate message still work when you click them.

You can also run the CLIs the plain way, straight into a terminal from the Panel Library: Claude Code, Codex, OpenCode, Cursor, Antigravity, Pi, Hermes, Mistral Vibe, and Kimi Code. Set an agent card’s Opens as pick to Terminal and you get the CLI’s own interface; Task opens a structured task instead, with Deska’s approval cards and structured transcript. The Library checks whether each tool is installed and offers to install it for you, in the background on this computer (the Update Center shows it once the Library closes). Whether a terminal launch skips the agent’s permission prompts is one switch per agent in Agent autonomy, not on the card.

Deska also resumes those conversations after a restart: Claude Code, Codex, OpenCode, Cursor, Antigravity, Pi, and Gemini CLI pick the thread back up, while Hermes, Mistral Vibe, and Kimi Code do not get theirs back yet. 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, OpenCode, Cursor, Antigravity, Pi, Hermes, Mistral Vibe, and Kimi Code, 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.

• No provider key needed: Deska never asks you for one. A key stored by an earlier version stays in your operating system’s secure storage.
• Managed keys cover voice only: transcription and spoken replies run on Deska’s keys, metered in minutes, so voice works without any setup.

Each agent in Settings → Agents has a default model. Unless you choose one, Deska picks the latest stable model of a lighter, faster family from what your account lists: Sonnet for Claude Code, GPT Luna for Codex and Gemini Flash for Antigravity. Dex differs on Claude Code only: there it answers on Haiku, Claude’s fastest family, and when your account refuses Haiku, Dex uses Sonnet. On every other agent, Dex uses the same model as that agent’s tasks. An OpenCode connection kept on Kimi uses Kimi’s own default. Models you chose are kept. If the family is missing or the list fails to load, Deska says so and offers a retry rather than silently picking another model. From there, a thread’s chips can change the model, the reasoning effort and the runtime mode per task. Within the same agent account, a model change applies from the next turn. Another agent or account offers a new conversation with copied history; its first send uses tokens to read that history. See Default models.

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.