Connect your agent to the GTM team.

Cursor — Native MCP support + one-click install deeplink. 60-second setup via Settings → MCP, ~/.cursor/mcp.json, or the cursor:// install button. · MCP (hosted url or stdio)

// ~/.cursor/mcp.json
{
  "mcpServers": {
    "chieflab": {
      "url": "https://api.chieflab.io/api/mcp",
      "headers": {
        "Authorization": "Bearer clp_dev_..."
      }
    }
  }
}

// Restart Cursor. In any chat after building something:
//   "launch this"  /  "get users"  /  "market this"  /  "announce this"  /  "post this"
// Cursor's agent picks chiefmo_launch_product automatically, gathers
// repo context (commits, files, routes, README), and returns a launch pack.

Full Cursor install guide →

Claude Desktop — Native MCP support. Add to claude_desktop_config.json, restart, done. · MCP (hosted url or stdio)

// macOS:    ~/Library/Application Support/Claude/claude_desktop_config.json
// Windows:  %APPDATA%\Claude\claude_desktop_config.json
{
  "mcpServers": {
    "chieflab": {
      "url": "https://api.chieflab.io/api/mcp",
      "headers": {
        "Authorization": "Bearer clp_dev_..."
      }
    }
  }
}

// Quit Claude Desktop fully and reopen. ChiefLab tools appear in the
// input area. Ask: "Use ChiefMO to launch this product."

Full Claude Desktop install guide →

Node script / web app — Plain fetch. No MCP client required. Drop into any Node service, Next.js route, edge function. · HTTPS POST

// Node 20+ (built-in fetch)
const r = await fetch("https://api.chieflab.io/api/mcp", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.CHIEFLAB_API_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    jsonrpc: "2.0", id: 1, method: "tools/call",
    params: {
      name: "chiefmo_launch_product",
      arguments: {
        productUrl: "https://yoursite.com",
        goal: "Get our first 100 users",
        channels: ["linkedin", "x", "product_hunt", "email", "landing_hero"],
        tenantId: "acme-co"
      }
    }
  })
});
const { result } = await r.json();
const payload = JSON.parse(result.content[0].text);
// payload.launchPack.channels — per-channel drafting briefs your LLM renders
// payload.publishActions[] — approval-gated; fire executorTool after approval
// payload.reviewUrl — surface to user for approval (HMAC-signed, no login)

Python — httpx / requests. Drop into any FastAPI, Flask, LangChain, LlamaIndex, Pydantic AI agent. · HTTPS POST

import os, json, httpx

r = httpx.post(
    "https://api.chieflab.io/api/mcp",
    headers={"Authorization": f"Bearer {os.environ['CHIEFLAB_API_KEY']}"},
    json={
        "jsonrpc": "2.0", "id": 1, "method": "tools/call",
        "params": {
            "name": "chiefmo_launch_product",
            "arguments": {
                "productUrl": "https://yoursite.com",
                "goal": "Get our first 100 users",
                "channels": ["linkedin", "x", "product_hunt", "email", "landing_hero"],
                "tenantId": "acme-co"
            }
        }
    },
    timeout=60.0
)
payload = json.loads(r.json()["result"]["content"][0]["text"])
# payload["launchPack"]["channels"] — per-channel briefs your LLM renders
# payload["publishActions"] — approval-gated; fire executorTool after approval
# payload["reviewUrl"] — surface to user (HMAC-signed, no login)

Telegram bot — Inside your webhook handler, fetch the endpoint. Use chat ID as tenantId for per-user context. · HTTPS POST

// inside your Telegram bot webhook handler
import { Telegraf } from "telegraf";
const bot = new Telegraf(process.env.TELEGRAM_TOKEN);

