Skip to content

Getting started

Connect via MCP

Connect Dexto to Claude, ChatGPT / Codex, Cursor, OpenClaw, or Hermes with one secure remote MCP endpoint.

Copy the Dexto connector URL

Paste this URL into your client in the next step.

https://app.dexto.ai/mcp

Connect, sign in and start

Connect, sign in, then enable Dexto from Search and tools.

Claude MCP docs

Use server name dexto, URL https://app.dexto.ai/mcp, transport Streamable HTTP, and OAuth. No Dexto CLI install or API key is needed for this path.

Terminal window
claude mcp add --transport http dexto https://app.dexto.ai/mcp

Open Claude Code, run /mcp, select dexto, and choose Authenticate. Finish sign-in and consent in the browser, then return to Claude Code. See Claude Code MCP setup.

Terminal window
codex mcp add dexto --url https://app.dexto.ai/mcp

Finish the browser OAuth flow if prompted. If adding the server did not start sign-in, run codex mcp login dexto. After authorization, start a new Codex session to load its tools. See Codex MCP setup.

When you import Codex chats into Dexto (dexto import), each answer keeps the model that wrote it. The chat continues on the model of its last answer. Run dexto connect codex to continue on your ChatGPT plan; see Continue imported chats on their model.

Merge this entry into .cursor/mcp.json (project) or ~/.cursor/mcp.json (all projects):

{
"mcpServers": {
"dexto": { "url": "https://app.dexto.ai/mcp" }
}
}

In Cursor’s MCP settings, enable dexto, choose Connect or Needs Login, and finish OAuth in the browser. See Cursor MCP setup.

Add a remote Streamable HTTP server named dexto with the URL above. Enable OAuth and let the client discover the authorization server from the resource metadata. Sign in to Dexto, choose your organization, and approve the requested access in the browser. Do not paste tokens into the configuration. After sign-in, load tools/list and ask for a read-only list of your chats. An empty list is a successful result; starting a chat is not required.

The permissions depend on the client and the tools requested. The authoritative list is https://app.dexto.ai/.well-known/oauth-protected-resource/mcp → scopes_supported; the tool catalog lists each tool’s scopes. For example, listing chats needs sessions:read; starting one needs sessions:write. Review the consent screen before approving. billing:write and gpu:write require explicit requests. See Building a client for discovery and the metered-compute exceptions.

After OAuth sign-in, Dexto introduces itself to your MCP client as four connected layers:

LayerWhat it gives you
ConnectConnections bring services such as GitHub and reusable account context into Dexto
WorkCapabilities perform direct actions; Agents and AutoBots take on delegated work
ReuseSkills preserve useful procedures; Apps provide focused interactive experiences
AutomateAutomations run recurring work autonomously

For an unfamiliar task, ask your client to search Dexto first. Dexto returns a small ranked set of routes that are available to your account, why each route matched, whether setup is needed, and the next product action. Where a Dexto tool acts on a route, the route names that tool and the arguments to fill in. It does not paste the full catalog or tool schemas into the conversation.

Try prompts such as:

  • “Search Dexto for the best way to connect my GitHub work.”
  • “Find a reusable release or pull-request review playbook.”
  • “Find an Agent or AutoBot that can own a competitor research brief.”
  • “Find or create a weekly project status automation.”
  • “Open Blender on a GUI computer and show me the default scene.”

Search results can include Dexto operations and App actions, Capabilities, Skills, Agents, AutoBots, Apps, Connections, Automations, Services, and Marketplace resources. Search only names what your connection’s permissions reach. A result is a route, not a grant: Dexto checks current access, billing, and availability again when the client takes the next action.

Dexto search deliberately returns a small page. The server enforces the result limit, bounds every display field and the complete serialized response, and supplies a cursor when more matches exist. The client can move wider through outcome-family facets and the cursor, or move deeper by inspecting one promising route for its current affordances and a few related alternatives. Setup requirements are resolved before the client takes the owning product action.

