KLAIM

API de verificación humana de pago por uso para agentes de IA

Verifica usuarios sin exponer sus documentos.

KLAIM es una infraestructura de verificación centrada en la privacidad que permite a aplicaciones y agentes de IA verificar afirmaciones sobre un usuario — como Edad > 18 — sin recibir los documentos de identidad subyacentes ni los PII sin procesar del usuario.

🚀 ¿Qué es KLAIM?

Las aplicaciones modernas necesitan cada vez más verificar que un usuario es elegible para un servicio.

Por ejemplo:

• ¿Tiene este usuario más de 18 años?

• ¿Es este usuario residente de un país concreto?

• ¿Posee este usuario una credencial válida?

• ¿Ha completado este usuario una verificación requerida?

• ¿Es esto un humano verificado?

El enfoque tradicional consiste en recopilar el documento de identidad real.

Eso crea un importante problema de privacidad.

Una aplicación puede necesitar saber únicamente:

Age > 18 = TRUE

pero en su lugar recibe:

Name
Date of Birth
Address
Aadhaar/PAN information
Document number
Issuer information
Full document

KLAIM cambia este modelo.

En lugar de que las aplicaciones reciban documentos, KLAIM expone una API de verificación humana de pago por uso.

La aplicación o el agente de IA pregunta:

"Is this person over 18?"

KLAIM realiza la verificación internamente y devuelve:

{
  "verified": true,
  "claim": "AGE_OVER_18"
}

La credencial subyacente y la información personal permanecen privadas.

KLAIM vende verificación, no datos de identidad.

Related MCP server: AgentStamp

🔗 Transacciones verificadas en Algorand Testnet

KLAIM utiliza el protocolo de pago x402 para habilitar la verificación humana de pago por uso.

Para el MVP, los pagos se liquidan en USDC en Algorand Testnet. Las siguientes transacciones son transferencias reales en cadena desde la cartera del pagador → cartera del proveedor, cada una representando un pago de verificación de 0,01 USDC.

Estos no son ID de transacción simulados. Son transacciones reales de Algorand Testnet y pueden verificarse de forma independiente mediante el explorador AlgoKit Lora.

Evidencia de pago x402 en vivo

Qué demuestra esto

La capa de pago está diseñada en torno al siguiente flujo:

AI Agent
   │
   │ MCP tool call
   ▼
KLAIM Verification API
   │
   │ No payment
   ▼
HTTP 402 Payment Required
   │
   │ x402 payment requirements
   ▼
AI Agent / Payer Wallet
   │
   │ Sign USDC payment
   ▼
GoPlausible Facilitator
   │
   │ Verify + settle
   ▼
Algorand Testnet
   │
   │ Real USDC transaction
   ▼
Provider Wallet
   │
   │ Settlement confirmed
   ▼
KLAIM Verification
   │
   ▼
Verified Claim
---

# 🎯 Problem

Digital onboarding and AI-agent workflows have three major problems.

### 1. Over-collection of personal information

Applications collect complete identity documents even when they only need one attribute.

### 2. AI agents cannot easily perform trusted identity verification

AI agents can interact with APIs and tools, but identity verification still requires manual document workflows.

### 3. Verification APIs are not naturally machine-payable

Traditional verification providers usually depend on subscriptions, accounts, billing systems, or manual payment workflows.

KLAIM combines:

* **MCP** for AI-agent interoperability
* **x402** for machine-to-machine payments
* **Algorand** for on-chain settlement
* **DID / VC** for identity
* **Zero-Knowledge Proofs** for privacy-preserving verification

into a single verification infrastructure layer.

---

# 💡 The Core Idea

KLAIM separates identity from verification.

### Traditional Verification

