Apps and MCP Tools

Use this guide to understand the platform's app suites, MCP (Model Context Protocol) integration, and how to connect AI tools to your handle.

All browser-first operator surfaces now run on https://app.10x.in. Use /apps/ as the current catalog/front door for product workflows, /creator/* for creator workflows, and /smartwork/launch/{projectId} when a Smartwork project is opened from the first-party launcher. Handle hosts and mapped custom domains remain public-only surfaces, so they do not redirect /admin, /app, /apps, /creator, /purchases, or /smartwork into the control plane.

When to use

• You want to manage campaigns, deployments, or analytics from an app interface.
• You want to connect an AI assistant or LLM to your handle via MCP.
• You need to register custom function bindings for tool-based integrations.

For a single end-to-end runbook across schema setup, analytics checks, and function-binding data delivery, use Platform-Wide Feature Exploration Lab.

If you need the operator-facing guide for reviewing the hosted connector surface, use MCP Builder and Hosted Tools.

Browser app surfaces

The platform exposes two browser app collections on the unified app.10x.in host: creator workflows under /creator/* and the /apps/ catalog for product and operations workflows.

Creator workflows

These routes are direct browser entry points under https://app.10x.in/creator/*.

Access: JWT authentication required (CREATOR role or above).

Apps catalog and product workflows

The canonical product entry point is https://app.10x.in/apps/. Each module opens from the browse catalog at /apps/browse/{appId}/playground; older shortcut paths such as /apps/attribution are preserved only as compatibility redirects inside the SPA.

Smartwork browser runtime

Smartwork is part of the same unified browser host, but it is launched separately from the /apps/ catalog.

MCP integration

The platform exposes a Model Context Protocol (MCP) server that allows AI assistants and LLMs to interact with one handle programmatically.

What is MCP?

MCP is a protocol that lets AI tools (like Claude, ChatGPT, or custom agents) call structured functions on your behalf. Instead of navigating the UI or writing API calls, you describe what you want in natural language and the AI uses MCP tools to execute it.

Available MCP tools

The hosted MCP surface can expose three capability shapes for a handle:

• tools for actions and structured reads
• read-only tenx://... resources
• reusable prompts for onboarding, debugging, and guided workflows

The table below focuses on tool families. For the operator-facing composition view of tools, resources, and prompts together, use MCP Builder and Hosted Tools.

Connecting an AI assistant

1. Create one connector per handle.
2. Point the connector to https://{handle}.mcp.10x.in/mcp or https://ai.10x.in/mcp/{handle}/mcp.
3. Complete the OAuth redirect and approve the scopes the connector needs.
4. Let the shared bootstrap workflow recover auth, validate scopes, and resume the requested handle workflow.
5. Let the hosted MCP transport use the OAuth-issued bridge credential. Do not paste raw usernames or passwords.

For detailed ChatGPT/OpenAI setup (auth handshake, scopes, and verification), follow ChatGPT MCP Setup.

MCP Builder and hosted composition

The operator-facing browser path for hosted MCP now lives under https://app.10x.in:

1. Open the handle in the control plane.
2. Navigate to Integrations -> MCP & Tools.
3. Review the connector endpoint, then use MCP Builder to inspect visible tools, resources, and prompts.

MCP Builder is the review and composition surface for the hosted connector. It lets you:

• inspect preview counts for visible tools, resources, and prompts
• enable or disable capability packs
• control which authenticated function bindings are exposed as MCP tools
• manage custom read-only resources and reusable prompts

Use MCP Builder and Hosted Tools for the full browser workflow and verification checklist.

MCP hosting

The MCP server can be accessed in multiple ways:

Sessions are managed via Redis with a configurable TTL (default 30 minutes). Each session is scoped to a handle and authenticated with the OAuth-issued bridge bearer for that connector.

Why MCP stays on platform domains

Platform MCP hosting currently depends on:

• platform-managed wildcard DNS and certificates for per-handle MCP subdomains
• environment-owned OAuth discovery metadata and protected-resource metadata
• environment-owned host parsing for handle resolution and session routing

Supporting MCP on customer-managed custom domains would require additional wildcard delegation, certificate lifecycle management, and OAuth metadata hosting for every customer domain. That is not supported today.

WebMCP browser tools

The platform also provides 6 built-in browser tools that work in the page context:

Function bindings

Function bindings let you register custom tool definitions that are exposed through the MCP server and public API.

Architecture summary:

• A binding is a handle-scoped registry entry, not uploaded custom code.
• Public browser/WebMCP clients can discover only ACTIVE template-backed bindings and invoke them through the public /_fn/* compatibility path.
• Authenticated MCP clients can discover a broader set of ACTIVE bindings and invoke either template-backed or skill-backed targets through the PAT-protected MCP binding surfaces.

For the deeper platform design, see Function Bindings MCP Architecture.

Creating a function binding

POST /v2/handles/{handle}/function-bindings

{
  "bindingKey": "product_lookup",
  "status": "ACTIVE",
  "target": {
    "type": "template",
    "templateKey": "proxy_request"
  },
  "exposure": {
    "publicWeb": true,
    "authenticatedMcp": true
  },
  "execution": {
    "mode": "sync"
  },
  "tool": {
    "name": "product_lookup",
    "description": "Look up product details by SKU"
  },
  "inputSchema": {
    "type": "object",
    "properties": {
      "sku": { "type": "string" }
    },
    "required": ["sku"]
  },
  "config": {
    "endpointUrl": "https://catalog.example.com/products"
  }
}

Requirements:

• PRO plan or above (growth_tools feature gate).
• Binding key must match ^[a-z0-9][a-z0-9_-]{1,63}$.
• Template targets can use proxy_request, webhook_forward, form_submit, or signed_redirect.
• Public Web exposure is limited to template-backed bindings in v1.
• Skill-backed bindings are allowed for authenticated MCP when the referenced skill has been published.

Listing function bindings

GET /v2/handles/{handle}/function-bindings

Returns the full registry for the handle, including disabled bindings and bindings that are only exposed to authenticated MCP.

Discovering public bindings

GET /v2/public/handles/{handle}/function-bindings

Returns only ACTIVE template-backed bindings with exposure.publicWeb=true. Browser/WebMCP clients use this endpoint for safe public discovery.

Discovering authenticated MCP bindings

GET /v2/public/handles/{handle}/function-bindings/mcp

Requires a PAT with mcp.connect plus per-binding or per-skill invoke authorization. This surface can include both template-backed and skill-backed bindings.

Invoking a binding at the edge

GET|POST /_edge/fn/{handle}/{bindingKey}

Use this path to invoke a public template-backed binding after creation/discovery.

Invoking an authenticated MCP binding

POST /v2/public/handles/{handle}/function-bindings/{bindingKey}/invoke

Requires a PAT with mcp.connect plus binding.invoke:{bindingKey} for template targets, or the underlying skill.invoke:{skillKey} permission for skill-backed targets. Responses use a normalized envelope:

• Sync: { "mode": "sync", "ok": true, "output": ..., "meta": ... }
• Async: { "mode": "async", "ok": true, "invocationId": "...", "status": "QUEUED", "meta": ... }

UI path

1. Open https://app.10x.in.
2. Navigate to your handle settings.
3. Open the Integrations tab.
4. Open MCP & Tools to view the hosted connector endpoint and the MCP Builder composition surface.
5. Configure function bindings or review authenticated binding exposure from the same Integrations area.
6. Use /apps/ from the main navigation to browse product workflows, or open the creator modules under /creator/*.
7. Open /smartwork/launch/{projectId} when you need the first-party Smartwork launcher for a project.

Required auth

• CREATOR-level JWT for app suite access.
• OAuth connector grant with appropriate scopes for MCP tool usage.
• pages.read/pages.write scopes for campaign-structure MCP tools.
• PRO plan required for function bindings (growth_tools gate).
• PAT is required for authenticated MCP binding discovery/invocation.

Common errors

Related:

• MCP Builder and Hosted Tools
• Platform-Wide Feature Exploration Lab
• API Tokens and Automations
• Plans, Quotas, and Feature Gates
• Chain Signals and Prefetch
• Glossary