Paybond MCP Server

Herramientas MCP vinculadas a inquilinos para autorización de gastos de agentes, evidencia, recibos y liquidación en Cursor, Codex y Claude Code.

Ver en paybond.aiPrueba este MCPPatrocinado

Documentación

Un host de MCP entrega a tus agentes herramientas que pueden cobrar dinero real. Un límite por transacción no ayuda mucho: doce llamadas a herramientas de $399 bajo un límite de $500 aún liquidan $4,788, porque cada aprobación no tiene memoria de la anterior — y un cargo liquidado no es prueba de que el trabajo ocurrió.

Paybond envía un servidor MCP vinculado a un tenant que cierra esa brecha. Vincula el gasto delegado a una intención firmada, libera o reembolsa contra evidencia de finalización enviada, y devuelve un recibo que finanzas puede reproducir — mientras preserva el mismo límite de tenant que los SDKs y APIs. Úsalo para runtimes de agentes internos y sistemas de orquestación que prefieren MCP sobre wrappers HTTP personalizados.

Superficie de adaptador de primera clase. Los hosts de MCP son una ruta de integración de framework compatible junto con adaptadores en proceso — consulta Middleware de agente, Configuración de agente de codificación y la Matriz de soporte de Kit.

Para la configuración de agentes de codificación, incluidos Codex y fragmentos genéricos de stdio MCP usando npx -y -p @paybond/kit paybond-mcp-server, comienza con Configuración de agente de codificación.

Para una primera integración de guardarraíl fuera de MCP, comienza con el andamiaje de sandbox:

npx -p @paybond/kit paybond-init \
  --preset paid-tool-guard \
  --framework provider-agnostic \
  --out paybond-paid-tool-guard.ts
paybond-kit-init \
  --preset paid-tool-guard \
  --framework provider-agnostic \
  --out paybond_paid_tool_guard.py
npx -p @paybond/kit paybond-init \
  --preset paid-tool-guard \
  --framework provider-agnostic \
  --out paybond-paid-tool-guard.ts
paybond-kit-init \
  --preset paid-tool-guard \
  --framework provider-agnostic \
  --out paybond_paid_tool_guard.py

Para hosts nativos de MCP, las herramientas de sandbox correspondientes son paybond_bootstrap_sandbox_guardrail y paybond_submit_sandbox_guardrail_evidence.

El servidor es stdio-primero por defecto — la mayoría de los hosts de escritorio lo lanzan como un proceso hijo local. Los hosts que necesitan una URL de red en su lugar pueden usar el endpoint HTTP Streamable alojado o auto-alojar el mismo transporte HTTP; consulta HTTP remoto (Streamable HTTP) a continuación.

Paybond no asume un proveedor de modelo o framework de agente específico. La única suposición es que tu host puede hablar llamadas a herramientas MCP, ya sea sobre stdio o Streamable HTTP.

Instalación

npm install @paybond/mcp

Importar desde @paybond/mcp

import { createPaybondMcpToolSurface } from "@paybond/mcp";

Subruta equivalente en el paquete principal: @paybond/kit/mcp\ — usa @paybond/kit\ cuando necesites múltiples adaptadores en una sola aplicación.
Para hosts de stdio MCP, lanza npx -y -p @paybond/kit paybond-mcp-server — consulta Configuración de agente de codificación en la documentación.
Python: paybond agent demo mcp smoke\ requiere el extra opcional mcp\. Usa pip install "paybond-kit\[mcp\]"\, pipx install 'paybond-kit\[mcp\]'\ o pipx inject paybond-kit mcp\ (cuando paybond-kit base ya esté instalado).
Prueba rápida: paybond agent demo mcp smoke --operation paid-tool --requested-spend-cents 100 --evidence-preset cost\_and\_completion --format json\ (MCP en proceso).

Entorno requerido

Siempre requerido. Para la configuración de sandbox, usa primero uno de los CLIs de inicio de sesión:

npx -p @paybond/kit paybond login
paybond-kit-login
npx -p @paybond/kit paybond login
paybond-kit-login

