XAIP

Proporciona a los agentes de IA una identidad persistente en cadena en XRPL: DIDs, credenciales, puntuaciones de reputación, depósitos en garantía y Memory Chain.

GitHub

Documentación

XAIP — Recibos de ejecución firmados para llamadas a herramientas de agentes de IA

Evidencia antes de la delegación. Envuelve las llamadas a herramientas de un agente una sola vez; usa el historial de recibos localmente hoy, y comparte los mismos recibos firmados más adelante como evidencia portátil e independientemente verificable.

XAIP es una capa de evidencia de ejecución firmada, neutral respecto al proveedor, para llamadas a herramientas de agentes de IA. Registra recibos co-firmados — tanto el agente ejecutor como el llamador firman el mismo registro canónico, de modo que ninguna de las partes puede fabricarlo unilateralmente — a través de MCP, LangChain.js, bucles de llamadas a herramientas compatibles con OpenAI y otros entornos de ejecución, y luego expone evidencia histórica de ejecución que los agentes, desarrolladores o capas de políticas pueden inspeccionar antes de la delegación.

Los recibos son el artefacto principal. Las puntuaciones de confianza son una vista derivada sobre esos recibos — no una afirmación de seguridad o corrección absoluta.

XAIP en 30 segundos

Mecanismo — una llamada a herramienta entra, un recibo sale. El agente ejecutor y el llamador firman el mismo registro canónico (Ed25519 sobre JCS), de modo que ninguna de las partes puede fabricarlo o repudiarlo unilateralmente. Solo se transportan hashes de entrada/salida; el contenido nunca sale de tu máquina.
Lo que obtienes desde el primer día — un historial verificable de lo que realmente hicieron las herramientas de tu propio agente, consultable antes de la siguiente delegación (precheck()). Útil en modo de un solo jugador; no requiere una red de otros usuarios.
Lo que XAIP no es — no es un sandbox, no es un motor de aprobación, no es una vía de pago, no es una garantía de seguridad. Hace visible la evidencia de ejecución; tú decides en qué confiar.

Elige tu profundidad: 3 minutos — produce tu primer recibo firmado · 10 minutos — verifica el formato tú mismo: ejecuta los vectores de conformidad ejecutables (node check.mjs, sin dependencias) y luego hojea el Internet-Draft que fija.

Demo en vivo: tres servidores candidatos, comparación lado a lado sin y con XAIP. Abrir en el navegador →

Neutral respecto al proveedor por diseño. XAIP es una capa de confianza para cualquier agente que use herramientas. La implementación de referencia y los datos en vivo comienzan con MCP (Model Context Protocol) — porque es donde existe hoy la flota más amplia de servidores públicos de herramientas — pero el formato de recibo, la firma y la puntuación se aplican igualmente a herramientas de LangChain, function calling de OpenAI, A2A y stacks de agentes propietarios. MCP es la primera integración, no la única.

Panel en vivo: https://xkumakichi.github.io/xaip-protocol/ — puntuaciones de confianza públicas actuales, actualización automática, sin autenticación. El conjunto de datos público actual está centrado en MCP porque MCP fue el primer objetivo de integración.

Puntos de entrada

Evidencia de confianza antes de la delegación — demo de una pantalla, POST /v1/select en vivo contra tres candidatos contrastantes.
Demo de evidencia antes del pago — demo de una pantalla: lo que un agente ve sobre una habilidad cerrada de pago antes de pagar, con vs sin evidencia de ejecución de precheck() (tres candidatos ficticios, fixture sembrado).
Playground en el navegador — demo de solo lectura de selección consciente de confianza.
Resumen de 60 segundos — el problema que XAIP intenta abordar.
Dirección futura — hipótesis a largo plazo, preguntas abiertas y solicitudes de investigación actuales.
Caso de estudio de dominancia de un solo llamador — un modo de fallo real detectado en el propio conjunto de datos público de XAIP el 2026-05-13, y lo que implica para la diversidad de llamadores.
Diseño de Agent Trust Check — concepto de diagnóstico planificado.
Diseño de puntuación consciente de clases — nota de diseño futura; no es comportamiento de puntuación en vivo.
Emitir recibos desde cualquier cosa — cómo producir recibos XAIP desde cualquier sistema de herramientas.
Guía de la API precheck() — asistente del SDK para evidencia de ejecución antes de la delegación.
Ejecutar xaip-caller — contribuye recibos firmados sin ejecutar MCP.

Pruébalo ahora