A client can narrow a search to source types such as operation, app_action, skill or connection; the search tool lists every type. Stable outcomes such as connect, work, reuse, delegate, automate, and experience help the client understand how a result can be used. Exact inputs become strict only when the client makes the call.

Each Dexto tool’s listing names its level in _meta (dexto/level): read, tidy, work, act, approve or money. Dexto can’t ask you anything over an MCP connection, so your client asks for it:

  • act: other changes in your Dexto. Your client should ask you before it calls the tool.
  • approve: publishing, deploying, installing, or messaging and answering for you. money: spending. The call must also carry confirm: true, which your client sends only after you agreed to that exact call. Without it, Dexto refuses the call and nothing runs.

Where a tool’s actions differ, each action has its own level (dexto/action_levels), and dexto_apps_action takes the level of the App action it runs.

When Dexto refuses a call, the error’s data says why: its kind (such as forbidden, needs_confirmation or not_found), and the missing scope or the call’s level where they apply.

Some tool families are available only with the corresponding OAuth scope or platform policy. For example, managed GPU tools appear only when that capability is available to the connected organization. The server rechecks authorization when a tool is called; a tool listing is not a permanent grant.

dexto_computer_* refers to bounded shell and file operations in the connected workspace. Managed GUI computers are a separate visual service exposed through the normal capability tools. Search for GUI computers, then describe or call dexto.gui.gui_computer or dexto.gui.gui_computer_control. They are available to ordinary organizations when the hosted GUI provider and an owned Desktop context are available; they are not sandbox or GPU operations.

A client such as the Dexto CLI builds its commands from the server at runtime instead of a fixed list. These are what it reads, and they are the public contract of the Dexto MCP.

  • Endpoint. https://app.dexto.ai/mcp, JSON-RPC over HTTP POST with a bearer token.
  • Sign-in. /.well-known/oauth-protected-resource/mcp names the authorization server, whose /.well-known/oauth-authorization-server metadata gives its endpoints. Clients are public: they register themselves, use PKCE (S256), and can sign in without a browser on the same machine with the device grant.
  • Scopes to ask for. The resource metadata’s scopes_supported is what a client asks for to use the workspace. Its dexto_app_scopes maps each app or service, then each tool or App action, to the scopes it takes, so a client that signed in for less can ask for one it can’t see yet. Where a tool has conditional scopes, this list contains the scopes for all of those calls; use its dexto/conditional_scopes metadata to select the scopes for the intended call. Operations that can spend are left out of both, and billing:write and gpu:write are granted only when a client names them. Two exceptions remain: computers:write (starts a chat’s computer as metered compute) and capabilities:call (runs available capabilities, which can be paid) are still in scopes_supported, and a sign-in that follows the MCP challenge asks for them.
  • Tools. tools/list lists the tools the connection’s scopes reach. Each tool’s _meta has:
    • dexto/app and dexto/app_kind (app or service): the app that provides it, so a client can group tools by app.
    • dexto/level: read, tidy, work, act, approve or money, as in Asking you first.
    • dexto/action_levels, where a tool’s action input picks what it does: each action’s own level, which replaces the tool’s for that call.
    • dexto/conditional_scopes, when present: scope and when pairs for calls that need additional access. Other calls to that tool can be available without those scopes.
  • App actions. dexto_apps_list lists the installed Apps and their actions, dexto_app_get describes one App’s actions, and dexto_apps_action runs one.
  • Refusals. A refused call’s error data has its kind, and the missing scope or the call’s level where they apply, so a client can sign in for the scope or ask the person and retry with confirm: true.

The catalog lists every tool and App action with its level and scopes.

Dexto adds tools, App actions, levels and _meta keys as it grows; a client ignores what it does not know and treats an unknown level as act. A tool’s name, its _meta keys and the meaning of each level do not change once published; a tool that goes away is first marked deprecated in its description.