Coding agents

A task uses the agents, accounts and models on the computer that owns its project. Installing OpenCode on a computer does not guarantee access to every model: some models need a connected provider account. On a Deska Cloud box, OpenCode works from the start with its free models and no account: it reads Ready, free models, and while nothing else is signed in there it is what new tasks and Dex start with.

If an agent is not signed in, the model picker says Not signed in with a Sign in button that opens that account on the correct computer. In the account settings the same button starts its sign-in, and the full error is under Details. On a Deska Cloud box every sign-in runs on the box, and your phone or desktop only opens the provider’s page. The accounts on a computer says what each agent asks of you.

On the phone, an agent that is not signed in can still be chosen in New task. Type the task and press Send: the sign-in comes first, and the task starts with what you typed as soon as it finishes.

When a turn fails because its agent is not signed in, the phone shows one card in its place, such as Cursor is not signed in on Deska Cloud, with a Sign in to Cursor button. When the sign-in finishes, the message is sent again on its own; a message with attachments goes back into the composer instead, ready to send. If you signed the agent in from its Agents screen after the turn failed, the card says Cursor is signed in now and offers Send again instead of a second sign-in. The raw error stays under Details.

A task that cannot start keeps its prompt and attachments. Finish connecting the account, then press Start again. A conversation that cannot be loaded offers Try again without creating another task or requiring you to close its window.

You can always run an agent CLI by hand in a terminal, and for a quick one-off that is often the right thing. When Deska starts the same CLI as a structured session it speaks the tool’s own protocol instead of reading its screen output, and that buys four things:

Enlarge screenshot

• Streamed events instead of scraped text. Messages, tool calls, plan updates, delegated subtasks and provider notices arrive as separate items, so the transcript can render each one properly rather than as a wall of terminal output. Routine hook activity stays out of the conversation on desktop and phone, including when reopening older threads. Hook failures and blocks remain visible with any details the agent reports. The model’s thinking is one line that reads Thinking while it thinks and how long it took, such as Thought for 12s, as soon as the agent acts, writes or stops. The line opens to the reasoning, and once the turn is over it folds away with the rest of the work.
• Approvals and supported questions as interface cards. A permission request pauses the turn and shows a card you answer with a key or a click, in the panel or on your phone, rather than a prompt buried in scrollback that only the focused terminal can answer.
• Conversations that survive a restart. Deska records a resume cursor for every session, so reopening the app and sending the next message reopens the same provider conversation with its context intact. A turn that was in flight when the app closed is reported as failed rather than silently replayed, because re-running side effects you never re-issued would be worse than saying so.
• Real token accounting. Input, output and cached tokens are folded per thread, with a context ring shown only when the provider actually reported its window size.

Structured sessions are what the Inbox board supervises. See Agent threads for the board itself, and Agents & Dex for the canvas-aware chat.

In the Panel Library, select an agent card whose Opens as pick is on Task, the default, to open a new task with that agent and its default model. Each agent card opens its own draft, so tasks you are already composing keep their text and selections. You can change the agent or model before pressing Start.

Only the five agents above run as structured sessions. Every other agent CLI still runs here, in a terminal panel: a real shell in your project, on this computer or on any computer you linked, so the agent behaves exactly as it does in your own terminal, with its own configuration, its own sign in and its own keybindings.

Deska keeps watching it. It reads the rendered screen rather than the provider protocol, which is why it works for an agent nobody integrated: the terminal shows whether the agent is working, waiting on you or finished, the desk and your phone are notified, and you can open that terminal from the phone and answer it there.

Gemini CLI, Aider and PI Agent are recognized by name, which is what the tab badge and the agent tint read from. Anything else, from Goose and Amp to a script of your own, runs the same way without the badge. Conversations are brought back after a restart for the CLIs listed in the terminal docs, which needs zsh on macOS or Linux.