La API está en vivo. Sin registro, sin clave de API.

# Check trust score for a scored tool server
curl https://xaip-trust-api.kuma-github.workers.dev/v1/trust/context7

# Batch query
curl "https://xaip-trust-api.kuma-github.workers.dev/v1/trust?slugs=context7,sequential-thinking,filesystem"

# Decision engine: rank candidates by available execution evidence
curl -X POST https://xaip-trust-api.kuma-github.workers.dev/v1/select \
  -H "Content-Type: application/json" \
  -d '{"task":"Fetch React docs","candidates":["context7","sequential-thinking","unknown-server"]}'

La respuesta /v1/select te indica qué servidor usar, por qué y qué sucedería sin XAIP:

{
  "selected": "context7",
  "reason": "Highest trust among scored candidates based on current verified receipts",
  "rejected": [{ "slug": "unknown-server", "reason": "unscored — no execution evidence available" }],
  "withoutXAIP": "Random selection would pick an unscored server 33% of the time — no execution evidence available"
}

El problema

Sin puntuaciones de confianza, tu agente está apostando:

┌────────────────┬────────────────┬───────────┬──────────────┐
│ Strategy       │ Server Hit     │ Success   │ Latency      │
├────────────────┼────────────────┼───────────┼──────────────┤
│ With XAIP      │ context7       │ ✓         │ ~3s          │
│ Random         │ unknown-mcp    │ ✗ error   │ ~8s (wasted) │
│ Try all (seq)  │ 3 servers      │ 1/3       │ ~11s total   │
└────────────────┴────────────────┴───────────┴──────────────┘

XAIP ayuda a los agentes a preferir candidatos con evidencia de ejecución disponible más sólida, omitir candidatos sin puntuar cuando corresponde y reducir llamadas fallidas evitables.

Cómo funciona

1. Select    POST /v1/select → ranks candidates by available execution evidence
2. Execute   Your agent calls the selected tool server
3. Report    POST /receipts → signed execution receipt feeds back into trust scores

Cada recibo de ejecución está firmado y verificado con Ed25519. Las puntuaciones de confianza se calculan con un modelo bayesiano con ponderación por diversidad de llamadores — no métricas auto-reportadas.

Inicio rápido — tu primer recibo firmado en menos de 5 minutos

El camino más rápido es el hook de Claude Code: tus llamadas normales a herramientas MCP comienzan a producir recibos firmados, sin que nada más que hashes salga de tu máquina. Medido de extremo a extremo en un perfil limpio de Windows 11 (Node 24, npm 11) — el tiempo total de comando fue de unos 8 segundos; los pasos son idénticos en macOS/Linux.

Quick start replay — install, one tool call, one signed receipt, verification, precheck

(Reproducción de terminal renderizada a partir de las salidas reales capturadas de esa medición — script generador.)

1. Instalar

npm install -g xaip-claude-hook

2. Un comando

xaip-claude-hook install

✓ XAIP Claude Code hook installed.
  C:\Users\you\.claude\settings.json

Next MCP tool call will emit a signed receipt to
  https://xaip-aggregator.kuma-github.workers.dev

3. Una llamada a herramienta

Abre una sesión nueva de Claude Code y deja que llame a cualquier herramienta MCP (por ejemplo, pídele que busque una librería con context7). El hook firma y envía un recibo automáticamente — tú no haces nada.

4. Un recibo firmado

cat ~/.xaip/hook.log

2026-07-17T03:41:57.964Z POST context7/resolve-library-id ok=true lat=2402ms → 200 {"ok":true,"agentDid":"did:web:context7","callerVerified":true}

callerVerified: true es el agregador que confirma tu firma de llamador Ed25519 sobre la carga útil canónica del recibo. Solo se enviaron hashes y metadatos (nombre de la herramienta, latencia, éxito) — nunca entradas, salidas ni rutas de archivo, y el registro muestra exactamente lo que salió de la máquina.

5. Un resultado de verificación

curl https://xaip-trust-api.kuma-github.workers.dev/v1/trust/context7

{ "slug": "context7", "trust": 0.926, "receipts": 1044,
  "source": "xaip-aggregator-1 (single aggregator)" }

6. Un resultado de precheck — sin confianza inventada

curl -X POST https://xaip-trust-api.kuma-github.workers.dev/v1/select \
  -H "Content-Type: application/json" \
  -d '{"task":"summarize a webpage","candidates":["context7","my-brand-new-server"]}'

