Lightning Faucet MCP Server

oficial

Proporciona a los agentes de IA una billetera Bitcoin con pagos a través de Lightning Network.

Documentación

Lightning Wallet

Dale a tu agente de IA una billetera de Bitcoin. Servidor MCP + CLI. Funciona con Claude Code, OpenClaw, Cursor y cualquier framework de agentes.

Novedades en v1.4

Herramienta update_operator / lw set-email - establece el correo de tu operador desde el cliente MCP o CLI; se te envía un enlace de verificación.
Herramienta claim_promo / lw claim-promo - reclama la promoción de sats gratis por instalación directamente desde tu agente. Requisitos: correo verificado + cuenta de operador con al menos 3 horas de antigüedad.
get_info funciona antes del registro - la información del servicio ya no requiere una clave API.

100 sats gratis para nuevos operadores

lw register --email [email protected] (o la herramienta MCP register_operator con un correo electrónico)
Haz clic en el enlace de verificación que te enviamos por correo
Después de que tu cuenta tenga 3 horas de antigüedad: lw claim-promo (o la herramienta MCP claim_promo)

Un bono por operador, solo para las primeras 100 instalaciones, sin depósito requerido.

Novedades en v1.3

v1.3.0 - Soporte del protocolo L402 v0 según la última especificación de Lightning Labs.

Protocolo L402 v0 - Formato de cabecera actualizado: version="0", token=, compatible hacia atrás con macaroon=
Descubrimiento de Endpoints - .well-known/l402.json en lightningfaucet.com y certvera.com
Compatibilidad hacia atrás - Maneja tanto el formato antiguo como el nuevo de cabeceras L402 de cualquier servicio

Novedades en v1.1

v1.1.0 - Soporte del protocolo X402 (USDC en Base) como alternativa automática junto a L402 (Lightning).

Soporte X402 - Pagos automáticos en USDC en Base cuando L402 no está disponible
Detección automática de protocolo - pay_l402_api maneja sin problemas tanto L402 como X402
Webhooks - Notificaciones en tiempo real para pagos y eventos
Keysend - Envía pagos sin facturas usando claves públicas de nodos
Decodificación de facturas - Decodifica facturas BOLT11 antes de pagar
Analíticas de agente - Rastrea patrones de gasto y uso
Exportación de transacciones - Exporta el historial en formato JSON o CSV
Gestión de presupuesto - Obtén el estado detallado del presupuesto y establece límites
Ciclo de vida del agente - Desactiva, reactiva y elimina agentes
Recuperación de cuenta - Recupera cuentas y rota claves API
Transferencias entre agentes - Mueve fondos entre tus agentes

¿Por qué Lightning Wallet MCP?

Pagos instantáneos - Las transacciones en Lightning Network se liquidan en milisegundos
Soporte de protocolos L402 + X402 - Accede a cualquier API de pago automáticamente (Lightning o USDC)
Jerarquía Operador/Agente - Gestiona múltiples agentes con límites de gasto
Sin riesgo de custodia - Cada agente tiene fondos aislados con supervisión del operador
Listo para producción - Infraestructura probada en batalla que impulsa transacciones reales
Notificaciones por Webhook - Recibe notificaciones instantáneas cuando llegan pagos
Observabilidad completa - Analíticas, exportaciones y seguimiento detallado del estado

Dos formas de uso

CLI (Cualquier framework de agente)

Para agentes que priorizan CLI (OpenClaw, Pi, KiloCode, o cualquier agente con acceso a Bash):

npm install -g lightning-wallet-mcp

Esto instala el comando lw:

# Register and save your API key
export LIGHTNING_WALLET_API_KEY=$(lw register --name "My Bot" | jq -r '.api_key')

# Check balance
lw balance | jq '.balance_sats'

# Pay an L402 API
lw pay-api "https://lightningfaucet.com/api/l402/fortune"

# Create and fund an agent
lw create-agent "Research Bot" --budget 5000
lw fund-agent 1 1000

# Check identity
lw whoami

La salida es JSON por defecto (redirige a jq). Usa --human para una salida legible.

Ejecuta lw help para ver todos los comandos.

Servidor MCP (Claude Code, Cursor, Windsurf)

Para clientes nativos MCP, configúralo como un servidor MCP:

Opción A: Auto-registro

{
  "mcpServers": {
    "lightning-wallet": {
      "command": "npx",
      "args": ["lightning-wallet-mcp"]
    }
  }
}