Los CLIs escriben PAYBOND_API_KEY en .env.local; los servidores MCP empaquetados cargan .env.local por defecto cuando PAYBOND_API_KEY no está ya presente. Establece PAYBOND_ENV_FILE para un archivo de secretos local diferente, o pasa PAYBOND_API_KEY en el entorno de lanzamiento del host MCP. Las claves de producción se crean en Console y se almacenan en administradores de secretos de despliegue.

Claves MCP restringidas (recomendadas para hosts)

Para Cursor, Claude Desktop, Codex y otros hosts de MCP, prefiere una clave restringida (paybond_rk_*) sobre una clave de cuenta de servicio estándar (paybond_sk_*). Las claves restringidas llevan una concesión de alcance MCP explícita; tools/list y tools/call exponen solo las herramientas que esos alcances desbloquean, y la puerta de enlace aplica los mismos alcances en las rutas subyacentes. Las claves estándar mantienen RBAC basado en roles y PAYBOND_MCP_TOOL_POLICY opcional para desarrollo local.

Crea una desde Console (Acceso de máquina → Claves API → Clave MCP restringida) o el CLI:

paybond keys create \
  --name cursor-discovery \
  --role analyst \
  --kind restricted \
  --preset mcp-readonly \
  --label cursor-discovery
paybond keys create \
  --name cursor-discovery \
  --role analyst \
  --kind restricted \
  --preset mcp-readonly \
  --label cursor-discovery

Ajustes preestablecidos (la escritura de liquidación / dinero real nunca se incluye — agrega --scope mcp.settlement:write solo cuando necesites intencionalmente fondos/confirmación):

Ajuste preestablecido	Alcances
`mcp-readonly`	discovery, signal, compliance, receipts (lectura)
`mcp-spend-operator`	readonly + spend + evidence (escritura)
`mcp-sandbox-agent`	discovery + sandbox + spend (escritura)

Lista el catálogo (sin conexión):

paybond mcp scopes list
paybond mcp scopes list --format json
paybond mcp scopes list
paybond mcp scopes list --format json

Cuando mcp install detecta una clave restringida en el archivo de entorno, omite PAYBOND_MCP_TOOL_POLICY de la configuración de host generada — los alcances provienen de la clave. Emparejar --tool-policy / --tool-allowlist con una clave restringida se rechaza.

Opcional:

export PAYBOND_PRINCIPAL_PATH="/v1/auth/principal"
export PAYBOND_MCP_MAX_RETRIES="3"
export PAYBOND_MCP_EVIDENCE_POLICY="strict"
export PAYBOND_ENV_FILE=".env.local"
export PAYBOND_PRINCIPAL_PATH="/v1/auth/principal"
export PAYBOND_MCP_MAX_RETRIES="3"
export PAYBOND_MCP_EVIDENCE_POLICY="strict"
export PAYBOND_ENV_FILE=".env.local"

PAYBOND_MCP_EVIDENCE_POLICY por defecto es strict. En modo estricto, las herramientas de envío de evidencia rechazan llamadas hasta que paybond_validate_completion_evidence tenga éxito para el mismo ajuste preestablecido y carga útil. Establece off solo para depuración local. La validación de predicado y esquema de Harbor sigue siendo autoritativa en el momento del envío.

Recarga de políticas opcional para procesos MCP de larga duración:

export PAYBOND_POLICY_FILE="./paybond.policy.yaml"
export PAYBOND_POLICY_RELOAD="watch"   # watch | poll | off (default off)
export PAYBOND_POLICY_RELOAD_ALLOW_LOOSEN="0"
export PAYBOND_POLICY_FILE="./paybond.policy.yaml"
export PAYBOND_POLICY_RELOAD="watch"   # watch | poll | off (default off)
export PAYBOND_POLICY_RELOAD_ALLOW_LOOSEN="0"

Cuando PAYBOND_POLICY_FILE está establecido, paybond_authorize_agent_spend y paybond_verify_capability aplican el registro de políticas antes de la verificación de Harbor. Los límites de gasto se resuelven desde el archivo de políticas cuando requested_spend_cents se omite. La recarga espera a que las llamadas a herramientas MCP en vuelo terminen antes de intercambiar el registro; las recargas fallidas mantienen la instantánea anterior. Usa poll con políticas de superposición de tenant para actualizar la política efectiva desde la Gateway.