{ "selected": "context7",
  "reason": "Only eligible candidate (trust 0.926, 1044 verified executions)",
  "rejected": [ { "slug": "my-brand-new-server",
                  "reason": "unscored — no execution evidence available" } ] }

Este es el comportamiento de arranque en frío, mostrado con honestidad: un servidor que nadie ha ejecutado es unscored, no recibe una puntuación sintética. La evidencia se acumula a medida que llegan los recibos; XAIP no fabrica confianza para herramientas sin historial de ejecución.

Si algo no funciona

El hook nunca se dispara — el comando del hook debe poder resolverse cuando Claude Code lo invoca: verifica que tu directorio global de binarios de npm (npm config get prefix) esté en PATH, y luego inicia una sesión nueva.
PowerShell dice "la ejecución de scripts está deshabilitada" — la política de ejecución predeterminada de Windows bloquea los shims de .ps1 de npm para comandos interactivos. Usa xaip-claude-hook.cmd, ejecútalo desde cmd, o Set-ExecutionPolicy -Scope CurrentUser RemoteSigned. La emisión de recibos no se ve afectada (el hook se ejecuta a través del shim de .cmd).
Desactivarlo — export XAIP_DISABLED=1 lo desactiva temporalmente; xaip-claude-hook uninstall elimina el hook (las claves/registros en ~/.xaip/ permanecen hasta que los elimines). Los recibos son seudónimos: tu DID de llamador es una clave por instalación, no vinculada a nada más.

Ejecutar la demo de extremo a extremo

git clone https://github.com/xkumakichi/xaip-protocol.git
cd xaip-protocol/demo
npm install
npx tsx dogfood.ts

Esta demo:

Pide a XAIP que clasifique servidores candidatos para "Fetch React hooks documentation" según la evidencia de ejecución disponible
Se conecta al servidor MCP seleccionado y ejecuta llamadas reales a herramientas
Envía un recibo de ejecución firmado al Agregador
Muestra la puntuación de confianza actualizada

Demo de calidad de decisión

Compara estrategias de selección a ciegas contra la selección guiada por XAIP usando una instantánea de confianza estática y conjuntos de candidatos fijos:

cd demo
npm run blind-vs-xaip

Esta es una reproducción local determinista. No realiza ejecución de herramientas en vivo, no publica recibos ni llama a ninguna API externa. Consulta docs/blind-vs-xaip-demo.md para alcance, métricas y limitaciones.

En la reproducción de instantánea incluida:

Estrategia	Tasa de elección arriesgada	Tasa de elección elegible
Aleatoria	71.4%	28.6%
Orden fijo	85.7%	14.3%
XAIP	14.3%	85.7%

risky_pick = el candidato seleccionado era low_trust o unscored en la instantánea. fixed-order modela un agente que acepta el orden de candidatos del planificador ascendente sin datos de confianza en tiempo de ejecución. La afirmación se limita a este conjunto de candidatos fijo y a esta instantánea de confianza estática — no es una garantía de mejora de ejecución en el mundo real.

Conviértete en un llamador independiente

¿Quieres que el grafo de confianza dependa de más de un operador? Ejecuta un llamador tú mismo. Sin cuenta, sin aprobación, sin clave de API — el agregador verifica firmas de cualquier par de claves válido.

Lo más rápido — sin instalación, 30 segundos:

npx xaip-caller

Firma recibos para un puñado de llamadas HTTP reales a herramientas y los envía por POST. Demuestra que XAIP funciona más allá de MCP — cualquier herramienta HTTP puede participar. Consulta clients/caller. Consulta Ejecutar xaip-caller para notas de Windows y detalles de contribución de recibos externos.

Ruta completa — servidores MCP, 5 minutos:

Clona el repositorio y ejecuta el auto-recolector contra servidores MCP reales. Tu DID de llamador contribuye a la diversidad de cada herramienta MCP puntuada. Consulta docs/contributor/run-a-caller.md.

Usar el SDK

npm install xaip-sdk

import { precheck } from "xaip-sdk";

const result = await precheck({
  task: "Fetch React documentation",
  candidates: ["context7", "memory", "unknown-server"],
  includeDecision: true,
});

console.log(result.selected); // e.g. "memory" or null
console.log(result.decision); // "allow", "warn", or "unknown"

precheck() es un envoltorio delgado del SDK sobre POST /v1/select. Devuelve evidencia de ejecución disponible para candidatos de herramientas, habilidades o agentes antes de que tu código decida qué delegar.

Consulta la guía de la API precheck() para límites, opciones de política, forma del resultado y errores.