Luego pídele a Claude: "Registra una nueva cuenta de operador de Lightning Wallet"

Opción B: Clave API preconfigurada

Obtén una clave API en lightningfaucet.com/ai-agents
Configura Claude Code (~/.claude/settings.json):

{
  "mcpServers": {
    "lightning-wallet": {
      "command": "npx",
      "args": ["lightning-wallet-mcp"],
      "env": {
        "LIGHTNING_WALLET_API_KEY": "your-api-key-here"
      }
    }
  }
}

Referencia de herramientas

Información del servicio

Herramienta	Descripción
`get_info`	Obtén el estado del servicio, versión y características soportadas
`decode_invoice`	Decodifica una factura BOLT11 para ver el monto, destino y expiración

Contexto e identidad

Herramienta	Descripción
`whoami`	Obtén el contexto actual - muestra si se opera como operador o agente
`check_balance`	Verifica el saldo actual en Lightning en satoshis
`get_rate_limits`	Verifica el estado actual del límite de tasa y las solicitudes restantes

Pagos (Requiere clave de agente)

Herramienta	Descripción
`pay_l402_api`	Accede a APIs de pago (L402/X402) - detecta automáticamente el protocolo y paga
`pay_invoice`	Paga cualquier factura Lightning BOLT11
`keysend`	Envía un pago directamente a una clave pública de nodo (sin necesidad de factura)
`pay_lightning_address`	Paga a una dirección Lightning (formato [email protected])
`create_invoice`	Genera una factura para recibir pagos
`get_invoice_status`	Verifica si una factura ha sido pagada
`get_transactions`	Consulta el historial de transacciones

LNURL (Requiere clave de agente)

Herramienta	Descripción
`lnurl_auth`	Autentícate en un servicio usando el protocolo LNURL-auth
`claim_lnurl_withdraw`	Reclama fondos de un enlace LNURL-withdraw

Gestión de operador

Herramienta	Descripción
`register_operator`	Crea una nueva cuenta de operador
`recover_account`	Recupera una cuenta usando el código de recuperación
`rotate_api_key`	Genera una nueva clave API (enfriamiento de 60 min en retiros)
`get_deposit_invoice`	Crea una factura para fondear la cuenta del operador
`withdraw`	Retira fondos a un destino externo de Lightning
`set_operator_key`	Cambia a credenciales de operador

update_operator - establece el correo del operador (envía enlace de verificación) y/o nombre
claim_promo - reclama la promoción de sats gratis por instalación (correo verificado + cuenta de 3h)

Gestión de agentes

Herramienta	Descripción
`create_agent`	Crea un agente bajo el operador
`list_agents`	Lista todos los agentes bajo el operador
`fund_agent`	Transfiere sats del operador al agente
`transfer_to_agent`	Transfiere sats entre agentes o del operador al agente
`sweep_agent`	Barre fondos del agente de vuelta al operador
`deactivate_agent`	Deshabilita temporalmente un agente
`reactivate_agent`	Reactiva un agente desactivado
`delete_agent`	Elimina permanentemente un agente (devuelve el saldo al operador)
`get_budget_status`	Obtén el límite de presupuesto y gasto del agente
`set_budget`	Establece o actualiza el límite de gasto del agente
`set_agent_credentials`	Cambia a credenciales de agente

Webhooks

Herramienta	Descripción
`register_webhook`	Registra una URL para recibir notificaciones de eventos
`list_webhooks`	Lista todos los webhooks registrados
`delete_webhook`	Elimina un webhook
`test_webhook`	Envía un evento de prueba para verificar la conectividad del webhook

Eventos de Webhook:

invoice_paid - Pago recibido en una factura
payment_completed - Pago saliente exitoso
payment_failed - Pago saliente fallido
balance_low - El saldo cayó por debajo del umbral
budget_warning - 80% del presupuesto consumido
test - Evento de prueba manual

Referencia CLI

Todos los comandos emiten JSON a stdout. Los errores van a stderr con código de salida 1.