What a terminal does not give you is the task layer: the rendered transcript with its diffs and plan steps, permission requests as buttons, the model and account pickers, and tasks with a git worktree each on the Inbox board. Those need a structured session, so they stay with the five.

The runtime mode is the single most important setting on an agent: it decides how much the agent may do without asking you. Deska maps your choice onto each provider’s supported permission policy. Approval behavior and OS sandbox support differ by provider; the sections below describe those differences.

• Approval required asks before actions the provider exposes for approval. The exact behavior depends on the provider; this mode does not guarantee an OS sandbox or that every edit is intercepted.
• Auto-accept edits lets the agent write inside the workspace it was started in without asking each time, and anything reaching outside that boundary still needs your approval.
• Auto (AI reviews risky actions) keeps the same workspace boundary but routes risky-action approvals to a reviewing model instead of to you. Not every provider has a reviewer; where none exists the session behaves as auto-accept edits rather than pretending to review.
• Full access lets the agent run tools without Deska’s approval prompts, with the access available to your user account.

You pick the mode when you create a thread and can change it mid-conversation from the composer’s Settings menu, under Permissions, where the four modes read Supervised, Auto accept edits, Auto and Full access. A new task starts in Full access unless the agent’s Default mode under Settings → Agents, or the mode you last chose for that agent, says otherwise. Modes that the current provider and model provably cannot honour are shown disabled rather than silently ignored.

The compact model picker uses the provider’s color until you choose a custom color in Settings → Agents. The Color control previews the current color even when closed, and the model button keeps that color after selection. Hover or focus its icon to read its name; the agent you are browsing is also named above its models. After the last agent comes a +, Add agent. It closes the menu and opens Tools & accounts for the computer the task runs on, with Add agent already open: pick a provider and its new card opens, where you name it and connect its account. It is there on a running task too, and what you add serves the next tasks. It adds another account or setup of an agent Deska supports, not a new kind of agent.

One machine often has more than one way to run the same agent: a work account and a personal one, a stable install and a nightly build. Each named setup is a provider instance, and all of them live in one place: Settings → Agents, under Your agents. The page configures this computer; other computers keep their own agents and accounts.

The same list also opens in Tools & accounts, the screen every computer has for its agents and sign-ins: add or remove an agent, pick what Dex and new tasks use, then sign in to GitHub and each agent below. It looks the same on this computer and on a Deska Cloud box. On a box, every sign-in there, extra accounts included, runs on the box itself: the screen shows the page to open and any code to use, and no terminal opens on the box. Open it from a computer card in Your computers, from Manage agents or the + in a task’s agent picker, by typing accounts in the command palette, or from Settings → Agents → Tools & accounts.

Enlarge screenshot

Two choices at the top decide what runs when you do not pick anything:

• Dex answers with is the agent Dex tries first. It sets the first entry of Dex’s fallback order, which you can still reorder under Fallback order for Dex on the same page. Existing conversations keep their selected model.
• New tasks use is the agent a new task starts on. A project default or a choice you make when starting a task overrides it. When it differs from Dex, Use the same agent as Dex copies Dex’s choice, and Ask each time leaves the pick to each task.

Below them, each agent is a card. Expand one to see its status and act on it:

• Install appears right on the card, next to Not installed, when the CLI is missing. It runs the provider’s installer in a terminal panel, where you follow its progress and can cancel with CtrlC. The card reads Installing meanwhile and says the agent is installed, with its version, as soon as the CLI answers. No Refresh needed. For agents installed through npm, when npm is not available the button reads Installation guide and opens the provider’s instructions instead.
• Connect account opens the CLI’s own sign-in in a terminal panel. When an account is already detected the button reads Change account. Finish in the terminal and the status updates on its own. Coming back to Deska also rechecks any agent that was signed out, and Refresh checks again whenever you want.
• The Status row names the account on a line of its own. Like every email address in Deska it stays blurred until you click it, then shows in full, so two accounts that start alike are easy to tell apart; another click hides it again: Signed in as [email protected]., Signed in with an API key. or Signed in with a ChatGPT account. Antigravity shows the Google account it signed in with on macOS and Linux; when it cannot tell, the line reads Signed in with Google. Antigravity did not say which account on this computer. An agent with no login reads Not signed in on this computer., and Not checked yet. means Deska could not confirm the sign-in without running the agent. That one does not mean you are signed out, and a connection check settles it.
• The sign-in for [email protected] expired. Sign in again to use it. means the login is gone, with Sign in expired beside the agent’s name. It shows when the agent refused its saved login during a task (for example a Claude Code session that could not be refreshed) and, for Claude Code on macOS, whenever the login in the keychain is missing even though Claude Code still remembers the email. The button then reads Sign in again, and the failed turn in the task offers the same Sign in again, which opens that account’s sign-in. A refused login is remembered when Deska restarts, until a task on that account works, you sign in from Deska, or the agent’s login is written again (for example by running claude /login in your own terminal).
• Update appears when the installed CLI is older than the provider’s latest release and CLI update checks is on.

Add agent opens a list of providers; one you already have reads Another account when this computer can keep a second account of it, and One account only when it cannot. One you disabled reads Enable instead, and picking it turns it back on rather than adding a duplicate. Claude Code, Codex, OpenCode, Cursor and Antigravity can keep separate accounts on macOS, Linux, Windows and Deska Cloud. An account you add gets a folder of its own right away, and its Connect account opens the CLI’s login in a terminal, so two accounts of the same agent sit side by side and signing one in never signs the other out. A setup added before that, still sharing the default account, offers Use its own account instead, which does the same. Separate accounts covers signing in and out, removing an account and what each agent does differently. Adding an agent does not change what Dex or new tasks use, and it is not added to Dex’s fallback order on its own. Removing an agent you added always confirms what goes with it: its settings, any secrets it stored, and the threads still pointing at it. The built-in setups, one per supported agent, can be disabled but not removed.

To use existing Codex accounts, set each instance’s Home path to its account directory, such as ~/.codex-a or ~/.codex-b. Binary path points to the executable, such as codex.exe on Windows; several accounts can share that executable. New tasks use the selected instance’s executable even when Codex is not on PATH.

Saving or enabling an instance updates the task picker immediately. If loading the agent list fails, the composer explains the problem and offers Retry. When no agents are enabled, Configure agents opens their settings.

Instances matter for one more reason, and it is the headline one: they are also the engine behind Dex. The assistant does not run on a Deska-managed model; it runs on your own agents, through a ranked fallback list. Dex answers with sets its first entry, and the whole order is under Fallback order for Dex on the Agents page and under Fallbacks in Settings → Dex, in the Who answers section. Each entry is one of these instances, optionally pinned to a model, or another of your computers answering with its own signed-in agent.

If a rung is not available, because the agent is not installed, nobody ever signed into it, or the computer is offline, Dex moves on to the next rung rather than failing on the first. When nothing on the list can answer, the reply says exactly which rung failed and why, and points you to Settings → Dex.

Each instance can carry its own:

• Binary path, when the CLI is not the one first on your PATH.
• Home path is the folder an instance with its own account keeps its sign-in and personal settings in. Every agent has it wherever this computer can keep a separate account of that agent.
• Default model, Default mode (the runtime mode) and, where the provider supports it, a Reasoning effort.
• Launch arguments for provider flags Deska does not model, appended verbatim when the session starts.
• An accent color, purely so its threads are recognisable at a glance on the board and in the chat header.

The instance’s name is how its threads name their agent: the chat header shows it beside the provider’s logo, and the board’s details, the Inbox and the phone show it too. With accounts named A, B and C, each panel says which one it is using. An instance you never renamed keeps its provider’s name, such as Codex or Codex 2.

Values resolve from most specific to least: what a thread pins, then the project default, then the instance default, then the provider’s own. Deska also probes each instance’s credential store cheaply and badges the ones that look signed out, so a thread that is about to fail on authentication says so before you send a message.