Ejecutar

Python

paybond-mcp-server
paybond-mcp-server

TypeScript

npx paybond-mcp-server
npx paybond-mcp-server

HTTP remoto (Streamable HTTP)

Stdio sigue siendo el predeterminado para hosts de escritorio (Cursor, Claude Desktop, Codex CLI). Para hosts que necesitan una URL de red en lugar de un subproceso local — runtimes de agentes remotos, modo HTTP de MCP Inspector, o cualquier orquestador que no pueda lanzar procesos hijos — Paybond también ejecuta la misma superficie de herramientas sobre Streamable HTTP, el transporte remoto actual de MCP (un solo POST /mcp con una respuesta JSON; sin HTTP+SSE heredado).

Endpoint alojado: https://mcp.paybond.ai/mcp

curl https://mcp.paybond.ai/mcp \
  -X POST \
  -H "content-type: application/json" \
  -H "authorization: Bearer $PAYBOND_API_KEY" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
curl https://mcp.paybond.ai/mcp \
  -X POST \
  -H "content-type: application/json" \
  -H "authorization: Bearer $PAYBOND_API_KEY" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Cada solicitud proporciona su propia clave de cuenta de servicio o clave MCP restringida como Authorization: Bearer paybond_sk_... o Bearer paybond_rk_... — el endpoint alojado es multi-tenant y sin estado: el alcance del tenant proviene solo de la clave (nunca de un tenant_id suministrado por el cliente), y cada solicitud se maneja de forma independiente sin nada almacenado en caché o compartido entre llamadores. Las claves restringidas filtran la superficie de herramientas por solicitud desde principal.mcp_scopes. Debido a que no hay sesión por conexión, siempre pasa capability_token explícitamente a paybond_authorize_agent_spend / paybond_verify_capability en lugar de confiar en que el token se recuerde de una llamada anterior en el mismo proceso (esa conveniencia solo se aplica a una sola sesión stdio de larga duración).

Ejemplo de configuración de cliente MCP para un host compatible con HTTP (prefiere una clave restringida en producción):

{
  "url": "https://mcp.paybond.ai/mcp",
  "headers": {
    "Authorization": "Bearer paybond_rk_sandbox_..."
  }
}
{
  "url": "https://mcp.paybond.ai/mcp",
  "headers": {
    "Authorization": "Bearer paybond_rk_sandbox_..."
  }
}

Auto-alojamiento del mismo contrato: ambos CLIs de Kit pueden ejecutar el contrato idéntico Bearer/Origin//healthz localmente en lugar de depender del endpoint alojado:

# TypeScript
npx paybond-kit mcp serve --transport http

# Python (requires the optional \`mcp\` extra: pip install "paybond-kit[mcp]")
paybond-kit mcp serve --transport http
# TypeScript
npx paybond-kit mcp serve --transport http

# Python (requires the optional \`mcp\` extra: pip install "paybond-kit[mcp]")
paybond-kit mcp serve --transport http

El CLI de Python se vincula a un tenant durante la vida del proceso: establece PAYBOND_API_KEY en el entorno del proceso y cada token Bearer entrante se verifica contra esa única clave (una puerta de secreto compartido en el acceso de red, no una forma de servir múltiples tenants desde un proceso). El CLI de TypeScript es multi-tenant como el endpoint alojado — deriva el alcance del tenant por solicitud de cualquier clave que presente el llamador. Ambos aceptan las mismas variables de entorno PAYBOND_MCP_HTTP_*:

export PAYBOND_MCP_HTTP_ADDR="0.0.0.0:8080"                       # default
export PAYBOND_MCP_HTTP_ALLOWED_ORIGINS="https://example.com"     # comma-separated; only enforced when a client sends an Origin header
export PAYBOND_MCP_HTTP_MAX_BODY_BYTES="1048576"                  # 1 MiB default
export PAYBOND_MCP_HTTP_RATE_LIMIT_PER_MINUTE="120"                # per authenticated API key
export PAYBOND_MCP_HTTP_RATE_LIMIT_UNAUTH_PER_MINUTE="30"          # per source IP, slows credential scanning
export PAYBOND_MCP_HTTP_ADDR="0.0.0.0:8080"                       # default
export PAYBOND_MCP_HTTP_ALLOWED_ORIGINS="https://example.com"     # comma-separated; only enforced when a client sends an Origin header
export PAYBOND_MCP_HTTP_MAX_BODY_BYTES="1048576"                  # 1 MiB default
export PAYBOND_MCP_HTTP_RATE_LIMIT_PER_MINUTE="120"                # per authenticated API key
export PAYBOND_MCP_HTTP_RATE_LIMIT_UNAUTH_PER_MINUTE="30"          # per source IP, slows credential scanning