Comando	Descripción
`lw register [--name "name"]`	Crea cuenta de operador, imprime clave API
`lw whoami`	Identidad actual (operador o agente)
`lw balance`	Saldo en satoshis
`lw info`	Estado y capacidades del servicio
`lw deposit <amount>`	Genera factura de depósito
`lw withdraw <invoice>`	Retira a billetera externa
`lw pay <invoice>`	Paga factura BOLT11 `[--max-fee <sats>]`
`lw pay-api <url>`	Paga API L402/X402 `[--method GET] [--body "{}"] [--max-sats 1000]`
`lw decode <invoice>`	Decodifica factura BOLT11
`lw create-agent <name>`	Crea agente `[--budget <sats>]`
`lw fund-agent <id> <amount>`	Transfiere sats al agente
`lw list-agents`	Lista todos los agentes
`lw transactions`	Transacciones recientes `[--limit 10] [--offset 0]`
`lw help`	Muestra todos los comandos

Ejemplo de flujo de trabajo de agente (Bash)

# 1. Register (one-time)
export LIGHTNING_WALLET_API_KEY=$(lw register --name "My Agent" | jq -r '.api_key')

# 2. Fund the account (pay the invoice with any Lightning wallet)
lw deposit 10000 | jq -r '.bolt11'

# 3. Create an agent with a budget
AGENT=$(lw create-agent "Worker" --budget 5000)
AGENT_ID=$(echo $AGENT | jq -r '.agent_id')
AGENT_KEY=$(echo $AGENT | jq -r '.agent_api_key')

# 4. Fund the agent
lw fund-agent $AGENT_ID 2000

# 5. Switch to agent context and make payments
export LIGHTNING_WALLET_API_KEY=$AGENT_KEY
lw pay-api "https://api.example.com/data" --max-sats 100

# 6. Check what happened
lw transactions --limit 5

Protocolos de API de pago: L402 + X402

Lightning Wallet MCP soporta dos protocolos de pago HTTP 402:

L402 (primario) - Pagos en Lightning Network. El protocolo original de pago por solicitud.
X402 (alternativo) - USDC en Base (protocolo de Coinbase). Se detecta automáticamente cuando L402 no está disponible.

Cuando llamas a pay_l402_api, el servidor detecta automáticamente qué protocolo usa la API. L402 siempre tiene prioridad si ambas cabeceras están presentes. Los agentes siempre pagan en sats independientemente del protocolo — los montos en X402 se convierten a la tasa de mercado.

Protocolo L402

El protocolo L402 (anteriormente LSAT) permite a las APIs cobrar por solicitud usando Lightning. Cuando llamas a un endpoint protegido por L402:

El servidor devuelve HTTP 402 con una factura Lightning
Lightning Faucet paga la factura automáticamente
La solicitud se completa con el contenido pagado

Protocolo X402 (Coinbase)

X402 usa USDC en Base para pagos de API. El flujo es transparente para los agentes:

El servidor devuelve HTTP 402 con la cabecera PAYMENT-REQUIRED
Lightning Faucet convierte el monto en USDC a sats, debita el saldo del agente
Firma una autorización EIP-712 y reintenta con la cabecera PAYMENT-SIGNATURE
La solicitud se completa — el agente ve el mismo formato de respuesta que con L402

La respuesta incluye payment_protocol: "x402" y usdc_amount para que los agentes sepan qué protocolo se usó.

Registro de API L402

Mantenemos un directorio de APIs habilitadas para L402 en lightningfaucet.com/l402-registry - perfecto para probar tus agentes.

APIs L402 de demostración

Prueba estos endpoints para probar pagos L402:

# Get a fortune (costs ~10-50 sats)
pay_l402_api({ url: "https://lightningfaucet.com/api/l402/fortune" })

# Get a joke (costs ~10-50 sats)
pay_l402_api({ url: "https://lightningfaucet.com/api/l402/joke" })

# Get an inspirational quote (costs ~10-50 sats)
pay_l402_api({ url: "https://lightningfaucet.com/api/l402/quote" })

Consulta el Registro de API L402 para más endpoints y recursos.

Ejemplo de flujo de trabajo completo

// 1. Register as operator (if no API key configured)
register_operator({ name: "My AI Company" })
// Returns: { api_key: "lf_abc...", recovery_code: "xyz...", operator_id: 123 }

// 2. Activate the operator key
set_operator_key({ api_key: "lf_abc..." })

// 3. Check who you are
whoami()
// Returns: { type: "operator", id: 123, name: "My AI Company", balance_sats: 0 }

// 4. Fund your operator account
get_deposit_invoice({ amount_sats: 10000 })
// Pay this invoice with any Lightning wallet

// 5. Create an agent with budget limit
create_agent({ name: "Research Assistant", budget_limit_sats: 5000 })
// Returns: { agent_id: 456, agent_api_key: "agent_def..." }

