XAIP

Dê aos agentes de IA uma identidade persistente on-chain no XRPL — DIDs, credenciais, pontuações de reputação, custódia e Memory Chain.

GitHub

Experimente este MCPPatrocinado

Documentação

XAIP — Recibos de Execução Assinados para Chamadas de Ferramentas de Agentes de IA

Evidência antes da delegação. Envolva as chamadas de ferramentas de um agente uma vez; use o histórico de recibos localmente hoje e compartilhe os mesmos recibos assinados depois como evidência portátil e verificável de forma independente.

XAIP é uma camada de evidência de execução assinada, neutra em relação ao provedor, para chamadas de ferramentas de agentes de IA. Ela registra recibos co-assinados — tanto o agente executor quanto o chamador assinam o mesmo registro canônico, então nenhum dos lados pode fabricá-lo unilateralmente — em MCP, LangChain.js, loops de chamada de ferramentas compatíveis com OpenAI e outros runtimes, e depois expõe evidências históricas de execução que agentes, desenvolvedores ou camadas de política podem inspecionar antes da delegação.

Os recibos são o artefato principal. As pontuações de confiança são uma visão derivada desses recibos — não uma afirmação de segurança ou correção absoluta.

XAIP em 30 segundos

Mecanismo — uma chamada de ferramenta entra, um recibo sai. O agente executor e o chamador assinam o mesmo registro canônico (Ed25519 sobre JCS), então nenhum dos lados pode fabricá-lo ou repudiá-lo unilateralmente. Apenas hashes de entrada/saída são transportados; o conteúdo nunca sai da sua máquina.
O que você obtém no primeiro dia — um histórico verificável do que as ferramentas do seu próprio agente realmente fizeram, consultável antes da próxima delegação (precheck()). Útil em modo single-player; não requer uma rede de outros usuários.
O que XAIP não é — não é um sandbox, não é um mecanismo de aprovação, não é um trilho de pagamento, não é uma garantia de segurança. Ele torna a evidência de execução visível; você decide no que confiar.

Escolha sua profundidade: 3 minutos — produza seu primeiro recibo assinado · 10 minutos — verifique o formato você mesmo: execute os vetores de conformidade executáveis (node check.mjs, sem dependências) e depois leia o Internet-Draft que ele fixa.

Demonstração ao vivo: três servidores candidatos, comparação lado a lado sem e com XAIP. Abrir no navegador →

Neutro em relação ao provedor por design. XAIP é uma camada de confiança para qualquer agente que use ferramentas. A implementação de referência e os dados ao vivo começam com MCP (Model Context Protocol) — porque é onde existe hoje a maior frota de servidores públicos de ferramentas — mas o formato de recibo, a assinatura e a pontuação se aplicam igualmente a ferramentas LangChain, function calling da OpenAI, A2A e stacks proprietárias de agentes. MCP é a primeira integração, não a única.

Painel ao vivo: https://xkumakichi.github.io/xaip-protocol/ — pontuações públicas atuais de confiança, atualização automática, sem autenticação. O conjunto de dados público atual é pesado em MCP porque MCP foi o primeiro alvo de integração.

Pontos de entrada

Evidência de Confiança Antes da Delegação — demonstração de uma tela, POST /v1/select ao vivo contra três candidatos contrastantes.
Demonstração de Evidência Antes do Pagamento — demonstração de uma tela: o que um agente vê sobre uma skill fechada paga antes de pagar, com vs sem evidência de execução de precheck() (três candidatos fictícios, fixture semeada).
Playground no navegador — demonstração somente leitura de seleção consciente de confiança.
Visão geral de 60 segundos — o problema que XAIP tenta resolver.
Direção futura — hipótese de longo prazo, perguntas em aberto e solicitações de pesquisa atuais.
Estudo de caso de dominância de chamador único — um modo de falha real identificado no próprio conjunto de dados público da XAIP em 2026-05-13 e o que isso implica para a diversidade de chamadores.
Design do Agent Trust Check — conceito de diagnóstico planejado.
Design de pontuação ciente de classe — nota de design futura; não é comportamento de pontuação ao vivo.
Emitir recibos de qualquer coisa — como produzir recibos XAIP de qualquer sistema de ferramentas.
Guia da API precheck() — auxiliar do SDK para evidência de execução antes da delegação.
Executar xaip-caller — contribua com recibos assinados sem executar MCP.