One computer can hold several accounts of the same coding agent, such as a work and a personal Cursor. Each extra account is a provider instance with a folder of its own for its sign-in, personal settings, plugins, MCP servers, cache and history. Your projects and their rules stay shared on purpose.

Where a separate account is available:

• Claude Code, Codex, OpenCode, Cursor and Antigravity: macOS, Linux, Windows and Deska Cloud.

The computer that runs the agent decides what is possible there, and the desktop and the phone show its reason when it says no. A computer running an older Deska offers no separate account for these agents until it is updated.

To add one:

• On this computer: in Settings → Agents, choose Add agent, pick the agent (it reads Another account), then Connect account on the new card. The agent’s login opens in a terminal and the card updates on its own when you finish.
• On another computer, from the desktop: open its Agents section in Tools & accounts, choose Add agent and turn on Separate account. Then use Connect account on the new agent to sign it in on that computer. On a Deska Cloud box the sign-in runs on the box and Deska shows its page and code; on one of your own computers it opens in a terminal there.
• From the phone: open the computer’s Agents, choose Add another account, which appears once something is signed in there, and pick the agent. The new account is named after it with a number, such as Codex 2. On a Deska Cloud box its sign-in starts right away, the same way as the computer’s own, and closing that sign-in before it finishes removes the empty account again. On one of your own computers, its Sign in opens a terminal there with the command already typed. New task leads there too, on the phone and on app.deska.dev: Add agent, under the agents in its agent and model picker, opens the computer’s Agents, with Add another account already open once something there is signed in.

The default setup of each agent keeps using the sign-in already on the computer, and updating Deska never moves or copies it. On the phone, a computer’s Agents shows that sign-in and every extra account in one list, and each account signs in and out on its own. On the desktop, Tools & accounts shows the shared sign-in once per tool, and extra accounts live in its Agents section, each signing in with its own Connect account and out with its own Sign out.

An agent you added that still uses the computer’s own sign-in gets a folder of its own when you sign it in, from this computer, another one or the phone, so it never replaces the account the computer’s own setup uses. If that shared sign-in has expired, signing in from any of them repairs it for all of them instead.

When a new account comes back as one you have

The sign-in page opens in your usual browser, and Codex and Claude Code take whichever account that browser is signed in to. When two of your accounts turn out to be the same person, both say so, for example Same ChatGPT account as Codex. Sign out of ChatGPT or Claude in that browser, or switch to the other account on the sign-in page, then choose Change account on the new one.

Signing out and removing

• Sign out clears that one account’s sign-in and leaves every other account alone. When the account has tasks running, Deska says how many and stops them only after you confirm.
• Remove takes the account off the computer and keeps its files. Its tasks say the account was removed and cannot resume.
• Also delete its data is a separate choice in the same dialog, with its own confirmation. It deletes only the folders Deska created for that account; a folder you chose yourself is kept.

Tasks keep their account

A task runs on the account it started with for its whole life, including restarts, resumes and queued messages. Changing the default account affects new tasks only, and a task never moves to another of your accounts on its own. If you use Change account on that account later, for example after a usage limit, the task keeps its conversation and continues as whoever is signed in now. The thread notes the change. A task whose account was removed cannot continue.

What each agent does differently