// 6. Fund the agent
fund_agent({ agent_id: 456, amount_sats: 1000 })

// 7. Set up a webhook for payment notifications
register_webhook({
  url: "https://your-server.com/webhooks/lightning",
  events: ["invoice_paid", "payment_completed"]
})
// Returns: { webhook_id: 1, secret: "..." }  <- Save this secret!

// 8. Switch to agent mode for payments
set_agent_credentials({ api_key: "agent_def..." })

// 9. Check budget status
get_budget_status()
// Returns: { budget_limit_sats: 5000, total_spent_sats: 0, remaining_sats: 5000 }

// 10. Make payments!
pay_l402_api({ url: "https://api.example.com/premium-data" })

Pagos Keysend

Envía pagos directamente a un nodo Lightning sin necesidad de una factura:

// Send 100 sats to a node with an optional message
keysend({
  destination: "03864ef025fde8fb587d989186ce6a4a186895ee44a926bfc370e2c366597a3f8f",
  amount_sats: 100,
  message: "Hello from my AI agent!"
})

Decodificación de facturas

Verifica los detalles de la factura antes de pagar:

decode_invoice({ invoice: "lnbc1000n1..." })
// Returns: {
//   amount_sats: 1000,
//   description: "Test payment",
//   destination: "03abc...",
//   expires_at: "2026-01-16T12:00:00Z",
//   is_expired: false
// }

Detalles de herramientas

get_info

Obtén el estado y las capacidades del servicio.

{
  "success": true,
  "version": "1.0.1",
  "api_version": "1.0",
  "status": "operational",
  "max_payment_sats": 1000000,
  "min_payment_sats": 1,
  "supported_features": ["l402", "x402", "webhooks", "lightning_address", "keysend"]
}

whoami

Obtén el contexto operativo actual.

Devuelve para Operador:

{
  "type": "operator",
  "id": 123,
  "name": "My Company",
  "balance_sats": 50000,
  "agent_count": 3
}

Devuelve para Agente:

{
  "type": "agent",
  "id": 456,
  "name": "Research Bot",
  "balance_sats": 1000,
  "budget_limit_sats": 5000,
  "operator_id": 123
}

pay_l402_api

Accede a APIs de pago con pago automático. Soporta ambos protocolos L402 (Lightning) y X402 (USDC en Base). El protocolo se detecta automáticamente de las cabeceras de respuesta 402.

Parámetro	Tipo	Requerido	Descripción
url	string	Sí	La URL a solicitar
method	string	No	Método HTTP (GET, POST, PUT, DELETE). Por defecto: GET
body	string	No	Cuerpo de la solicitud para POST/PUT
max_payment_sats	number	No	Monto máximo de pago. Por defecto: 1000

keysend

Envía un pago a un nodo sin una factura.

Parámetro	Tipo	Requerido	Descripción
destination	string	Sí	Clave pública del nodo destino (66 caracteres hexadecimales)
amount_sats	number	Sí	Monto en satoshis
message	string	No	Mensaje opcional (máx. 1000 caracteres)

register_webhook

Registra una URL para recibir notificaciones de pago.

Parámetro	Tipo	Requerido	Descripción
url	string	Sí	URL HTTPS para recibir webhooks
events	array	No	Tipos de eventos a suscribir. Por defecto: ["invoice_paid"]

Devuelve: ID del webhook y secreto HMAC para verificación de firma.

Arquitectura

┌─────────────────────────────────────────────────────────┐
│                    OPERATOR                              │
│  • Holds main funds                                      │
│  • Creates and manages agents                            │
│  • Sets spending limits                                  │
│  • Receives webhook notifications                        │
│  • Can recover account with recovery code                │
├─────────────────────────────────────────────────────────┤
│     AGENT 1          AGENT 2          AGENT 3           │
│   ┌─────────┐      ┌─────────┐      ┌─────────┐        │
│   │ 1000 sat│      │ 5000 sat│      │ 2500 sat│        │
│   │ Budget: │      │ Budget: │      │ Budget: │        │
│   │ 5000    │      │ 10000   │      │ Unlimited│        │
│   └─────────┘      └─────────┘      └─────────┘        │
│       │                │                │               │
│   L402 APIs        Keysend          Receive             │
│   Pay Invoice      Payments         Payments            │
└─────────────────────────────────────────────────────────┘