```text
User
 │
 │ Upload document
 ▼
Application
 │
 ├── Name
 ├── DOB
 ├── Address
 ├── ID Number
 └── Full Document

Arquitectura de KLAIM

User
 │
 │ Credential + Consent
 ▼
KLAIM
 │
 │ Verify privately
 │
 │ ZK Proof
 ▼
Application / AI Agent
 │
 └── "AGE > 18 = TRUE"

La aplicación recibe la respuesta, no el documento.

🏗️ Arquitectura

flowchart TD

    H[Human User]

    DL[DigiLocker / Credential Issuer]

    DID[DID + Verifiable Credential]

    H -->|Consent| DL
    DL -->|Credential| DID

    A[AI Agent<br/>Claude / GPT / Custom Agent]

    MCP[KLAIM MCP Server]

    X402[x402 Payment Middleware]

    FAC[GoPlausible Facilitator]

    ALGO[Algorand Testnet]

    API[Verification API]

    PA[Provider Agent<br/>Strands]

    ZK[ZK Proof Engine<br/>Midnight-ready]

    RESULT[Verified Claim<br/>No Raw PII]

    A -->|MCP Tool Call| MCP
    MCP --> API

    API --> X402

    X402 -->|402 Payment Required| A

    A -->|USDC Payment| X402

    X402 --> FAC
    FAC --> ALGO

    ALGO -->|Settlement TX| X402

    X402 --> API

    API --> PA

    PA -->|Check DID| DID
    PA -->|Check Credential| DID
    PA -->|Check Claim| DID

    PA --> ZK

    ZK --> RESULT

    RESULT --> API
    API --> MCP
    MCP --> A

🔄 Flujo de verificación completo

1. Incorporación del humano

El usuario conecta su fuente de credenciales de identidad.

Para el MVP, DigiLocker es la fuente de credenciales prevista.

Human
  │
  ▼
DigiLocker
  │
  ▼
Credential
  │
  ▼
KLAIM DID

KLAIM almacena referencias de credenciales y afirmaciones derivadas en lugar de exponer documentos de identidad completos a los consumidores de verificación.

2. El agente de IA se conecta mediante MCP

Los agentes de IA se conectan a KLAIM a través del Protocolo de Contexto de Modelo (MCP).

Claude / GPT / Custom Agent
            │
            │ MCP
            ▼
     KLAIM MCP Server

El servidor MCP expone herramientas de verificación como:

verify_human_age

Por tanto, un agente puede solicitar:

Verify whether DID xyz is over 18.

3. Autenticación del agente

Cada verificador recibe una credencial de agente KLAIM única.

Ejemplo:

Agent ID:
agent_xxxxxxxxx

Agent Key:
klm_xxxxxxxxxxxxxxxxx

La clave:

• la genera KLAIM

• se muestra una sola vez

• se almacena con hash

• es revocable

• es rotable

4. Solicitud de verificación

La herramienta MCP llama a la API de verificación protegida.

POST /api/v1/verify/age

Ejemplo:

{
  "did": "did:klaim:demo-user-001"
}

5. Límite de pago x402

La API de verificación está protegida por x402.

Si no se adjunta ningún pago válido:

HTTP/1.1 402 Payment Required

La capa x402 proporciona los requisitos de pago necesarios para el cliente.

El flujo pasa a ser:

AI Agent
   │
   │ POST /verify/age
   ▼
KLAIM
   │
   │ HTTP 402
   ▼
AI Agent
   │
   │ Prepare payment
   ▼
x402

6. Pago en USDC

El agente verificador paga la verificación usando USDC en Algorand Testnet.

AI Agent
    │
    │ USDC
    ▼
x402
    │
    ▼
GoPlausible Facilitator
    │
    ▼
Algorand Testnet

El pago se liquida en cadena.

Una verificación correcta contiene el ID de transacción de liquidación.

Ejemplo:

{
  "payment": {
    "txId": "REAL_ALGORAND_TX_ID",
    "explorerUrl": "https://lora.algokit.io/testnet/transaction/..."
  }
}

7. Agente proveedor

Solo después de que la liquidación del pago se realice correctamente se ejecuta el pipeline de verificación.

El Agente Proveedor de KLAIM está diseñado en torno al Strands Agents SDK, con un respaldo determinista para el MVP.

El pipeline de verificación es:

check_did
    ↓
check_credential
    ↓
check_claim
    ↓
generate_zk_proof
    ↓
verify_zk_proof

Invariante crítico

NO PAYMENT
     ↓
NO VERIFICATION

La lógica de negocio de verificación no se ejecuta antes de que el límite de pago tenga éxito.

8. Verificación de credenciales

El Agente Proveedor comprueba si la credencial solicitada existe para el DID del usuario.

Por ejemplo:

Requested:

AGE > 18

Available:

DigiLocker Credential
       │
       └── DOB available

La afirmación requerida se deriva internamente.

La fecha de nacimiento real nunca se devuelve al verificador.

9. Verificación de conocimiento cero

KLAIM sigue un principio simple:

Demuestra la afirmación sin revelar los datos subyacentes.

En lugar de exponer:

Date of Birth:
12/03/2002

KLAIM pretende producir una prueba de:

AGE > 18

El verificador solo necesita:

verified = true

La arquitectura contiene una capa de abstracción ZK diseñada para conectarse con un prover de Midnight.

Arquitectura actual del MVP:

ZK Service
    │
    ├── Local / deterministic engine
    │
    └── Midnight prover integration point

El sistema identifica explícitamente el motor de prueba en lugar de presentar falsamente una simulación local como criptografía ZK de producción.

🔐 Modelo de privacidad

KLAIM sigue una arquitectura de divulgación mínima.

Datos que permanecen privados

Name
Date of Birth
Address
Aadhaar
PAN
Document Number
Raw Identity Document

Datos devueltos

Verification Result
Claim
Proof Descriptor
Payment Receipt
Algorand Transaction ID

Ejemplo:

{
  "verified": true,
  "claim": "AGE_OVER_18",
  "proof": {
    "type": "zk",
    "notDisclosed": [
      "date_of_birth",
      "name",
      "address",
      "document"
    ]
  }
}

🤖 Arquitectura de agentes de IA

KLAIM está diseñado específicamente para la verificación máquina a máquina.

sequenceDiagram

    participant C as Claude / AI Agent
    participant M as KLAIM MCP
    participant API as Verification API
    participant X as x402
    participant F as GoPlausible
    participant A as Algorand
    participant P as Provider Agent
    participant Z as ZK Engine

    C->>M: verify_human_age(DID)

    M->>API: POST /verify/age

    API->>X: Check payment

    X-->>C: HTTP 402 + requirements

    C->>X: Signed USDC payment

    X->>F: Verify + settle

    F->>A: Algorand Testnet settlement

    A-->>F: Transaction ID

    F-->>X: Settlement successful

    X->>API: Payment verified

    API->>P: Start verification

    P->>P: Check DID

    P->>P: Check credential

    P->>P: Evaluate claim

    P->>Z: Generate / verify proof

    Z-->>P: Proof

    P-->>API: Verified claim

    API-->>M: Result + TX ID

    M-->>C: Verified claim

🧩 ¿Por qué MCP?

Sin MCP, cada agente de IA requeriría una integración KLAIM personalizada.

Claude → Custom SDK
GPT → Custom SDK
Agent X → Custom SDK
Agent Y → Custom SDK

Con MCP:

Claude
GPT
Custom Agent
     │
     ▼
    MCP
     │
     ▼
   KLAIM

KLAIM se convierte en una capacidad de verificación reutilizable que los agentes de IA pueden descubrir e invocar.

💰 ¿Por qué x402?

x402 permite pagos de máquina nativos de HTTP.

El agente no necesita:

• suscripciones

• proceso de compra manual

• formularios de tarjeta de crédito

• intervención humana de facturación

En su lugar:

Request
   ↓
402
   ↓
Pay
   ↓
Retry
   ↓
Verification

Esto crea un modelo natural para APIs de pago por verificación.

🌐 ¿Por qué Algorand?

Algorand se utiliza como red de liquidación para el MVP porque proporciona:

• liquidación rápida

• costes de transacción bajos

• soporte de USDC

• infraestructura de testnet accesible

• transacciones verificables de forma independiente

El recibo de pago puede inspeccionarse en Algorand Testnet.

⭐ Propuesta única de venta

KLAIM no es otro panel de identidad.

KLAIM es una capa de infraestructura de verificación para agentes de IA.

Verificación de identidad tradicional

Application
     │
     ▼
Identity Provider
     │
     ▼
Upload Document
     │
     ▼
PII Processing
     │
     ▼
Verification

KLAIM

AI Agent
   │
   ▼
MCP
   │
   ▼
x402 Payment
   │
   ▼
KLAIM
   │
   ├── DID / Credential
   ├── Provider Agent
   └── ZK Proof
          │
          ▼
   Boolean Verification

La diferencia clave

KLAIM vende verificación, no datos de identidad.

👥 Roles de producto

Humano

El humano controla su identidad.

Capacidades:

• Crear / gestionar DID

• Conectar credenciales

• Ver credenciales

• Eliminar credenciales

• Gestionar permisos de verificación

• Ver historial de verificación

El humano no paga por la verificación.

Verificador

El verificador representa una aplicación o un agente de IA.

Capacidades:

• Crear agentes de IA

• Generar credenciales MCP

• Rotar / revocar claves de agente

• Conectar MCP a Claude

• Solicitar verificación

• Supervisar pagos x402

• Ver historial de transacciones

• Ver actividad de verificación

🔑 Autenticación de agentes

KLAIM genera credenciales únicas para los agentes verificadores.

Ejemplo:

Agent ID
agent_xxxxxxxxx

Agent Key
klm_xxxxxxxxxxxxxxxxx

La clave sin procesar se muestra una sola vez.

KLAIM almacena un hash SHA-256 de la clave.

Agent Key
    │
    ▼
 SHA-256
    │
    ▼
Stored Hash

🏗️ Estructura del proyecto

KLAIM/
│
├── src/
│   ├── routes/
│   │   ├── api/
│   │   │   ├── public/
│   │   │   │   └── mcp.ts
│   │   │   │
│   │   │   └── v1/
│   │   │       ├── verify/
│   │   │       │   └── age.ts
│   │   │       ├── agents.ts
│   │   │       ├── credentials.ts
│   │   │       ├── digilocker.ts
│   │   │       ├── integrations.ts
│   │   │       └── transactions.ts
│   │   │
│   │   ├── human.*
│   │   ├── verifier.*
│   │   └── index.tsx
│   │
│   ├── lib/
│   │   └── klaim/
│   │       ├── server/
│   │       │   ├── mcp.server.ts
│   │       │   ├── x402.server.ts
│   │       │   ├── provider-agent.server.ts
│   │       │   ├── zkp.server.ts
│   │       │   ├── digilocker.server.ts
│   │       │   ├── store.server.ts
│   │       │   └── env.server.ts
│   │       │
│   │       ├── api.ts
│   │       ├── services.ts
│   │       ├── types.ts
│   │       └── mock-data.ts
│   │
│   └── components/
│       ├── app/
│       ├── ui/
│       └── klaim-landing.tsx
│
├── scripts/
│   ├── provision-agent.ts
│   └── test-x402.ts
│
├── tests/
│   └── mcp-x402-flow.test.ts
│
├── .env.example
├── package.json
└── README.md

🛠️ Pila tecnológica

🧪 Ejecución local

Requisitos

Instala:

• Node.js o Bun

• Git

• Claude Desktop (opcional para pruebas de MCP)

Clona el repositorio:

git clone <YOUR_GITHUB_REPOSITORY_URL>
cd KLAIM

Instala las dependencias:

npm install

o:

bun install

Crea tu archivo de entorno:

cp .env.example .env

Inicia el servidor de desarrollo:

npm run dev

La aplicación estará disponible en:

http://localhost:8080

🔌 Pruebas de MCP

El endpoint de MCP es:

http://localhost:8080/api/public/mcp

El servidor MCP admite:

initialize
ping
tools/list
tools/call

La herramienta de verificación principal es:

verify_human_age

🤖 Conectar Claude Desktop

Después de aprovisionar un agente verificador KLAIM, configura Claude Desktop con:

{
  "mcpServers": {
    "klaim": {
      "type": "http",
      "url": "http://localhost:8080/api/public/mcp",
      "headers": {
        "X-KLAIM-Agent-Id": "YOUR_AGENT_ID",
        "Authorization": "Bearer YOUR_AGENT_KEY"
      }
    }
  }
}

Reinicia Claude Desktop.

Después pregunta:

Use KLAIM to verify whether did:klaim:demo-user-001 is over 18.

Claude debería descubrir e invocar:

verify_human_age

💳 Pruebas de x402

Configura las carteras de Algorand Testnet requeridas.

El flujo completo es:

POST /api/v1/verify/age
        │
        ▼
HTTP 402
        │
        ▼
Payment Requirements
        │
        ▼
USDC Payment
        │
        ▼
GoPlausible
        │
        ▼
Algorand Testnet
        │
        ▼
Settlement TX
        │
        ▼
Provider Agent
        │
        ▼
Verification
        │
        ▼
HTTP 200

Ejecuta el cliente de prueba x402 independiente:

npm run test:x402

Un resultado correcto debería contener un ID de transacción real de Algorand Testnet.

🔎 Transacción de Algorand Testnet

Una transacción x402 de KLAIM correcta puede verificarse de forma independiente usando Lora.

Ejemplo

Reemplaza el marcador de posición siguiente con una transacción real generada por el proyecto:

https://lora.algokit.io/testnet/transaction/YOUR_REAL_TX_ID

Importante: El enlace de transacción anterior debe reemplazarse con una transacción KLAIM real antes de la entrega final.

🧪 Flujo de demostración completo

Ejecuta el sistema en el siguiente orden.

Terminal 1 — Iniciar KLAIM

npm run dev

Terminal 2 — Aprovisionar un agente

npx tsx scripts/provision-agent.ts

Almacena el:

KLAIM_AGENT_ID
KLAIM_AGENT_KEY

generado en el entorno/la configuración correspondiente.

Terminal 3 — Ejecutar prueba x402

npm run test:x402

Después conecta Claude Desktop a:

/api/public/mcp

Pregunta a Claude:

Verify whether the user is over 18 using KLAIM.

Arquitectura esperada:

Claude
   ↓
MCP
   ↓
KLAIM
   ↓
HTTP 402
   ↓
USDC Payment
   ↓
GoPlausible
   ↓
Algorand Testnet
   ↓
Provider Agent
   ↓
Credential Verification
   ↓
ZK Proof
   ↓
Verified Claim
   ↓
Claude

🔐 Seguridad y privacidad

KLAIM está diseñado en torno a la minimización de datos.

KLAIM no expone:

❌ Aadhaar number
❌ PAN number
❌ Date of Birth
❌ Address
❌ Raw identity document
❌ Private wallet keys
❌ Agent private credentials

KLAIM expone:

✓ Verification result
✓ Claim
✓ Proof metadata
✓ Payment receipt
✓ Algorand transaction ID

⚠️ Estado del MVP

KLAIM es actualmente una implementación de MVP / hackathon.

La arquitectura separa intencionadamente las integraciones de producción detrás de interfaces de servicio.

Implementado

• Separación de roles Humano / Verificador

• Modelo de identidad orientado a DID

• Gestión de credenciales

• Servidor MCP

• Autenticación MCP

• Descubrimiento de herramientas MCP

• API de verificación

• Límite de pago x402

• Flujo de liquidación en Algorand Testnet

• Integración del facilitador GoPlausible

• Arquitectura del Agente Proveedor

• Punto de integración de Strands

• Abstracción ZK

• Interfaz de integración de DigiLocker

• Aprovisionamiento de agentes

• Rotación / revocación de claves de agente

• Historial de verificación

• Historial de transacciones

Dependiente de integración

DigiLocker production credentials
        ↓
Official DigiLocker OAuth / issuer integration

Midnight prover
        ↓
MIDNIGHT_PROVER_URL

Strands / Bedrock
        ↓
AWS credentials + model configuration

Estas integraciones pueden habilitarse sin cambiar la arquitectura central de MCP y x402.

🚀 Hoja de ruta

Fase 1 — MVP

✓ MCP
✓ x402
✓ Algorand Testnet
✓ USDC settlement
✓ Agent authentication
✓ Credential abstraction
✓ Provider Agent
✓ Verification API
✓ ZK abstraction

Fase 2 — Identidad de producción

DigiLocker production integration
        ↓
Verifiable Credentials
        ↓
DID interoperability

Fase 3 — ZK de producción

Midnight prover
        ↓
Cryptographically verifiable claims

Fase 4 — Economía de agentes

KLAIM puede convertirse en un mercado de verificación de propósito general para agentes autónomos.

APIs potenciales:

verify_age
verify_residency
verify_credential
verify_student_status
verify_business_registration
verify_human

Cada verificación se convierte en una API pagable por máquina.

🌍 Casos de uso

Aplicaciones con restricción de edad

AI Agent
   ↓
KLAIM
   ↓
AGE > 18

No se expone la fecha de nacimiento.

Onboarding financiero

AI Agent
   ↓
KLAIM
   ↓
Credential Valid

La aplicación no necesita el documento de identidad completo.

Educación

AI Agent
   ↓
KLAIM
   ↓
Student Credential = TRUE

Servicios solo para humanos

AI Agent
   ↓
KLAIM
   ↓
Human Verification

🏆 ¿Por qué KLAIM?

La mayoría de los sistemas de identidad preguntan:

"¿Quién es esta persona?"

KLAIM pregunta:

"¿Puedo verificar lo único que necesito saber sin ver todo lo demás?"

KLAIM combina:

Privacy-Preserving Verification
            +
AI Agent Interoperability
            +
Pay-Per-Use Payments
            +
Zero-Knowledge Architecture
            +
On-Chain Settlement

en una única API de verificación.

📜 Licencia

MIT

KLAIM

Infraestructura de verificación humana para la economía de agentes

No envíes el documento.

Demuestra la afirmación.