Experimente Agora

A API está no ar. Sem cadastro, sem chave 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"]}'

A resposta /v1/select informa qual servidor usar, por quê e o que aconteceria sem 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"
}

O Problema

Sem pontuações de confiança, seu 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 ajuda agentes a preferir candidatos com evidência de execução disponível mais forte, pular candidatos sem pontuação quando apropriado e reduzir chamadas com falha evitáveis.

Como 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 execução é assinado e verificado com Ed25519. As pontuações de confiança são calculadas usando um modelo bayesiano com ponderação de diversidade de chamadores — não métricas auto-relatadas.

Início Rápido — seu primeiro recibo assinado em menos de 5 minutos

O caminho mais rápido é o hook do Claude Code: suas chamadas normais de ferramentas MCP começam a produzir recibos assinados, com apenas hashes saindo da sua máquina. Medido de ponta a ponta em um perfil limpo do Windows 11 (Node 24, npm 11) — o tempo total de comando foi de cerca de 8 segundos; as etapas são idênticas no macOS/Linux.

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

(Replay de terminal renderizado a partir das saídas reais capturadas dessa medição — script gerador.)

1. Instalar

npm install -g xaip-claude-hook

2. Um 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. Uma chamada de ferramenta

Abra uma sessão nova do Claude Code e deixe-o chamar qualquer ferramenta MCP (por exemplo, peça para consultar uma biblioteca com context7). O hook assina e envia um recibo automaticamente — você não faz nada.

4. Um recibo assinado

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 é o agregador confirmando sua assinatura de chamador Ed25519 sobre o payload canônico do recibo. Apenas hashes e metadados (nome da ferramenta, latência, sucesso) foram enviados — nunca entradas, saídas ou caminhos de arquivo, e o log mostra exatamente o que saiu da máquina.

5. Um resultado de verificação

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. Um resultado de precheck — sem confiança 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 é o comportamento de cold start, mostrado honestamente: um servidor que ninguém executou é unscored, não recebe uma pontuação sintética. A evidência se acumula conforme os recibos chegam; XAIP não fabrica confiança para ferramentas sem histórico de execução.

Se algo não funcionar

O hook nunca dispara — o comando do hook deve ser resolvível quando o Claude Code o inicia: verifique se o diretório global de binários do npm (npm config get prefix) está em PATH e depois inicie uma sessão nova.
O PowerShell diz "running scripts is disabled" — a política de execução padrão do Windows bloqueia os shims .ps1 do npm para comandos interativos. Use xaip-claude-hook.cmd, execute a partir de cmd ou Set-ExecutionPolicy -Scope CurrentUser RemoteSigned. A emissão de recibos não é afetada (o hook roda via o shim .cmd).
Desativar — export XAIP_DISABLED=1 desativa temporariamente; xaip-claude-hook uninstall remove o hook (chaves/logs em ~/.xaip/ permanecem até você excluí-los). Os recibos são pseudônimos: seu DID de chamador é uma chave por instalação, não vinculada a mais nada.

Executar a demonstração de ponta a ponta

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

Esta demonstração:

Pede à XAIP para classificar servidores candidatos para "Fetch React hooks documentation" com base na evidência de execução disponível
Conecta-se ao servidor MCP selecionado e executa chamadas reais de ferramentas
Envia um recibo de execução assinado ao Agregador
Mostra a pontuação de confiança atualizada

Demonstração de qualidade de decisão

Compare estratégias de seleção às cegas contra a seleção guiada por XAIP usando um snapshot estático de confiança e conjuntos fixos de candidatos:

cd demo
npm run blind-vs-xaip

Este é um replay local determinístico. Ele não executa ferramentas ao vivo, não publica recibos nem chama nenhuma API externa. Consulte docs/blind-vs-xaip-demo.md para escopo, métricas e limitações.

No replay do snapshot incluído:

Estratégia	Taxa de escolha arriscada	Taxa de escolha elegível
Aleatória	71.4%	28.6%
Ordem fixa	85.7%	14.3%
XAIP	14.3%	85.7%