Servidor MCP

Usa XAIP directamente desde Claude, Cursor o cualquier agente de IA compatible con MCP:

npx xaip-mcp-trust

4 herramientas: xaip_list_servers, xaip_check_trust, xaip_select, xaip_report

Añadir a Claude Code (~/.claude/claude_desktop_config.json):

{
  "mcpServers": {
    "xaip-trust": {
      "command": "npx",
      "args": ["-y", "xaip-mcp-trust"]
    }
  }
}

npm: xaip-mcp-trust

Referencia de API

Método	Endpoint	Descripción
`GET`	`/v1/servers`	Lista todos los servidores puntuados con datos de confianza
`GET`	`/v1/trust/:slug`	Puntuación de confianza para un único servidor puntuado
`GET`	`/v1/trust?slugs=a,b,c`	Puntuaciones de confianza por lotes (máx. 50)
`POST`	`/v1/select`	Motor de decisión — clasifica candidatos según la evidencia de ejecución disponible
`GET`	`/health`	Sonda de actividad

URL base: https://xaip-trust-api.kuma-github.workers.dev

Respuesta de puntuación de confianza

Campo	Tipo	Descripción
`trust`	`number \| null`	Puntuación 0.0–1.0, null si no está puntuado
`verdict`	`string`	`trusted` ≥0.7 · `caution` 0.4–0.7 · `low_trust` <0.4 · `unscored`
`receipts`	`number`	Total de recibos de ejecución verificados
`confidence`	`number \| null`	Confianza estadística: min(1, recibos/100)
`riskFlags`	`string[]`	Indicadores de riesgo detectados
`computedFrom`	`string`	Descripción de la procedencia de los datos

Motor de decisión (`POST /v1/select`)

Solicitud:

{
  "task": "description of what your agent needs to do",
  "candidates": ["server-a", "server-b", "server-c"],
  "mode": "relative"
}

mode: "relative" (predeterminado) — siempre selecciona la mejor opción disponible, incluso si está por debajo del umbral
mode: "strict" — rechaza todos los candidatos por debajo del umbral de precaución

Arquitectura

┌──────────────────────────────────────────────────────────┐
│  Your AI Agent                                           │
│  ┌──────────┐   ┌───────────┐   ┌─────────────────────┐ │
│  │ Select   │──▶│ Execute   │──▶│ Report Receipt      │ │
│  │ (Trust   │   │ (MCP call)│   │ (Ed25519 signed)    │ │
│  │  API)    │   └───────────┘   └──────────┬──────────┘ │
│  └────┬─────┘                              │            │
└───────┼────────────────────────────────────┼────────────┘
        │                                    │
        ▼                                    ▼
┌───────────────┐                 ┌──────────────────────┐
│  Trust API    │◀────────────────│  Aggregator (BFT)    │
│  + Decision   │  Service        │  Cloudflare D1       │
│    Engine     │  Binding        │  Ed25519 verification│
└───────────────┘                 │  Bayesian scoring    │
                                  └──────────────────────┘

Modelo de confianza:

Distribución Beta bayesiana (la prior varía según el método DID)
Ponderación por diversidad de llamadores (previene el juego de un solo llamador)
Factor de co-firma (Ed25519 dual: agente + llamador)
Federación capaz de BFT con detección de valores atípicos MAD entre nodos agregadores; el despliegue público actual es un nodo agregador único (las respuestas de la API dicen single aggregator; la redacción de quórum aparece solo en despliegues reales de múltiples nodos)

Infraestructura:

Cloudflare Workers (edge global, latencia <50ms)
Cloudflare D1 (SQLite en el edge) para almacenamiento de recibos
Service Bindings para comunicación Worker-a-Worker

Identidad opcional respaldada por ledger

XAIP no es un protocolo blockchain ni una vía de pago.

El modelo de identidad actual admite múltiples métodos DID, incluidos did:key, did:web e identificadores respaldados por ledger como did:xrpl. Las puntuaciones de confianza se derivan de recibos de ejecución firmados, no de tenencias de tokens, pagos ni afiliación a cadenas.

Los priors predeterminados a continuación son política de despliegue, no una afirmación universal sobre la confianza:

Método DID	Prior predeterminado	Caso de uso
`did:xrpl`	[5, 1]	Agentes respaldados por ledger (una opción anclada externamente)
`did:web`	[2, 1]	Servidores verificados por dominio
`did:key`	[1, 1]	Agentes anónimos / nuevos