• OpenCode and Cursor: a new account starts without your global MCP servers and plugins, the same way a separate Claude Code or Codex account does. Add them again inside that account if you need them.
• Codex on macOS: when the ChatGPT app has Computer Use turned on, every separate Codex account can use it too. Deska lends the account the app’s Computer Use setup each time a task starts; the account’s own settings file is not changed and its sign-in stays its own. Turn Computer Use off in the ChatGPT app and the separate accounts lose it as well. On Windows the same holds for every Codex task, the computer’s own sign-in included, while the ChatGPT app is running: Deska connects each task to the app’s Computer Use when the task starts, and the app shows its own approvals. When a turn ends, however it ends, Deska tells the app, so its “ChatGPT is using your computer” banner goes away without pressing Esc. Restart ChatGPT and the next task picks it up again.
• OpenCode: provider API keys exported in your shell are not treated as the account’s sign-in; the account signs in with its own opencode auth login on your own computer, or with Connect a provider on a Deska Cloud box. Commands the agent runs still see those variables. A separate account runs only on the OpenCode versions Deska has checked, and on any other version it does not start and says which version to install. That includes OpenCode 2 (@opencode/cli): from the next desktop update tasks and Dex run on it with the computer’s own OpenCode sign-in, while a separate account still needs OpenCode 1.
• Cursor: a separate account refuses to start in a project whose .envrc exports CURSOR_API_KEY or CURSOR_AUTH_TOKEN, because that would sign it in as a different person. The message names the file; remove the variable or use the computer’s own Cursor sign-in in that folder.
• Antigravity on macOS and Linux runs the native agy in a home folder of its own, with its own keychain on macOS. Commands its agent runs still reach your files through links to your home, but on macOS they do not see your login keychain: git push over HTTPS and gh ask to sign in again there. Use SSH remotes, or sign those tools in inside that account.
• Antigravity on Windows runs Google’s Antigravity ACP runtime for a separate account, so that account has no terminal. Sign it in with Sign in with Google inside Deska. On the Windows computer itself your browser opens. From another computer or the phone, the Google page opens on your device; when it finishes, copy the final address from the browser and paste it back into Deska, because the sign-in returns to the Windows computer. Each session takes longer to start, often tens of seconds, because the runtime unpacks on every launch. The runtime itself (about 125 MB) downloads once per computer, as soon as you add the account; until it finishes, the account’s row shows how far along it is, and Google’s page opens after it. The runtime lists its models only from inside a session, so right after signing in Deska opens one in a temporary folder to read that account’s own models, then removes it, so it never shows in the account’s history. An account that signed in before the next desktop update gets its list the same way the first time its models are asked for. Until the list arrives the picker says Models appear after the first task and a task runs on Antigravity’s own default model; after it, Automatic picks the latest Gemini Flash as usual.

An installed, signed-in CLI is not proof that it answers. Each expanded agent card has two separate checks, because Dex and tasks use an agent differently:

• Check Dex, on the Dex and desk tools row, asks the agent to use one of Deska’s read-only desk tools and reply. It passes only when the tool call really succeeded, so a greeting alone is not enough. Open a desk on this computer first.
• Check tasks, on the Task responses row, starts a task session and waits for a short reply without tools. Your project files are not part of the check.

Checks run only when you choose them, never when you open Settings. Each one sends a short request using your provider account, so it counts toward that account’s usage. A result reads Worked on or Failed on followed by when it ran and which model answered, and Cancel stops one in progress. Before the first run, or after the agent’s setup, version or account changes, the row reads Not checked yet. The buttons are disabled while the agent is not installed or not signed in.

Model lists refresh in the background when they are over 15 minutes old while the desktop is visible, and when you return to Deska. Opening a model picker checks again once its list is a couple of minutes old, keeping the models on screen while it does. Starting a task with Claude Code, Codex, Cursor or OpenCode refreshes that agent’s list too, read from the task’s own process at no extra cost, and an open picker shows a new model as soon as one appears. Detecting an updated agent also refreshes its models. Your selected model stays selected. To check immediately, use Rediscover on the agent card.

When neither you nor the project picks a model, Deska chooses one from the models your account actually lists, preferring a lighter, faster family by default:

• Claude Code: the latest stable Sonnet.
• Codex: the latest stable GPT Luna.
• Antigravity: the latest stable Gemini Flash.
• OpenCode: set Model provider to keep a connection on one provider, such as Kimi, and it uses the default model OpenCode reports for that provider. If OpenCode reports none, Deska asks you to choose one. With All connected providers, OpenCode picks.
• Cursor: the provider’s own default.