risky_pick = o candidato selecionado era low_trust ou unscored no snapshot. fixed-order modela um agente que aceita a ordem de candidatos do planejador upstream sem dados de confiança em tempo de execução. A afirmação é limitada a este conjunto fixo de candidatos e snapshot estático de confiança — não é uma garantia de melhoria de execução no mundo real.

Torne-se um chamador independente

Quer que o grafo de confiança dependa de mais de um operador? Execute um chamador você mesmo. Sem conta, sem aprovação, sem chave de API — o agregador verifica assinaturas de qualquer par de chaves válido.

Mais rápido — zero instalação, 30 segundos:

npx xaip-caller

Assina recibos para algumas chamadas reais de ferramentas HTTP e as envia via POST. Demonstra que XAIP funciona além do MCP — qualquer ferramenta HTTP pode participar. Consulte clients/caller. Consulte Run xaip-caller para notas sobre Windows e detalhes de contribuição de recibos externos.

Caminho completo — servidores MCP, 5 minutos:

Clone o repositório e execute o auto-coletor contra servidores MCP reais. Seu DID de chamador contribui para a diversidade de cada ferramenta MCP pontuada. Consulte docs/contributor/run-a-caller.md.

Usar o 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() é um wrapper fino do SDK sobre POST /v1/select. Ele retorna evidência de execução disponível para candidatos de ferramenta, skill ou agente antes de seu código decidir o que delegar.

Consulte o guia da API precheck() para limites, opções de política, formato de resultado e erros.

Servidor MCP

Use XAIP diretamente do Claude, Cursor ou qualquer agente de IA compatível com MCP:

npx xaip-mcp-trust

4 ferramentas: xaip_list_servers, xaip_check_trust, xaip_select, xaip_report

Adicionar ao Claude Code (~/.claude/claude_desktop_config.json):

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

npm: xaip-mcp-trust

Referência da API

Método	Endpoint	Descrição
`GET`	`/v1/servers`	Lista todos os servidores pontuados com dados de confiança
`GET`	`/v1/trust/:slug`	Pontuação de confiança para um único servidor pontuado
`GET`	`/v1/trust?slugs=a,b,c`	Pontuações de confiança em lote (máx. 50)
`POST`	`/v1/select`	Mecanismo de decisão — classifica candidatos pela evidência de execução disponível
`GET`	`/health`	Sonda de liveness

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

Resposta de Pontuação de Confiança

Campo	Tipo	Descrição
`trust`	`number \| null`	Pontuação 0.0–1.0, null se não pontuado
`verdict`	`string`	`trusted` ≥0.7 · `caution` 0.4–0.7 · `low_trust` <0.4 · `unscored`
`receipts`	`number`	Total de recibos de execução verificados
`confidence`	`number \| null`	Confiança estatística: min(1, recibos/100)
`riskFlags`	`string[]`	Indicadores de risco detectados
`computedFrom`	`string`	Descrição da proveniência dos dados

Mecanismo de Decisão (`POST /v1/select`)

Solicitação:

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

mode: "relative" (padrão) — sempre seleciona o melhor disponível, mesmo se abaixo do limite
mode: "strict" — rejeita todos os candidatos abaixo do limite de cautela

Arquitetura

┌──────────────────────────────────────────────────────────┐
│  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 Confiança:

Distribuição Beta bayesiana (prior varia por método de DID)
Ponderação de diversidade de chamadores (impede manipulação por chamador único)
Fator de co-assinatura (Ed25519 duplo: agente + chamador)
Federação com capacidade BFT com detecção de outliers MAD entre nós agregadores; a implantação pública atual é um nó agregador único (as respostas da API dizem single aggregator; a menção a quórum aparece apenas em implantações reais de múltiplos nós)

Infraestrutura:

Cloudflare Workers (edge global, latência <50ms)
Cloudflare D1 (SQLite no edge) para armazenamento de recibos
Service Bindings para comunicação Worker-a-Worker

Identidade Opcional com Ledger

XAIP não é um protocolo de blockchain nem um trilho de pagamento. O modelo de identidade atual suporta múltiplos métodos DID, incluindo did:key, did:web e identificadores baseados em ledger, como did:xrpl. As pontuações de confiança são derivadas de recibos de execução assinados — não de posse de tokens, pagamentos ou afiliação a cadeias.

Os priors padrão abaixo são política de implantação, não uma afirmação universal sobre confiança:

Método DID	Prior Padrão	Caso de Uso
`did:xrpl`	[5, 1]	Agentes baseados em ledger (uma opção com ancoragem externa)
`did:web`	[2, 1]	Servidores verificados por domínio
`did:key`	[1, 1]	Agentes anônimos / novos

Identidades baseadas em ledger podem ser úteis quando um agente precisa de uma identidade com ancoragem externa. O próprio XAIP não exige nenhum ledger.

Dados

As pontuações de confiança são calculadas a partir de dados reais de execução, não de benchmarks sintéticos:

~4.500 recibos assinados em 10 servidores MCP avaliados em 2026-06-12: context7, sequential-thinking, memory, filesystem, everything, fetch, sqlite, git, puppeteer, playwright
Coleta automatizada de dados diários via GitHub Actions
As pontuações são atualizadas a cada novo recibo de execução; consulte o dashboard/API ao vivo para valores atuais

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

Funciona Com

Runtime / integração	Status	Como
MCP (Model Context Protocol)	Conjunto de dados público ativo (10 servidores, ~4.500 recibos assinados em 2026-06-12)	`xaip-claude-hook`, `xaip-sdk`, `xaip-mcp-trust`
LangChain.js	Prévia testada + recibos ao vivo integrados	`xaip-langchain` callback handler
Loops de chamada de ferramentas compatíveis com OpenAI	Prévia testada + recibos ao vivo integrados	`xaip-openai` wrapper
Ferramentas HTTP / A2A / runtimes proprietários	Fluxo de recibos suportado	`xaip-sdk` ou emissão direta de recibos assinados

O esquema de recibos é intencionalmente agnóstico em relação ao sistema de ferramentas: agentDid, callerDid, taskHash, resultHash, success, latencyMs, failureType, timestamp. Qualquer framework de agentes que consiga gerar hash de entradas/saídas e assinar com Ed25519 pode contribuir com recibos.

Consulte Emita recibos XAIP de qualquer coisa para o fluxo de recibos neutro em relação ao provedor.

Status

v0.4.0 ativa; rascunho v0.5 em desenvolvimento (taxonomia de classes de ferramentas + infraestrutura de observação/exibição).

Internet-Draft

O formato de transmissão (wire format) dos recibos XAIP é publicado como um Internet-Draft individual no IETF Datatracker:

draft-xkumakichi-xaip-receipts-03 (revisão atual; cópia de trabalho)
https://datatracker.ietf.org/doc/draft-xkumakichi-xaip-receipts/
Vetores de teste de conformidade executáveis: docs/spec/test-vectors/ — cada hash, payload canônico e assinatura é real; node check.mjs rederiva todos eles (Node ≥ 18, sem dependências)

Este é um Internet-Draft individual. Não é um padrão IETF, não é aprovado pelo IETF e não tem status formal no processo de padronização do IETF. O escopo do rascunho é apenas o formato de transmissão dos recibos — pontuação, agregação e lógica de decisão são política de implantação e estão fora do escopo do próprio rascunho.

Citar como (trabalho em andamento — cite a revisão específica para reprodutibilidade):

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

As exportações BibTeX e BibXML estão disponíveis na página do Datatracker vinculada acima.

Artigos

Portable Trust — por que a infraestrutura de confiança para agentes de IA deve ser neutra em relação ao provedor e derivada do comportamento (dev.to · Zenn 日本語版)
Evidence Before Payment — a pilha de pagamento de agentes descreve a transação em questão; a evidência portátil da execução anterior de uma contraparte permanece escassa. Define esse problema de design, independente de qualquer implementação específica (artigo)

Relacionados

xaip-caller — CLI sem instalação: npx xaip-caller para contribuir com o grafo de confiança
xaip-mcp-trust — servidor MCP para agentes de IA verificarem pontuações de confiança
xaip-langchain — callback handler LangChain.js que emite recibos XAIP
xaip-openai — wrapper de chamada de ferramentas OpenAI com recibos assinados
Veridict — experimento anterior de registro de execução em runtime que informou o design centrado em recibos do XAIP. Publicado anteriormente como pacote npm; não mantido como produto independente.
Especificação XAIP v0.4 — Especificação atual do protocolo
Especificação XAIP v0.5 RC — Candidato a lançamento (taxonomia de classes de ferramentas)

Licença

MIT