GET /healthz devuelve 200 sin autenticación para verificaciones de salud de balanceadores de carga y contenedores. PAYBOND_POLICY_RELOAD=watch|poll (recarga de políticas) se rechaza en el inicio HTTP — depende de una instancia de proceso de larga duración y solo se admite para stdio; usa PAYBOND_POLICY_RELOAD=off (el predeterminado) u omítelo por completo al ejecutar HTTP.

Categorías de herramientas

Descubrimiento de solo lectura y cumplimiento (permitido bajo --tool-policy readonly):

paybond_get_principal
paybond_list_intents
paybond_get_intent
paybond_list_audit_exports
paybond_get_audit_export
paybond_get_reputation_receipt
paybond_get_portfolio_summary
paybond_get_signed_portfolio_artifact
paybond_get_fraud_assessment
paybond_get_fraud_metrics
paybond_get_a2a_agent_card
paybond_list_a2a_task_contracts
paybond_get_a2a_task_contract
paybond_verify_agent_mandate_v1
paybond_verify_agent_recognition_proof_v1
paybond_get_settlement_receipt_v1
paybond_verify_protocol_receipt_v1
paybond_get_agent_receipt_v1
paybond_verify_agent_receipt_v1
paybond_validate_completion_evidence
paybond_get_budget_remaining
paybond_explain_policy

Herramientas de gasto y mutación (por defecto --tool-policy spend-write; las herramientas de dinero real como paybond_fund_intent y paybond_confirm_settlement permanecen bloqueadas a menos que se permitan explícitamente):

paybond_verify_capability
paybond_authorize_agent_spend
paybond_bootstrap_sandbox_guardrail
paybond_submit_sandbox_guardrail_evidence
paybond_import_agent_mandate_v1
paybond_create_intent
paybond_create_spend_intent
paybond_fund_intent
paybond_submit_evidence
paybond_submit_spend_evidence
paybond_confirm_settlement

Para hosts de producción, acuña una clave restringida (consulta Claves MCP restringidas) para que la credencial en sí limite la superficie de herramientas. Para instalaciones locales con clave estándar, una política de entorno de solo lectura aún funciona:

# Preferred (scopes on the key)
paybond keys create --name cursor --role analyst --kind restricted --preset mcp-readonly
paybond mcp install --host generic --scope project

# Local standard-key override (dev only)
paybond mcp install --host generic --scope project --tool-policy readonly
# Preferred (scopes on the key)
paybond keys create --name cursor --role analyst --kind restricted --preset mcp-readonly
paybond mcp install --host generic --scope project

# Local standard-key override (dev only)
paybond mcp install --host generic --scope project --tool-policy readonly

La verificación local de paquetes de auditoría (paybond audit exports verify <path> o paybond.audit.exports.verify(...)) es solo SDK/CLI. Los hosts de MCP no pueden verificar rutas ZIP descargadas en disco. Los paquetes de cumplimiento que incluyen agent_receipts también pueden contener archivos complementarios PEF (*.pef.json) junto a cada recibo firmado.

Las herramientas nombradas para gasto son alias sobre las mismas rutas Harbor y Gateway vinculadas al tenant. Existen para que los hosts de agentes puedan coincidir con solicitudes de usuario como "controlar el gasto del agente", "agregar límites de gasto en llamadas a herramientas" o "autorizar acciones de proveedores pagados" sin adivinar a partir de nombres de capacidades de nivel inferior.

