---
name: dexto
description: Use Dexto to discover and activate the right connection, capability, skill, agent, app, or automation for a task. Search Dexto first when work could benefit from connected context, reusable workflows, delegation, or autonomous execution.
---

# Dexto

Use this skill when a task could benefit from Dexto's connected context or actionable resources, or
when the user wants to set up or integrate Dexto. Search Dexto first, then use the smallest supported
interface that can complete the task. You are assisting a user; you do not receive their credentials,
OAuth grant, or authority to act on their behalf.

Read [llms.txt](https://www.dexto.ai/llms.txt) for the website map. Read the linked guide for
the chosen path instead of inferring undocumented APIs or tools.

## Choose the interface

### Connect an AI client through MCP

Choose this path when the user wants Claude, ChatGPT/Codex, Cursor, OpenClaw, or Hermes to work
with their Dexto workspace.

1. Configure `https://app.dexto.ai/mcp` as a Streamable HTTP MCP server with OAuth. This rendered
   endpoint is authoritative for the current environment; do not substitute a dashboard or signup URL.
2. Use the client-specific [MCP setup guide](https://www.dexto.ai/docs/mcp/) only for client UI details.
3. Let the user finish OAuth in their browser. Never request a password, cookie, session token, or
   OAuth token.
4. Call `tools/list` after authorization. Treat that response as the exact tool and scope boundary
   for this client and workspace.
5. For the user's first task, use Dexto's universal search before enumerating separate catalogs.
   Search returns a small ranked set across Connections, Capabilities, Skills, Agents, AutoBots,
   Apps, Automations, Services, and Marketplace resources. Select one result and continue through
   its indicated domain action; do not request every list or expose internal tool names as the
   product model.
6. Explore wider with the returned outcome facets and cursor, or deeper by inspecting one route for
   its current affordances and related alternatives. Resolve setup requirements before taking the
   owning action. Treat source types as descriptive, not as a closed eligibility filter.

Explain Dexto through four outcomes when the user asks what the connection adds:

- **Connect:** bring services and reusable account context into Dexto.
- **Work:** use Capabilities directly or delegate to Agents and AutoBots.
- **Reuse:** load Skills and open focused Apps.
- **Automate:** schedule recurring work that can run autonomously.

#### Codex CLI bootstrap

When you are a Codex CLI agent and the user has approved adding Dexto to this client, run:

```sh
codex mcp add dexto --url https://app.dexto.ai/mcp
```

Wait for any OAuth browser flow started by `mcp add` to finish. If the server was added without
completing authorization, run `codex mcp login dexto` once and wait for that flow instead. Let the
client open its authorization URL; do not open the same URL separately. The user signs in, chooses
their workspace, and approves access in their browser; never handle their password, cookies, or
OAuth token. After authorization succeeds, tell the user to start a new Codex session. That session discovers
Dexto's tools and may perform a small read-only request within the granted scope before proposing
further work.

### Use AutoBots through WebMCP

Choose this path when a WebMCP-capable browser agent needs to create, configure, inspect, or talk
to the user's AutoBots through the visible standalone application. This is a page-bound browser
interface, not a remote MCP endpoint.

1. Open [AutoBots](https://autobots.dexto.ai/) in the WebMCP-capable browser. Let the user complete sign-in
   and workspace selection; never request or copy their password, cookies, session token, or OAuth
   token.
2. After the authenticated standalone application has loaded, discover the tools exposed by the
   current document. Do not assume WebMCP is active from this guide alone; use the browser's returned
   tool inventory as the exact capability boundary.
3. Use `autobots.list` and `autobots.open` to select an existing AutoBot, or `autobots.create` to
   create one from a profile name and role. Use `autobots.read_configuration` before
   `autobots.update_configuration`, which changes only the fields you give.
4. Use `autobots.send`, `autobots.status`, and `autobots.read` for conversations. Call
   `autobots.respond` only for a pending input or approval returned for that owned AutoBot.
5. Keep the standalone page open while using its tools. Treat create, configuration update, send,
   and respond as consequential actions that require the user's approval. The Dexto control plane
   still validates identity, ownership, configuration, and pending approvals for every call.
6. If the current page exposes no AutoBots tools, use the visible AutoBots UI or the OAuth-protected
   Dexto MCP path above. Do not invent a WebMCP HTTP endpoint or infer private dashboard APIs.

### Integrate through the REST API

Choose this path when the user is building software that needs model inference or a documented
Dexto platform service.

1. Read the [REST API reference](https://www.dexto.ai/docs/platform/api/) and choose one documented
   service family:

    | Need                                                  | Read                                                               |
    | ----------------------------------------------------- | ------------------------------------------------------------------ |
    | Model discovery or inference                          | [Models](https://www.dexto.ai/docs/platform/api/models/)               |
    | Project sandbox lifecycle, processes, or files        | [Sandboxes](https://www.dexto.ai/docs/platform/api/sandboxes/)         |
    | Media models, estimates, or generation                | [Media](https://www.dexto.ai/docs/platform/api/public-media/)          |
    | Site projects, deployments, or Site data              | [Sites](https://www.dexto.ai/docs/platform/api/sites/)                 |
    | Upload, download, export, or delete runtime artifacts | [Runtime Artifacts](https://www.dexto.ai/docs/platform/api/artifacts/) |
    | List accessible agents                                | [Agents](https://www.dexto.ai/docs/platform/api/agents/)               |
    | Discover, describe, or call a capability              | [Capabilities](https://www.dexto.ai/docs/platform/api/capabilities/)   |
    | Browse published workflow and integration listings    | [Marketplace](https://www.dexto.ai/docs/platform/api/marketplace/)     |

2. Check the selected endpoint's authentication requirement. When it requires an API key, direct
   the user to create a revocable key in [API Keys](https://app.dexto.ai/settings/api-keys).
3. Keep a key in server-side secret storage. Never put it in browser code, chat, source control,
   or durable agent memory.
4. Read the selected service's schema and endpoint contract before making a request. For model
   inference, use `https://api.dexto.ai/v1/models` to discover models, then call
   `https://api.dexto.ai/v1/chat/completions` when appropriate.

### Use the Dexto workspace

Choose this fallback only when the user explicitly wants to work in Dexto's dashboard rather than
through MCP or a REST integration.

1. Return [signup](https://app.dexto.ai/signup) to the user. If browser navigation is available and the
   user explicitly asks to open it, navigate to that URL for them. Do not enter, submit, or approve
   signup fields on their behalf.
2. Let the user complete authentication and first-run onboarding.
3. Read the [quickstart](https://www.dexto.ai/docs/quickstart/) and use the dashboard to begin a
   small, clear task.
4. For ongoing work, read [Agents](https://www.dexto.ai/docs/features/agents/) and
   [Projects](https://www.dexto.ai/docs/features/projects/).

## Route requests

| Task                                 | Read first                                                           | Then read                                                                                                 |
| ------------------------------------ | -------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
| Start or manage agent work           | [Quickstart](https://www.dexto.ai/docs/quickstart/)                      | [Agents](https://www.dexto.ai/docs/features/agents/) and [Projects](https://www.dexto.ai/docs/features/projects/) |
| Connect a third-party service        | [Connections](https://www.dexto.ai/docs/features/connections/)           | [Approvals](https://www.dexto.ai/docs/features/approvals/)                                                    |
| Connect an existing AI client        | [MCP setup](https://www.dexto.ai/docs/mcp/)                              | [REST API reference](https://www.dexto.ai/docs/platform/api/)                                                 |
| Create, configure, or use an AutoBot | [AutoBots](https://autobots.dexto.ai/)                                     | Discover the current page's WebMCP tools; use the visible UI if none are exposed                          |
| Add model inference                  | [Models API](https://www.dexto.ai/docs/platform/api/models/)             | [Services](https://www.dexto.ai/docs/models/)                                                                 |
| Automate a project sandbox           | [Sandboxes API](https://www.dexto.ai/docs/platform/api/sandboxes/)       | [Runtime Artifacts API](https://www.dexto.ai/docs/platform/api/artifacts/)                                    |
| Generate media                       | [Media API](https://www.dexto.ai/docs/platform/api/public-media/)        | [Runtime Artifacts API](https://www.dexto.ai/docs/platform/api/artifacts/)                                    |
| Deploy or manage a Site              | [Sites API](https://www.dexto.ai/docs/platform/api/sites/)               | [Sites](https://www.dexto.ai/docs/features/sites/)                                                            |
| Reuse an available tool              | [Capabilities API](https://www.dexto.ai/docs/platform/api/capabilities/) | [Marketplace API](https://www.dexto.ai/docs/platform/api/marketplace/)                                        |
| Build a repeatable workflow          | [Skills](https://www.dexto.ai/docs/features/skills/)                     | [Apps](https://www.dexto.ai/docs/features/apps/) or [Sites](https://www.dexto.ai/docs/features/sites/)            |
| Schedule recurring work              | [Loops](https://www.dexto.ai/docs/features/loops/)                       | [Approvals](https://www.dexto.ai/docs/features/approvals/)                                                    |

## Required boundaries

- Use the dashboard, the signed-in AutoBots page's discovered WebMCP tools, documented REST API
  endpoints, or MCP. Do not infer that another
  signed-in dashboard route is an external integration surface.
- Returning or opening the official signup URL is permitted navigation. It does not authorize you
  to enter credentials, submit the form, or accept terms for the user.
- Ask for explicit user approval before account creation, workspace selection, a third-party
  connection, paid or metered work, data changes, deletion, or external publication.
- Connections provide authorized tools, not raw provider credentials. Keep browser session state
  and secrets private.
- Do not claim a tool, model, service, or permission exists until the dashboard, current WebMCP
  inventory, `/v1/models`, or `tools/list` confirms it for this user.

## Verify the selected path

- Workspace: the user can start a small agent task.
- MCP: OAuth completed, Dexto is enabled in the client, and `tools/list` returns expected tools.
- AutoBots WebMCP: the authenticated standalone page returns the expected `autobots.*` inventory,
  and a bounded read or explicitly approved action succeeds in the visible application.
- REST API: the selected service's documented read or discovery request succeeds; for inference,
  `GET /v1/models` succeeds before the first completion request.