Mejores prácticas de seguridad

Nunca subas claves API a repositorios - Usa variables de entorno
Establece límites de presupuesto - Protégete contra gastos descontrolados
Usa claves de agente para pagos - Mantén segura la clave de operador
Verifica las firmas de webhook - Usa el secreto devuelto durante el registro
Monitorea las transacciones - Usa get_transactions para revisar la actividad
Códigos de recuperación - Almacénalos de forma segura, necesarios si se pierde la clave API
Rotación de claves - Rota las claves periódicamente usando rotate_api_key

Seguridad de Webhooks

Los webhooks incluyen firmas HMAC-SHA256 para verificación:

import hmac
import hashlib

def verify_webhook(payload, signature, secret):
    expected = hmac.new(
        secret.encode(),
        payload.encode(),
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(signature, expected)

Verifica la cabecera X-Webhook-Signature contra la carga útil.

Política de pre-pago

Un gancho opcional e independiente del proveedor permite que un endpoint de política externo permita o deniegue un pago antes de que se ejecute. Está desactivado por defecto — cuando PRE_PAYMENT_HOOK_URL no está configurado, el comportamiento es exactamente el mismo de antes. Cuando se configura, cada pago saliente (pay_l402_api, pay_invoice, keysend, pay_lightning_address) se verifica primero contra tu endpoint; una denegación aborta el pago antes de que se muevan fondos.

Esto es útil para políticas de gasto, flujos de aprobación, verificaciones de cumplimiento o cualquier capa de autorización externa. El protocolo del gancho es genérico, por lo que cualquier servicio que implemente el contrato de solicitud/respuesta a continuación puede conectarse solo mediante configuración.

Configuración

Variable de entorno	Valor por defecto	Descripción
`PRE_PAYMENT_HOOK_URL`	(sin configurar)	Endpoint de política al que enviar por POST cada propuesta de pago. Dejarlo sin configurar desactiva completamente el gancho.
`PRE_PAYMENT_HOOK_TIMEOUT_MS`	`3000`	Tiempo de espera por solicitud en milisegundos.
`PRE_PAYMENT_HOOK_FAIL_MODE`	`closed`	`closed` deniega un pago si el gancho falla o expira; `open` permite que continúe. El valor por defecto es a prueba de fallos (denegar).

{
  "mcpServers": {
    "lightning-wallet": {
      "command": "npx",
      "args": ["lightning-wallet-mcp"],
      "env": {
        "LIGHTNING_WALLET_API_KEY": "your-api-key",
        "PRE_PAYMENT_HOOK_URL": "https://your-policy-endpoint.example/hook"
      }
    }
  }
}

Solicitud del gancho (POST desde el cliente)

La propuesta describe únicamente el pago propuesto — nunca incluye tu clave API de la billetera.

{
  "proposal_id": "f7e1…",
  "agent_id": 42,
  "protocol": "l402",
  "destination_or_url": "https://api.example/paid-endpoint",
  "amount_sats": null,
  "max_payment_sats": 1000,
  "method": "GET",
  "ts": "2026-06-06T18:00:00.000Z"
}

protocol es uno de l402, x402, bolt11, keysend, lnaddress. amount_sats es el monto exacto cuando se conoce en el momento del gancho: para keysend y lnaddress es el monto solicitado, y para bolt11 se decodifica localmente desde la factura (sin llamada API adicional). Para l402/x402 es null porque el monto lo establece el desafío de pago en el momento de la ejecución — allí el gancho aplica max_payment_sats (el límite autorizado por el agente) por adelantado, y el monto exacto liquidado está disponible después a través de webhooks. max_payment_sats es el límite autorizado por el agente cuando corresponde.

Exactamente lo que sale de la billetera. Solo los ocho campos anteriores se envían a tu endpoint de gancho: proposal_id, agent_id, protocol, destination_or_url, amount_sats, max_payment_sats, method, ts. La clave API de la billetera y cualquier otra credencial nunca se incluyen.

Cobertura. El gancho controla cada gasto iniciado por el agente: pay_l402_api, pay_invoice, keysend, pay_lightning_address y Nostr zaps. La gestión de fondos con alcance de operador (retiros, financiación de agentes, transferencias entre agentes) intencionalmente no está controlada — esas son acciones del operador, no gastos del agente.

Respuesta del gancho (tu endpoint devuelve)

{ "decision": "allow" }

{ "decision": "deny", "reason": { "code": "over_limit", "message": "Exceeds per-transaction limit" } }

allow → el pago continúa.
deny → el pago se aborta y la herramienta devuelve un error PolicyDenied mostrando reason.message.
Un campo opcional attestation (cualquier JSON) es tratado como opaco por el cliente — se registra en stderr y se ignora en todo lo demás, para que un servicio de política pueda devolver una decisión firmada para auditoría posterior.

En caso de error del gancho, tiempo de espera o respuesta no reconocida, se aplica PRE_PAYMENT_HOOK_FAIL_MODE (denegar por defecto).

Precios

Lightning Faucet cobra una tarifa de plataforma del 2% (mín. 1 sat) en pagos salientes:

Pagos L402: tarifa de plataforma del 2% + tarifa de enrutamiento Lightning
Pagos X402: tarifa de plataforma del 2% + diferencial de tipo de cambio del 1% (conversión de USDC a sats)
Pagos de factura: tarifa de plataforma del 2% + tarifa de enrutamiento Lightning
Pagos Keysend: tarifa de plataforma del 2% + tarifa de enrutamiento Lightning
Retiros del operador: tarifa de plataforma del 2% + tarifa de enrutamiento Lightning
Transferencias internas entre operadores: tarifa de plataforma del 2% (sin tarifa de enrutamiento)
Transferencias de agentes del mismo operador: Gratis
Depósitos: Gratis
Recepción de pagos: Gratis
Webhooks: Gratis

Todas las respuestas de pago incluyen platform_fee_sats, routing_fee_sats y total_cost para total transparencia.

Registro de cambios

v1.1.0 (2026-02-16)

Interfaz CLI: Nuevo comando lw para agentes que priorizan CLI (OpenClaw, Pi, KiloCode, cualquier agente Bash)
Mismo paquete, dos interfaces: npm install -g lightning-wallet-mcp te ofrece tanto servidor MCP como CLI
Salida JSON primero: Todos los comandos CLI emiten JSON a stdout, errores a stderr
Soporte X402: Repliegue automático a X402 (USDC en Base) cuando L402 no está disponible
Detección automática de protocolo: pay_l402_api detecta L402 o X402 desde los encabezados de respuesta 402
Campos de respuesta: payment_protocol y usdc_amount incluidos cuando se usa X402
Tipo de cambio: Conversión BTC/USD en tiempo real vía CoinGecko con caché de 5 min

v1.0.3 (2026-02-05)

Tarifa de plataforma: Tarifa del 2% (mín. 1 sat) en todos los pagos salientes y transferencias entre operadores
Transparencia de tarifas: Todas las respuestas de pago ahora incluyen platform_fee_sats, routing_fee_sats y total_cost
Las transferencias de agentes del mismo operador siguen siendo gratuitas

v1.0.0 (2026-02-04)

Renombrado de lightning-faucet-mcp a lightning-wallet-mcp
Variable de entorno renombrada: LIGHTNING_FAUCET_API_KEY → LIGHTNING_WALLET_API_KEY
Las 37 herramientas completamente probadas y listas para producción
Sin cambios de API que rompan compatibilidad - solo el nombre del paquete

Versiones anteriores (como lightning-faucet-mcp)

Consulta el registro de cambios de lightning-faucet-mcp para el historial de v1.6.0 a v2.0.7.

Pagos básicos y facturas

Vitrina: Experimento de Teoría de Juegos con Agentes de IA

Realizamos un experimento económico de 100 rondas con 16 agentes de IA (8 Claude, 8 GPT-4o) usando Bitcoin real en Lightning. Los agentes podían comerciar, formar alianzas, invertir y competir — todo impulsado por este servidor MCP.

Resultados: Los agentes completaron 2,839 transacciones Lightning reales. Los agentes Claude dominaron mediante comercio agresivo temprano, mientras que los agentes GPT-4o adoptaron estrategias conservadoras.

Repositorio del experimento: github.com/pfergi42/lf-game-theory
Publicación del blog: lightningfaucet.com/blog/ai-game-theory

Soporte

Documentación: lightningfaucet.com/ai-agents/docs
Demo: lightningfaucet.com/ai-agents/demo
Incidencias: github.com/lightningfaucet/lightning-wallet-mcp/issues
Correo electrónico: [email protected]

Licencia

Licencia MIT - consulta LICENSE para más detalles.

Construido con Bitcoin | Lightning Faucet