paybond_get_budget_remaining y paybond_explain_policy llaman a la ruta de gateway sin efectos secundarios POST /v1/spend/preflight. Evalúan la misma política de control de gasto que authorize sin crear decisiones, reservas o solicitudes de aprobación. Úsalas antes de paybond_authorize_agent_spend cuando un agente necesite presupuesto restante o una explicación legible de allow / approval_required / deny. Comandos CLI correspondientes: paybond spend budget-remaining y paybond spend explain-policy.

paybond_verify_protocol_receipt_v1 es una verificación sin conexión de solo lectura de un recibo de autorización o liquidación firmado de protocolo v2 (POST /protocol/v2/receipts/verify). Pasa el objeto de recibo completo (no un receipt_id). Usa paybond_verify_agent_mandate_v1 para sobres de mandato y paybond_verify_capability / paybond_authorize_agent_spend para puertas de capacidad de Harbor. Obtén primero un recibo de liquidación con paybond_get_settlement_receipt_v1 cuando solo tengas un UUID de intención.

paybond_get_agent_receipt_v1 obtiene un paybond.agent_receipt_v1 firmado por receipt_id (GET /protocol/v2/agent-receipts/{receipt_id} vinculado al tenant). paybond_verify_agent_receipt_v1 ejecuta la misma verificación de firma de nivel operativo sin conexión que resources/read en paybond://receipt/{receipt_id}; pasa validity_tier=primary|attested opcional cuando necesites un estándar más fuerte. Las cadenas de continuidad, pruebas de inclusión, divulgación del propietario y adaptadores ACTA/PEF/SCITT siguen siendo superficies de Kit TypeScript/Python y CLI/Gateway auditor — no el trabajo completo de MCP.

paybond_get_principal devuelve el principal de cuenta de servicio vinculado al tenant para el PAYBOND_API_KEY configurado (tenant_id, subject, roles) a través de un GET de gateway de solo lectura. Úsalo cuando necesites confirmar la identidad de autenticación; llámalo temprano como requisito previo antes de llamadas al ciclo de vida de intención, lecturas de Signal u otras herramientas con alcance de tenant cuando la identidad del tenant sea desconocida. No es necesario antes de cada llamada posterior una vez que tenant_id ya se conoce. No lo uses cuando necesites detalles de intención — usa paybond_get_intent en su lugar cuando tengas un intent_id. No lo uses para descubrimiento A2A — usa paybond_get_a2a_agent_card en su lugar.

paybond_get_portfolio_summary devuelve un agregado de Signal con alcance de tenant (conteos, puntaje promedio, volumen, operadores bajo revisión). Omite score_version para usar el predeterminado de la gateway (1.0). Prefiere paybond_get_signed_portfolio_artifact cuando necesites una lista de operadores firmada y portátil para compartir con socios o verificadores, y paybond_get_reputation_receipt para un solo operador.

paybond_get_signed_portfolio_artifact devuelve una instantánea de portafolio de Signal firmada con alcance de tenant (lista de operadores más material de firma Ed25519) para verificaciones de verificador sin conexión o intercambio con socios. Omite score_version para usar el predeterminado de la gateway (1.0). Prefiere paybond_get_portfolio_summary para agregados sin firmar, paybond_get_reputation_receipt para un solo operador y paybond_get_fraud_assessment para la postura de revisión de fraude.

paybond_get_fraud_metrics devuelve métricas de backtesting de fraude a nivel de tenant para una ventana móvil (24h predeterminado, o 7d / 30d). Las ventanas no compatibles fallan con HTTP 400. Usa paybond_get_fraud_assessment cuando necesites la postura de fraude de un solo operador en lugar de agregados de tenant. paybond_get_reputation_receipt obtiene el recibo firmado de reputación Signal para un DID de operador (GET /reputation/{operator_did}). Omite score_version para usar el valor predeterminado de la puerta de enlace (1.0). Devuelve null cuando no existe ningún recibo. Prefiere paybond_get_portfolio_summary para agregados de tenant, paybond_get_signed_portfolio_artifact para una lista firmada y portátil de operadores, y paybond_get_fraud_assessment para la postura de revisión de fraude.

Las herramientas de protección del sandbox son ayudas separadas solo para desarrolladores. Llaman a /v1/sandbox/guardrails/..., derivan el alcance del tenant de la clave API de cuenta de servicio configurada y no reemplazan las herramientas de producción de Harbor de creación/financiación/evidencia.