Las identidades respaldadas por ledger pueden ser útiles cuando un agente necesita una identidad anclada externamente. XAIP en sí no requiere ningún ledger.

Datos

Las puntuaciones de confianza se calculan a partir de datos de ejecución reales, no de benchmarks sintéticos:

~4,500 recibos firmados en 10 servidores MCP puntuados al 2026-06-12: context7, sequential-thinking, memory, filesystem, everything, fetch, sqlite, git, puppeteer, playwright
Recopilación de datos diaria automatizada mediante GitHub Actions
Las puntuaciones se actualizan con cada nuevo recibo de ejecución; consulta el dashboard/API en vivo para ver los valores actuales

# See all scored servers
curl https://xaip-trust-api.kuma-github.workers.dev/v1/servers

Funciona con

Runtime / integración	Estado	Cómo
MCP (Model Context Protocol)	Dataset público en vivo (10 servidores, ~4,500 recibos firmados al 2026-06-12)	`xaip-claude-hook`, `xaip-sdk`, `xaip-mcp-trust`
LangChain.js	Vista previa probada + recibos en vivo integrados	`xaip-langchain` manejador de callback
Bucles de llamada a herramientas compatibles con OpenAI	Vista previa probada + recibos en vivo integrados	`xaip-openai` wrapper
Herramientas HTTP / A2A / runtimes propietarios	Flujo de recibos compatible	`xaip-sdk` o emisión directa de recibos firmados

El esquema de recibos es intencionalmente agnóstico respecto al sistema de herramientas: agentDid, callerDid, taskHash, resultHash, success, latencyMs, failureType, timestamp. Cualquier framework de agentes que pueda generar hashes de entradas/salidas y firmar con Ed25519 puede contribuir recibos.

Consulta Emitir recibos XAIP desde cualquier cosa para el flujo de recibos neutral respecto al proveedor.

Estado

v0.4.0 en vivo; borrador v0.5 en desarrollo (taxonomía de clases de herramientas + infraestructura de observación/visualización).

Internet-Draft

El formato de transmisión de recibos XAIP se publica como un Internet-Draft individual en IETF Datatracker:

draft-xkumakichi-xaip-receipts-03 (revisión actual; copia de trabajo)
https://datatracker.ietf.org/doc/draft-xkumakichi-xaip-receipts/
Vectores de prueba de conformidad ejecutables: docs/spec/test-vectors/ — cada hash, payload canónico y firma es real; node check.mjs los re-deriva todos (Node ≥ 18, sin dependencias)

Este es un Internet-Draft individual. No es un estándar IETF, no está aprobado por IETF y no tiene estatus formal en el proceso de estándares de IETF. El alcance del borrador es únicamente el formato de transmisión de recibos — la puntuación, la agregación y la lógica de decisión son política de despliegue y quedan fuera del alcance del propio borrador.

Citar como (trabajo en progreso — cita la revisión específica para reproducibilidad):

xkumakichi, "Signed Execution Receipts for AI Agent Tool Calls (XAIP Receipts)", Work in Progress, Internet-Draft, draft-xkumakichi-xaip-receipts-03, 2 July 2026, https://datatracker.ietf.org/doc/draft-xkumakichi-xaip-receipts/.

Las exportaciones BibTeX y BibXML están disponibles en la página de Datatracker enlazada arriba.

Publicaciones

Portable Trust — por qué la infraestructura de confianza para agentes de IA debe ser neutral respecto al proveedor y derivada del comportamiento (dev.to · Zenn 日本語版)
Evidence Before Payment — la pila de pagos de agentes describe la transacción en cuestión; la evidencia portable de la ejecución previa de una contraparte sigue siendo escasa. Define ese problema de diseño, independiente de cualquier implementación (artículo)

Relacionados

xaip-caller — CLI sin instalación: npx xaip-caller para contribuir al grafo de confianza
xaip-mcp-trust — servidor MCP para que los agentes de IA consulten puntuaciones de confianza
xaip-langchain — manejador de callback de LangChain.js que emite recibos XAIP
xaip-openai — wrapper de llamada a herramientas de OpenAI con recibos firmados
Veridict — experimento anterior de registro de ejecución en runtime que informó el diseño de recibos primero de XAIP. Publicado previamente como paquete npm; no se mantiene como producto independiente.
Especificación XAIP v0.4 — Especificación actual del protocolo
Especificación XAIP v0.5 RC — Candidato de lanzamiento (taxonomía de clases de herramientas)

Licencia

MIT