Grok offers custom MCP connectors for external services. You can use that connection route to request saved 1PC product context, then make a scoped product decision from the current state. Start by verifying authentication and a real context read; a connector entry alone does not prove the complete workflow works.

This guide covers Grok's web connector and a separate developer route through the xAI Responses API. It follows official documentation checked on October 4, 2026. It provides a setup and verification procedure; a live Grok-to-1PC OAuth session has not been verified here.

Choose your Grok connection route

RouteUse it whenAuthentication to check
Grok web custom connectorYou want product work inside a Grok conversation.The connector's sign-in flow must complete against 1PC.
xAI Responses API remote MCPYou are building your own assistant or testing an integration in code.An xAI API key and a separate 1PC bearer credential.

You need a 1PC User and access to the intended Product. Every User has the available skills; private MCP usage consumes prepaid Wallet credit. Grok access and API billing remain with your provider. See the MCP overview.

Add the Grok web connector

According to Grok's connector documentation, open Grok connectors, choose New Connector, then Custom. Enter the public server URL:

https://use1pc.com/mcp

Complete the authentication offered by the connector. For a Grok Business or Enterprise organization, an administrator must provision the connector first; see Grok connector management. The hosted 1PC endpoint is already public, so this setup does not need a local server or tunnel.

1PC supports OAuth discovery, dynamic client registration and S256 PKCE. It does not advertise Client ID Metadata Documents (CIMD). Grok's overview does not specify every registration detail, so verify that the sign-in and consent actually finish. New OAuth connections grant full User access, including owner decisions; a narrower scope request still shows full account consent. Review the 1PC authentication contract if registration or consent fails.

A personal token is an alternative only where the client supports a bearer header. The web instructions here do not assume a token field exists in Grok's connector dialog. Never paste a token into a conversation to resolve authentication.

Enter through Product Owner

Connecting the MCP server exposes tools. Set Product Owner entry explicitly in your first request and repeat it in a fresh conversation. This loads changing requirements from 1PC rather than treating a copied checklist as the workflow authority.

Use my 1PC connector. Before this workflow, call
get_skill_instructions with skill_id "product-owner", phase "entry".
Read workspace context, paginate accessible products and the skill catalog,
and resolve Follow-up Board before any product operation. Keep its
product_id explicit. Read current owner context, relevant saved files,
decisions and progress with revisions.

Explain the saved state and relevant missing evidence. Follow applicable checks. Do not create, save or change anything
yet. Ask me to choose the product if the name is ambiguous.

Follow-up Board is fictional: a SaaS helping freelance designers track unanswered proposals. Replace the name with your product. Inspect the actual tool activity for the context reads; a fluent summary based only on your prompt has not loaded the saved product.

For execution, Product Owner selects an available skill from catalog metadata and loads get_skill_instructions with its skill_id and phase work, then the relevant product context. Use the returned execution Markdown alongside the separate requirements. Receiving that guidance does not install a native Grok skill. Published private skills are available only to the caller with the required plan; the custom product skill guide explains authoring.

Review a launch claim before drafting content

A useful first job is checking the gap between an accepted feature decision and what you can truthfully say publicly. Suppose Follow-up Board has a planned reminder feature. Its saved customer context may explain the problem, while the release status determines which claims a landing page can make.

Using the saved state you just read, review my planned launch message:
"Never lose another proposal. Follow-up Board automatically sends every
client a reminder."

Separate claims supported by saved product behavior from planned behavior
and unverified outcomes. Identify the sources and evidence gaps. Suggest
a revised message and one useful next task. Keep these as proposals in
the conversation; do not publish, contact customers or save yet.

The original message makes several assumptions: an absolute outcome, automatic sending and universal coverage. The review should check those claims individually. It must not infer a released capability from a roadmap entry or invent customer results. If the accepted product actually helps a designer decide whom to follow up with, the draft should explain that supported behavior.

Once the message is grounded, the shared feature launch marketing plan connects it to a landing page, social content, SEO and a prospect experiment. Related work is a suggestion to assess within your scope. It does not authorize every asset or its publication.

Developer alternative: xAI API with remote MCP

The xAI remote MCP reference documents Streamable HTTP connections and custom headers in the Responses API. This developer example restricts exposed tools to reads and guidance. The xAI key authenticates the model request; the 1PC token authenticates requests to your workspace.

