Integrations

Parley reaches any MCP client through the bridge, parley mcp. One command sets it up:

npx parley-protocol install                  # detects your AI tools and configures each one
npx parley-protocol install --target cursor --local   # one tool, this project only

install (alias: setup) creates an agent key and registers the bridge with each tool. For Claude Code, Codex, Gemini CLI and Cursor it also writes a short, marker-fenced PARLEY block of agent instructions, because subagents don't see MCP server instructions. Add services with parley add <url>; the bridge serves everything in parley services.

Where your key lives

By default, install creates only the agent key on this machine. Your principal key, the one that signs your policy and approvals, belongs somewhere the agent can't read (security model). Issue the grant there and bring it over:

# on the principal's device (another OS user, machine or phone)
parley grant --to <agent key> --risk low --per 25USD --spend 100USD --exp 30d

# on the agent's machine
parley grant-import <pg1.… token>
parley doctor        # "principal key is not on this machine (recommended)"

Just trying it out? parley install --with-principal creates the principal key locally, with a warning, and signs a starter policy: low-risk actions, up to 25.00 USD each and 100.00 USD in total, for 30 days. Anything else asks you. The starter policy isn't scoped to particular services, and spend is counted per service, so the total applies at each service separately. Add --svc to your own grants to scope them.

Configure by hand

Every client runs the same command: npx -y parley-protocol mcp, optionally followed by service URLs. With no URLs, it serves the services you added with parley add.

Don't auto-approve commits

Whatever the client, don't add parley_commit or parley_undo to an auto-approve or "trusted" list. Your client's own confirmation is a second check on top of your signed policy. Auto-approving parley_ask is fine: it's read-only by definition.

Claude Code

As a plugin, which bundles the MCP config and a parley skill that teaches the model consent etiquette (it runs the npm package, so it works once parley-protocol 0.1.0 is published):

/plugin marketplace add solomonjames/parley
/plugin install parley@parley

Or register the bridge directly:

claude mcp add parley -- npx -y parley-protocol mcp

Or in .mcp.json (project) or ~/.claude.json (user):

{
  "mcpServers": {
    "parley": { "type": "stdio", "command": "npx", "args": ["-y", "parley-protocol", "mcp"], "alwaysLoad": true }
  }
}

alwaysLoad keeps the Parley tools out of Claude Code's deferred tool search, so the model sees them from the first turn.

Claude Desktop

claude_desktop_config.json, in ~/Library/Application Support/Claude/ (macOS), %APPDATA%\Claude\ (Windows) or ~/.config/Claude/ (Linux):

{
  "mcpServers": {
    "parley": { "command": "npx", "args": ["-y", "parley-protocol", "mcp"] }
  }
}

Cursor

~/.cursor/mcp.json (global) or .cursor/mcp.json (project):

{
  "mcpServers": {
    "parley": { "command": "npx", "args": ["-y", "parley-protocol", "mcp"] }
  }
}

VS Code (GitHub Copilot)

.vscode/mcp.json. Note the top-level key is servers:

{
  "servers": {
    "parley": { "type": "stdio", "command": "npx", "args": ["-y", "parley-protocol", "mcp"] }
  }
}

Codex CLI

~/.codex/config.toml:

[mcp_servers.parley]
command = "npx"
args = ["-y", "parley-protocol", "mcp"]

Gemini CLI

~/.gemini/settings.json (user) or .gemini/settings.json (project):

{
  "mcpServers": {
    "parley": { "command": "npx", "args": ["-y", "parley-protocol", "mcp"] }
  }
}

Leave Gemini's per-server trust unset or false: true skips tool-call confirmations.

Zed

In Zed's settings.json:

{
  "context_servers": {
    "parley": { "command": "npx", "args": ["-y", "parley-protocol", "mcp"], "env": {} }
  }
}

Windsurf (Devin Desktop)

Windsurf is now Devin Desktop. Its Cascade agent reads ~/.config/devin/mcp_config.json (older Windsurf installs: ~/.codeium/windsurf/mcp_config.json); open it from the Cascade panel's … menu, MCPs, Open MCP config file. parley install writes whichever applies.

{
  "mcpServers": {
    "parley": { "command": "npx", "args": ["-y", "parley-protocol", "mcp"] }
  }
}

Hermes Agent

Hermes Agent is an MCP client, so it can use Parley services directly:

hermes mcp add parley --command npx --args -y parley-protocol mcp

or in Hermes's config.yaml:

mcp_servers:
  parley:
    command: "npx"
    args: ["-y", "parley-protocol", "mcp"]

Consent works well here: when a commit needs the human's approval and the client supports MCP elicitation, the bridge asks through it, and Hermes routes form-mode elicitation through its own approval surface. If you restrict which tools a server exposes (tools.include), include all four Parley tools; the agent needs parley_intent to see proposals before parley_commit.

MCP registry

Parley's MCP registry entry is io.github.solomonjames/parley (server.json: npm package parley-protocol, stdio transport, argument mcp). It's published with the first release; then clients that browse the registry can install it from there.

Services to try

parley examples               # the example calendar (7447) and shop (7449), trusting your principal
parley add parley://127.0.0.1:7447
parley add parley://127.0.0.1:7449

Or wrap an API you already use: Wrap any REST API. Then restart your AI tool and ask it to do something.