bot.command("launch", async (ctx) => {
  // ctx.message.text comes in like "/launch https://acme.co Get our first 100 users"
  const [, productUrl, ...goalParts] = ctx.message.text.split(/s+/);
  const r = await fetch("https://api.chieflab.io/api/mcp", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.CHIEFLAB_API_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      jsonrpc: "2.0", id: 1, method: "tools/call",
      params: {
        name: "chiefmo_launch_product",
        arguments: {
          productUrl,
          goal: goalParts.join(" ") || "Get our first users",
          channels: ["linkedin", "x", "product_hunt", "email"],
          // Per-user context: each Telegram user is a tenant
          tenantId: `tg-${ctx.from.id}`
        }
      }
    })
  });
  const { result } = await r.json();
  const payload = JSON.parse(result.content[0].text);

  // Surface the reviewUrl — user clicks, approves, agent fires executors
  await ctx.reply(`Launch staged. Approve here: ${payload.reviewUrl}`);
});

Vapi / voice agents — Register ChiefLab as a function call. Vapi runtime hits the endpoint; your voice agent's LLM speaks the rendered output back. · HTTPS POST (function call)

// Vapi function definition (in your assistant config)
{
  "name": "chiefmo_launch_product",
  "description": "Plan and queue a product launch end-to-end. Use when the caller has just shipped a product and asks to launch it / get users / market it / announce it / post about it.",
  "parameters": {
    "type": "object",
    "properties": {
      "productUrl": { "type": "string" },
      "goal":       { "type": "string" },
      "tenantId":   { "type": "string", "description": "Use the caller's phone number" }
    },
    "required": ["productUrl"]
  },
  "server": {
    "url": "https://api.chieflab.io/api/mcp",
    "headers": { "Authorization": "Bearer YOUR_CHIEFLAB_KEY" },
    "method": "POST"
  }
}

// The Vapi runtime translates a function call into a JSON-RPC call to
// chieflab.io/api/mcp. The voice agent's LLM (Vapi → OpenAI/Anthropic)
// reads the launchPack briefs and speaks the rendered marketing back
// to the caller, then SMSs them the reviewUrl for approval.

LangChain / LangGraph — Wrap as a Tool. The agent's LLM gets a brief, renders the final output. · HTTPS POST

from langchain.tools import Tool
import httpx, json, os

def chiefmo_launch(query: str) -> str:
    """Plan and queue a product launch. Input format: '<productUrl> | <goal>'."""
    parts = [s.strip() for s in query.split("|", 1)]
    product_url = parts[0]
    goal = parts[1] if len(parts) > 1 else "Get our first users"
    r = httpx.post(
        "https://api.chieflab.io/api/mcp",
        headers={"Authorization": f"Bearer {os.environ['CHIEFLAB_API_KEY']}"},
        json={
            "jsonrpc": "2.0", "id": 1, "method": "tools/call",
            "params": {
                "name": "chiefmo_launch_product",
                "arguments": {
                    "productUrl": product_url,
                    "goal": goal,
                    "channels": ["linkedin", "x", "product_hunt", "email", "landing_hero"]
                }
            }
        }
    )
    payload = json.loads(r.json()["result"]["content"][0]["text"])
    channels = payload["launchPack"]["channels"]
    briefs = "\n\n---\n\n".join(channels[k]["body"] for k in channels)
    return f"REVIEW URL: {payload['reviewUrl']}\n\n{briefs}"

chiefmo_tool = Tool(
    name="chiefmo_launch_product",
    description="Plan and queue a product launch end-to-end. Use after the user ships something and says 'launch this' / 'get users' / 'market this' / 'announce this' / 'post this'. Returns per-channel briefs + signed reviewUrl.",
    func=chiefmo_launch
)
# Add chiefmo_tool to any LangChain / LangGraph agent. The agent's LLM
# renders each brief into final copy — no extra ChiefLab server-side LLM cost.

Custom agent / SDK — OpenClaw, Hermes, Manus, Devin, Replit Agent, your own SDK — anything with HTTPS works. · HTTPS POST

Same shape as the others — POST JSON-RPC with a Bearer token. See the Node example as a starting point.