Flujo de gasto típico

Llama a paybond_create_spend_intent para crear la intención de gasto firmada.
Si la intención no se financia de inmediato, llama a paybond_fund_intent.
Opcionalmente, llama a paybond_get_budget_remaining o paybond_explain_policy para una verificación previa de solo lectura del presupuesto restante y el resultado de la política.
Usa los intent_id y capability_token devueltos con paybond_authorize_agent_spend antes de cualquier llamada API de pago, acción de proveedor, paso de liquidación u otra herramienta con efectos secundarios.
Llama a paybond_validate_completion_evidence con el preset de finalización y la carga útil que planeas enviar.
Después de que el trabajo protegido se complete, llama a paybond_submit_spend_evidence con el mismo preset y la misma carga útil.

Si estás escribiendo código de SDK en lugar de exponer herramientas MCP, usa paybond.spendGuard(intentId, capabilityToken) en TypeScript o paybond.spend_guard(intent_id, capability_token) en Python. PaybondCapabilityBinding solo se necesita para adaptadores de frameworks de Python que requieren un objeto de contexto de ejecución.

Flujo de prueba rápida de protección del sandbox

Llama a paybond_bootstrap_sandbox_guardrail con una operación y un monto de gasto de sandbox.
Usa los intent_id y capability_token devueltos con paybond_authorize_agent_spend antes de que se ejecute la herramienta de pago de muestra.
Llama a paybond_validate_completion_evidence cuando uses un preset de finalización (por ejemplo, api_response_ok).
Llama a paybond_submit_sandbox_guardrail_evidence con el intent_id de sandbox, completion_preset_id y la carga útil de evidencia.

Comando de prueba rápida incluido

Valida la ruta de autorización y evidencia de MCP sin lanzar un subproceso stdio ni un LLM:

paybond agent demo mcp smoke \
  --operation paid-tool \
  --requested-spend-cents 100 \
  --evidence-preset cost_and_completion \
  --format json
paybond agent demo mcp smoke \
  --operation paid-tool \
  --requested-spend-cents 100 \
  --evidence-preset cost_and_completion \
  --format json

La prueba rápida usa PaybondMCPServer.callTool() en proceso (TypeScript) o build_mcp_server().call_tool() (Python): enlace de sandbox, paybond_authorize_agent_spend, finalización simulada de efectos secundarios y paybond_submit_sandbox_guardrail_evidence. Python requiere el extra opcional mcp (pip install "paybond-kit[mcp]").

Modelo de seguridad