Preview, experimental and larger context variants are never picked on their own. The same rule covers Dex and new tasks, including the tasks Dex starts. The model is resolved when a conversation or task starts, and a conversation keeps it from then on. A model you change for an agent, or for a rung of Dex’s answer chain, reaches an open Dex conversation on its next message.

Model selection on each agent card has three choices: Automatic follows the recommended family and names it, Provider default lets the agent choose (its default may use more time or quota), and Specific model keeps the exact model you enter. A model you chose, for an agent, a project or a task, is always kept; the recommendation only fills in when nothing was chosen. The line under it says what new sessions use.

If the recommended family is missing from your account, or the model list fails to load, Deska does not quietly start a different model. The agent card and the task’s model menu say what happened and offer Rediscover or Retry loading models, and a task or Dex turn that needs the missing recommendation stops with the same explanation instead of running on another model. Choose a specific model or Provider default to go ahead. See Models do not load.

Plan mode changes what a turn produces rather than what it is allowed to do. Press ShiftTab in the composer to arm the next turn as planning, and a Plan mode badge appears. That turn researches the codebase read-only and comes back with a proposed plan instead of editing files, whatever runtime mode the session is in.

Each provider does this its own way, through its native planning permission mode, a read-only per-turn policy, or a built-in planning agent, so you get the same behaviour across supported providers. The result lands as a Proposed plan card in the thread, where Implement sends the plan back for execution, Refine prefills a follow-up asking for changes, and Implement in new worktree thread starts a sibling thread in its own checkout so planning and execution never share a working tree.

Deska does not ship a hardcoded model list for these agents. It asks each installed CLI for its own catalog over the protocol the CLI already speaks, then shuts that probe down. You get the models your install and your account actually have, including ones released after your copy of Deska. Discovery runs on demand from settings, is time-bounded, and its results are cached, so nothing waits on it during normal work.

Every list shows the most capable models first. Within one maker its families run from most to least capable (Claude Code: Fable, Opus, Sonnet, Haiku; Codex: Astra, Sol, Terra, Luna), the newest version first in each. Agents that offer several makers’ models list their own first (Composer in Cursor, Gemini in Antigravity), then Claude, GPT, Gemini and Grok, each maker kept together; OpenCode groups them by the provider they come from. The default model keeps its place in that order: the Default model row at the top names it.

Sessions also pick up what the CLI advertises about itself. Slash commands the provider exposes become available in the composer (Codex lists its own skills behind $ as well), and providers with named agents or personas expose those too. The same discovery that lists models also reads Claude Code’s and OpenCode’s commands and Codex’s skills, on the process it already started, so the composer offers them before any session has run. Changing the model on a thread is safe at any time: with nothing running it applies the next time the thread starts, and mid-conversation it applies from the next turn, never disturbing a turn already in flight.

Reasoning effort comes from the same catalog: the levels on offer are the ones the model lists, so they change from model to model. OpenCode calls them variants, and an OpenCode model without variants shows no effort control. On OpenCode a new level applies from the next turn.

The / menu shows the full available list. Scroll or use the arrow keys, or type a name to filter it. For Codex it starts with /goal, /review, /compact and /init, which Deska runs for Codex, followed by its skills, invoked with $name. Codex’s other CLI commands, such as /model, are not listed; use Deska’s model and permission controls, or open Codex in a terminal for its CLI menu. Slash commands.

Claude Code, Codex and Cursor offer a fast mode on some models: the same model answers sooner, and your plan runs out faster. In Deska it is off unless you turn it on for a task. Open the task’s Settings menu, the three dots next to the model in the composer, and pick On or Off under Fast mode. On the phone it is Fast mode in the task’s three dots menu. The change applies from the next turn, and a new task starts with it off.

While it is on, the composer’s menu reads Fast with a filled bolt. Deska turns fast mode off explicitly, so turning it on in the agent’s own terminal (/fast, or service_tier in Codex’s config.toml) does not carry into Deska’s tasks. The menu shows the section only for models that have a fast mode.

