Pause as a tool surface for every AI agent

Touch the architecture

Four live surfaces you can hit right now

The MCP server lives at mcp/ in this repo. It speaks stdio (the standard transport for local AI clients) and fronts the mocked Experience APIs under /api/mulesoft/*. The descriptor is published at /.well-known/mcp.json so any MCP-aware registry or gateway can discover the tool surface.

Install today · clone the repo

The five-minute path that works right now

1. Clone, build, smoke-test:

# 1. Clone Pause-Health.ai
git clone https://github.com/hucmaggie/pause-health.ai.git
cd pause-health.ai/mcp

# 2. Install + build
npm install
npm run build

# 3. Run a smoke test against the live mocked APIs
PAUSE_MCP_BASE_URL=https://pause-health.ai \
  node dist/server.js < <(echo '{"jsonrpc":"2.0","id":1,"method":"tools/list"}')

2. Register with Claude Desktop — add to ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "pause-health": {
      "command": "node",
      "args": ["/absolute/path/to/pause-health.ai/mcp/dist/server.js"],
      "env": {
        "PAUSE_MCP_BASE_URL": "https://pause-health.ai"
      }
    }
  }
}

Cursor uses the same shape in ~/.cursor/mcp.json. Both clients spawn node dist/server.js as a child process and talk MCP over stdio.

After Phase 1 ships · npm one-liner

The two-minute path, once @pause-health/mcp is published

Claude Desktop / Cursor — once published:

{
  "mcpServers": {
    "pause-health": {
      "command": "npx",
      "args": ["-y", "@pause-health/mcp"],
      "env": {
        "PAUSE_MCP_BASE_URL": "https://pause-health.ai"
      }
    }
  }
}

Production deployment · Agentforce

How a customer Salesforce org will consume Pause as an MCP tool source

// Salesforce Agentforce 3.0 — register the Pause MCP server with the
// Agentforce Registry (the June 2025 release introduced a native MCP
// client; the legacy "External Services connector" pattern is obsolete
// for MCP intake).
//
// 1. Setup -> Agentforce Registry -> New MCP server.
//    Paste the Streamable HTTP URL:
//      https://pause-health.ai/api/mcp
//    Salesforce calls tools/list against it and auto-populates the
//    four Pause tools.
// 2. Allowlist the tools you want. Each one is persisted to the
//    Agentforce Asset Library as a callable action; the tool's
//    description becomes the agent's reasoning instructions.
// 3. Agentforce Builder -> your agent -> Topic ->
//    This Topic's Actions -> Add from Asset Library. Validate in
//    Plan Canvas.
// 4. Tool calls flow:
//      Agentforce agent -> Agentforce Registry / Gateway ->
//      https://pause-health.ai/api/mcp ->
//      MuleSoft Experience API -> JupyterHealth / DBDP.
//
// For a customer-managed Anypoint deployment, set PAUSE_MCP_BASE_URL
// on the Vercel deployment to the customer's Experience-tier base URL
// and the same four tools transparently call the customer's APIs.
// The registration URL doesn't change.

Pause as an MCP host · the other direction

Pause's Care Router agent now CALLS external MCP servers, not just exposes its own

Why ship both directions:

• Server-side (above) — any AI agent can use Pause as a tool source via https://pause-health.ai/api/mcp.
• Host-side (this section) — Pause's own agents can use any partner's MCP server (Salesforce Agentforce, Heroku Managed MCP, custom Apex tools) as a tool source without bespoke per-vendor adapters.

Configuration + flow:

// Vercel env (or .env.local) on the prototype:
PAUSE_MCP_HOST_ENABLED=on
// Optional — add external MCP servers the Care Router can also call:
PAUSE_MCP_HOST_REMOTES=[
  { "id": "salesforce", "url": "https://customer-mcp.example/mcp",
    "headers": { "Authorization": "Bearer …" } }
]

// Inside frontend/app/api/agents/care-router/tasks/route.ts:
//   const host = createMCPHostFromRequest(req);
//   const decision = await route(intake, grounding, {
//     providerLookup: providerLookupViaMcpHost({ host })
//   });
//   await host.close();

// Behavior:
//   1. Care Router task arrives at /api/agents/care-router/tasks
//   2. Host spins up an MCP Streamable HTTP client per registered remote
//   3. Tool calls iterate: loopback (https://pause-health.ai/api/mcp)
//      first, then each external slot in order. First ok() wins.
//   4. If every remote errors, host returns the last error and the
//      adapter falls back to the legacy direct-call ProviderLookup so
//      the routing decision NEVER regresses on host failure.
//   5. Trace span carries mcpHostEnabled, mcpHostRemoteCount, and a
//      per-attempt array { remoteId, ok, error? } so /demo/agent-fabric
//      shows which MCP server served the provider list.

The host opens a fresh MCP client per request (no module-level state, no cold-start staleness) and tears it down in a finally block when the routing decision finishes. 17 tests cover the host + adapter — config parsing, fallback chains, JSON payload parsing, an in-process integration test using InMemoryTransport that pins the wire contract — and the existing Care Router route tests still pass unchanged. See frontend/lib/mcp/host.ts and frontend/lib/mcp/provider-lookup.ts.

Prototype vs production

What changes between the two install paths

Why investors should care

The four compounding advantages

• Distribution leverageEvery new MCP client (Claude, Cursor, Agentforce, GPT, others) becomes a Pause distribution channel without engineering work. The protocol does the marketing — once Phase 1 ships.
• Same APIs, two contractsMuleSoft is the contract enterprise IT signs. MCP is the contract an AI agent signs. Pause owns both ends of the same shape — buyers don't have to choose between 'integratable' and 'agent-native.'
• Defensible architecture storyOpen standards everywhere: MCP (Anthropic / Model Context Protocol), MuleSoft (Salesforce), FHIR R5 (HL7), Open mHealth (DHCH), DBDP (Duke). No proprietary lock-in at any tier.
• Demo today, polish in Phase 1Investors and partners can clone the repo and call Pause's clinical APIs from inside Claude Desktop or Cursor in under five minutes. The mocked Experience APIs make this real today; the npm one-liner lands in Phase 1.