Create a personal token under MCP connections in 1PC. Supply XAI_API_KEY, ONEPC_MCP_TOKEN and XAI_MODEL through your environment or secret manager. Choose an available model supporting remote MCP from the xAI model documentation. Personal 1PC tokens grant read/write, expire after 90 days and can be revoked; the tool filter below limits this request, not the token itself.

Save this as a local Python script and run it with Python 3. It uses the standard library and contains no credential values:

import json
import os
import urllib.request

entry = """Use onepc. First call get_skill_instructions with skill_id
product-owner and phase entry. Read workspace context; paginate products
and skills. Explain accessible products and ask me to select one before
product-specific work. Follow applicable checks. Do not create or save."""

payload = {
    "model": os.environ["XAI_MODEL"],
    "input": [{"role": "user", "content": entry}],
    "tools": [{
        "type": "mcp",
        "server_label": "onepc",
        "server_url": "https://use1pc.com/mcp",
        "headers": {
            "Authorization": "Bearer " + os.environ["ONEPC_MCP_TOKEN"]
        },
        "allowed_tools": [
            "get_workspace_context", "list_product_skills", "list_products",
            "get_skill_instructions",
            "get_product", "get_product_context", "list_product_files",
            "read_product_files", "search_product_files",
            "get_task_context", "list_tasks"
        ]
    }]
}

request = urllib.request.Request(
    "https://api.x.ai/v1/responses",
    data=json.dumps(payload).encode("utf-8"),
    headers={
        "Content-Type": "application/json",
        "Authorization": "Bearer " + os.environ["XAI_API_KEY"]
    },
    method="POST"
)
with urllib.request.urlopen(request, timeout=120) as response:
    result = json.load(response)
for item in result.get("output", []):
    if item.get("type") == "message":
        for part in item.get("content", []):
            if part.get("type") == "output_text":
                print(part["text"])

Run this as a read check, then inspect tool-call records in your integration and follow up with the selected product. The request has no write tools. xAI currently does not support the Responses API require_approval parameter; a writing application must enforce its own approval and scope before exposing write tools. Do not rely on a prompt alone as the application's write boundary.

Save an approved result and resume

For a requested saved review or domain output, approve the exact result and destination before writing. In Grok web, the connection acts with your User permissions. In an API integration, implement the approval boundary before enabling the necessary write tools. Choose the explicit scope, department, document role and stable key, then prepare and self-review the update:

Save only the revised message and review we approved for the selected
product. Load the applicable work and save requirements. Identify the
authorized scope, department, reference role and stable key. Read its latest revision. Preserve valid existing
information, save the authorized update, verify the receipt and read the
file back. Report its actual path and revision. Keep other suggested work
proposed; do not publish or mark a feature released.

Prepare and self-review each scoped update, commit with the exact revision and current Task claim where required, then read back the receipt. A conflict requires fresh state and recovery guidance. If the response is uncertain, read the destination before retrying.

Open a fresh Grok conversation, enter Product Owner again and give it the actual saved path. Ask it to read that file, explain what was accepted and distinguish what remains proposed. Verify the content against the earlier read-back. The cross-tool continuity guide explains what persists: saved knowledge, decisions and progress. Unsaved chat details and unrelated host actions do not become product records.

Check the failing layer

  • No connector option: check the current Grok UI and, for an organization, administrator provisioning.
  • Sign-in fails: check callback registration, PKCE and the MCP resource against 1PC's authentication reference. A model API key cannot authenticate your 1PC account.
  • Tools available, no state read: request Product Owner entry and inspect the actual calls.
  • Read succeeds, save fails: check OAuth write scope, the tool allowlist and the selected workflow's plan requirements.
  • A skill is unavailable: inspect its current catalog availability. Connection success does not grant paid guidance.

After the read/save/new-session check, test revocation. Remove the OAuth authorization or revoke the personal token in 1PC, then verify a fresh authenticated read fails with that credential. For OAuth, also test refresh and denied consent before relying on a long-running connection. Use the MCP reference for exact tool and recovery rules.

Check your 1PC authentication setup.

Use the MCP reference to verify credentials, scopes and a real product-state read before enabling saves.

Open the authentication reference ↗