If a task’s provider session was stopped, send a new message to resume its saved conversation. This also works from your phone with an updated host. A task being deleted, or whose isolated worktree is being removed or is no longer available, cannot resume; start a new task in that case.

An agent CLI left running holds real resources: a process, sometimes a local server and a port. A session with no active turn and no pending approval or question for thirty minutes has its provider process stopped. Nothing about the conversation is lost. The session keeps its identity, and your next message transparently restarts the provider from the resume cursor and carries on where it left off. The only thing you notice is that the first message after a long pause takes a moment longer to start.

When a session cannot start or dies, Deska names the cause rather than showing a raw stack: the CLI could not be launched, you need to sign in to that provider, the installed CLI is too old, the provider answered unexpectedly, the process is gone, or it stopped responding. Failures with no recognisable cause show their message unchanged instead of being labelled with a cause nobody established. Troubleshooting covers what to do about each one.

Select Install in Settings → Agents to use the installer for your operating system. On Windows, Deska runs the PowerShell installer; macOS and Linux use Bash. If an older Deska version sends curl -fsSL to PowerShell and reports an Invoke-WebRequest parameter error, update Deska or run irm https://antigravity.google/cli/install.ps1 | iex in PowerShell. See Google’s Antigravity installation guide.

Install Google’s agy CLI, then run agy in a terminal to sign in. Deska notices the sign-in on its own, with no refresh or restart. A Deska Cloud box comes with it installed, and there Sign in runs that first launch on the box for you: sign in with Google on the page that opens, then copy the code the page shows and paste it in Deska. A second Antigravity account on the box signs in the same way. Deska supports version 1.2.12 or newer. Choose Antigravity in the task composer, Panel Library or Settings → Dex. Models come from your account through agy models; update the CLI with agy update.

Open your Antigravity agent in Settings → Agents and select Discover models to retry loading the list, or Rediscover to refresh it. The task picker includes all models the account offers. By default new sessions use the latest stable Gemini Flash your account lists; Default model sets another initial choice. Neither limits the list to one model.

Tasks stream messages and tool activity, show permission requests on your desktop or phone, and resume the same conversation after stopping. Stop interrupts the CLI process; the next message resumes the recorded conversation. Model and plan changes apply when the session next starts.

Deska installs its own hook and MCP entries in Antigravity’s global configuration, preserving your other entries. Session credentials stay in the running process. Outside a Deska task, its permission hook defers to Antigravity’s own policy. In Dex, Antigravity can use only Deska’s tools.

Antigravity takes text and images. Mid-turn steering and conversation rewind are unavailable, and on macOS and Linux so are interactive question cards. In plan mode it reads but writes and runs nothing, and its plan arrives in its reply. A model’s name already says its effort (-low, -medium, -high), so pick the model rather than an effort. To change the computer’s own Antigravity to another Google account, type /logout in the agy terminal that Change account opens, then sign in again. For a second account, add another Antigravity setup in Settings → Agents and choose Connect account on its card: on macOS and Linux it signs in under its own home folder, and its Sign out in Settings signs out only that account. On Windows, a separate account runs Google’s Antigravity ACP runtime with no terminal: sign it in with Sign in with Google inside Deska, and expect each of its sessions to take tens of seconds to start (see Separate accounts). Sign the computer’s own Antigravity out with /logout inside the native agy terminal.

Cursor runs as its own agent server (cursor-agent acp), which Deska starts once per task and keeps open. Sign in once with cursor-agent login; the login lives in your keychain, so Settings reads its state from the CLI itself. On a Deska Cloud box, Sign in opens Cursor’s page on your phone or desktop with no code to type; finish there and the screen updates on its own. A separate Cursor account keeps its login in a file inside its own folder instead, and its model choice stays in that account rather than becoming the CLI’s default for your own sign-in.

