App integrations

Connectors supports two app-integration modes: indexed connectors (sync app data into searchable knowledge) and live app actions (execute actions through a brokered path).

Indexed connectors

Indexed connectors sync app data into Sketch’s searchable knowledge layer. Once synced, agents use the public MCP tools: sketch_search, sketch_search_entities, sketch_get_entity_context, and sketch_get_file_content.

Sketch registers these 11 connector types:

Google Drive
Google Calendar
Gmail
Outlook
Microsoft Teams
ClickUp
Notion
Linear
Fireflies
Otter
Zoho CRM

To connect one:

Open Connections, or Files → Connectors.
Choose the app.
Complete OAuth, or enter the required API key.
Choose scope when the connector requires it.
Let the sync complete.
Query the data with the MCP search tools.

Every synced connector is indexed and searchable through sketch_search. But the public source filter only recognizes a subset of values. For a connector without a dedicated source value, search it with query text and narrow by kind (meeting, doc, task, message) instead.

Connector	Indexed & searchable	Public `source` filter
Google Drive	Yes	`google_drive`
ClickUp	Yes	`clickup`
Linear	Yes	`linear`
Notion	Yes	`notion`
Fireflies	Yes	`fireflies`
Google Calendar	Yes	— narrow by `query` / `kind`
Gmail	Yes	— narrow by `query` / `kind`
Outlook	Yes	— narrow by `query` / `kind`
Microsoft Teams	Yes	— narrow by `query` / `kind`
Otter	Yes	— narrow by `query` / `kind`
Zoho CRM	Yes	— narrow by `query` / `kind`

Two source values are not connectors: conversation (Sketch chat history) and local (local workspace files). The full filter enums live in the sketch_search reference.

Live app actions

Live app actions are handled through a Canvas integration provider and a brokered CLI path in the Sketch agent runtime. The agent calls the CLI as $CANVAS_CLI <subcommand> --output json.

The action path

An action is never a blind single call. The agent discovers the app, finds the right component, reads its input schema, resolves any dynamic options, and only then executes:

search app -> confirm connected -> find component -> fetch schema -> resolve remote options (if needed) -> execute

CLI subcommands

Discovery:

search-apps — find apps and their connected-account status (isConnected).
get-components — list an app’s components (actions and triggers).
search-components — search components across or within an app.
get-component-definition — read a component’s input schema before executing.

Execution:

direct-execute-action — run an app action, passing the fields from the component schema.
fetch-remote-options — resolve dynamic option values (for example, turn a channel name into a channel ID) when the schema needs an ID you don’t already have.

Web:

direct-execute-web-search — run a web search.
direct-execute-web-scrape — scrape a page.

Example: post to Slack

1. search-apps --queries "slack"          # is Slack connected for this user?
2. search-components --app slack "send message"
3. get-component-definition <componentKey> # what inputs does it need?
4. fetch-remote-options ...                # resolve the channel name -> channel ID
5. direct-execute-action <componentKey> ...# send the message

The same discovery-first path applies to Linear (create/update issues), ClickUp (create tasks), and every other connected app: always resolve the component schema and any option IDs before you execute.

Credentials never reach the agent. Sketch creates a per-run local broker, gives the agent a harmless launcher path through CANVAS_CLI, and keeps credential environment variables inside the trusted server process. The backend resolves the connected account from the caller’s identity; if an app isn’t connected, the call returns a not-connected result rather than exposing secrets.

If the agent tries to use an app account that is missing, Sketch can collect connection-card data from tool progress and show a connection prompt in supported surfaces.