El servidor está vinculado a un tenant derivado de la clave API de cuenta de servicio configurada.
No pases IDs de tenant manualmente a través de argumentos de herramientas para flujos normales.
Las herramientas de cambio de estado respaldadas por la puerta de enlace requieren el material de prueba correcto y fallan de forma segura cuando las pruebas faltan, están obsoletas, se reproducen o no coinciden.
Los cuerpos de solicitud firmados de Harbor siguen siendo responsabilidad del llamador. El servidor MCP no gestiona claves de firma de larga duración en nombre del modelo.
El endpoint HTTP alojado (https://mcp.paybond.ai/mcp) acepta:
- Claves restringidas (paybond_rk_*) — preferidas para agentes y automatización; los alcances de la clave son el modelo de permisos.
  - Claves estándar (paybond_sk_*) — derechos de rol completos; úsalas solo cuando quieras intencionalmente una credencial de máquina sin restricciones.
  - Tokens de acceso OAuth de MCP (paybond_oat_*) — concesiones con alcance de usuario del flujo de consentimiento de Console para hosts interactivos (Cursor, Claude, VS Code). De corta duración; renueva con paybond_ort_* mediante POST /v1/oauth/token.
Prefiere una clave restringida de sandbox para pruebas; para hosts de producción, crea una clave restringida con los alcances MCP mínimos en Console, o usa el consentimiento OAuth para hosts interactivos.

Comprueba qué credencial usará realmente una configuración de host:

paybond doctor --mcp --host claude
paybond doctor --mcp --host claude

--mcp falla cuando la configuración se resuelve a una clave paybond_sk_* sin restricciones (la puerta de enlace no puede limitar su superficie MCP) y nuevamente cuando esa clave ni siquiera está limitada por PAYBOND_MCP_TOOL_POLICY. Pasa --config <path> para evaluar una configuración de host en disco en lugar de la que paybond mcp install generaría.

OAuth de MCP (hosts interactivos)

Los hosts MCP interactivos pueden obtener un bearer con alcance sin incrustar una clave API de larga duración:

El host redirige el navegador a GET /v1/oauth/authorize (PKCE S256, response_type=code).
Console abre /console/authorize/mcp?request=… para un tenant_admin humano.
El administrador revisa los alcances solicitados / herramientas visibles, opcionalmente reduce la concesión y la aprueba (el mcp.settlement:write en vivo requiere autenticación MFA adicional).
El host canjea el código en POST /v1/oauth/token y llama a https://mcp.paybond.ai/mcp con Authorization: Bearer paybond_oat_….

Los administradores de tenant gestionan el interruptor de apagado de MCP por entorno, las sesiones OAuth activas y las URI de redirección personalizadas en Console → Machine access → MCP access. Deshabilitar MCP bloquea nuevas concesiones y rechaza los bearers paybond_oat_* existentes para ese entorno.

Ejemplo de configuración de cliente MCP

Ejemplo de entrada stdio local usando el .env.local predeterminado escrito por paybond login:

{
  "command": "npx",
  "args": ["-y", "-p", "@paybond/kit", "paybond-mcp-server"],
  "env": {
    "PAYBOND_ENV_FILE": ".env.local"
  }
}
{
  "command": "npx",
  "args": ["-y", "-p", "@paybond/kit", "paybond-mcp-server"],
  "env": {
    "PAYBOND_ENV_FILE": ".env.local"
  }
}

Entrada avanzada de clave directa para hosts que no pueden leer archivos de entorno:

{
  "command": "npx",
  "args": ["-y", "-p", "@paybond/kit", "paybond-mcp-server"],
  "env": {
    "PAYBOND_API_KEY": "paybond_sk_sandbox_..."
  }
}
{
  "command": "npx",
  "args": ["-y", "-p", "@paybond/kit", "paybond-mcp-server"],
  "env": {
    "PAYBOND_API_KEY": "paybond_sk_sandbox_..."
  }
}

Recursos de recibos de agentes (MCP)

El rol de ARS de MCP es la transferencia de recibos entre agentes mediante la URI de recurso paybond://receipt/{receipt_id}: los hosts pasan la URI entre agentes sin incrustar JSON completo en los prompts.

Elemento	Valor
Plantilla de URI	`paybond://receipt/{receipt_id}`
Tipo MIME	`application/json`
Fuente	`GET /protocol/v2/agent-receipts/{receipt_id}` vinculado al tenant
Verificar al leer	Comprobación de firma de nivel operativo (esquema, digest, Gateway Ed25519)

Servidores stdio de TypeScript y Python:

resources/templates/list — publica la plantilla paybond://receipt/{receipt_id}
resources/read — obtiene el JSON firmado paybond.agent_receipt_v1 y verifica en el nivel operativo antes de devolverlo; un fallo de verificación devuelve un error claro (el contenido no se entrega sin firmar)

Herramientas de solo lectura (misma superficie que las herramientas de recibos de liquidación):

paybond_get_agent_receipt_v1 — obtener por receipt_id
paybond_verify_agent_receipt_v1 — verificación sin conexión de un objeto de recibo; validity_tier opcional (operational predeterminado, o primary / attested)

Los niveles de validez más allá de una comprobación rápida de transferencia, las auditorías de cadena de continuidad, las pruebas de inclusión de Merkle / cabeza de árbol, la divulgación confidencial del propietario y los adaptadores de exportación ACTA / PEF / SCITT son superficies de auditoría de Kit TypeScript/Python, CLI y Gateway, no la función completa de MCP. Usa las bibliotecas cliente de Kit para esos flujos.

Las exportaciones de auditoría de cumplimiento que incluyen recibos de agentes también pueden incluir acompañantes PEF (*.pef.json) junto a cada JSON de recibo firmado.