• Runtime modes: Cursor never asks before an ordinary edit inside the workspace, so Approval required runs it in its read-only Ask mode instead and every command, delete, MCP call and web request comes to you as a card. Auto-accept edits lets reads through and still asks for commands, deletes, the network and any write that reaches outside the workspace or touches a protected path. Auto has no reviewer on Cursor and behaves as auto-accept edits. Full access answers everything for you.
• Accept for this session is remembered by Deska, not by Cursor: the CLI’s own “allow always” would write a permanent entry into its global allowlist, so Deska never chooses it.
• Model choice is shared with the Cursor CLI itself: picking a model for a thread also becomes the CLI’s default model on that computer while the thread runs, because that is how Cursor stores it. Deska puts the previous default back when the thread stops. A model your Cursor plan does not include fails the turn with Cursor’s own upgrade message; switch the thread back to Auto.
• Questions and plans arrive the way Cursor sends them: a question card per prompt, with several choices at once where it allows, and a plan turn ends in a Proposed plan card.
• Models come from Cursor’s catalog, and the effort, context window, fast mode and thinking knobs a model offers switch on the live session. A slug Cursor does not know leaves the task on its default model with a note, never a dead task.
• Stop cancels the running turn; a follow-up sent while it works folds into the same turn. Sign-out, quota and connection problems that Cursor reports as text are shown as the task’s failure cause rather than as an answer.

Claude Code, Codex, Cursor and Antigravity subscriptions come with limits that refill on a clock: a five hour session and a weekly cap for Claude (plus a separate weekly cap for some models), a weekly or five hour window for Codex depending on the plan, a monthly allowance for Cursor (shown in dollars, with any on-demand spend this cycle), and a weekly cap per model group for Antigravity (Gemini models share one, Claude and GPT models another). A small gauge hangs under the Ask Dex capsule with what is left of each agent signed in on this computer. Each agent shows its own window that runs out first and names it beside the number, so Claude Code can read Week while Codex reads Session. Press it for the detail: every window, when it refills, and a mark on each bar showing where an even pace would leave you by now.

• Every account counts. Each agent is read from its own sign in, and a provider instance with its own configuration folder (a separate work Claude, for example, or an Antigravity instance with its own account) gets its own gauge under its own name. The detail names the account under each agent’s name, blurred until you click it, so you can check which login each number belongs to.
• Live while agents work. Claude Code and Codex report their limits on every turn, so a running task moves the gauge immediately. Otherwise Deska checks every few minutes while its window is in front, and again when you open the detail.
• Runs out before the reset? When your pace so far would empty a window clearly before it refills, the detail says when, in amber.
• States say what to do. An expired sign in reads The sign-in expired, so usage cannot be read. under the account it names, and offers Sign in again, the same as Settings, an agent signed in with an API key is billed per token and has no limit to show, a plan without included usage says so, and a failed check keeps the last answer for a while with its age.
• Dex reads it too. Ask Dex how much is left, or give it several tasks and say to hand them to the accounts with the most left: it ranks your accounts by the window that runs out first, puts one task on each from the top, and tells you which account took which task. Two instances that share one sign in share one allowance, so Dex counts them once. It warns you before starting a task on an account that is nearly out, and it never moves a task to another agent unless you ask.

The gauge describes the computer you are on. When you open another computer’s desk it steps aside, since that machine’s agents have their own accounts. OpenCode bills through the provider keys it holds, so it has no gauge. The Antigravity gauge is available on macOS; on Windows and Linux its sign in is kept where Deska cannot read it yet.

On your phone and on app.deska.dev, the same numbers are under Usage left in three places: in Settings, right under your name, as one row that says how many accounts you have and which one has the least left, and opens the list for every computer you own (a plan signed in on two computers shows once; pull down to check again); at the end of a computer’s page, for that computer; and behind a task’s own limit warning (“The provider rate limit is nearly reached”), which opens the account that task runs on. An account’s row opens every window of that plan and when each one refills. The phone reads them from your computer while it is connected.