Lightning Faucet MCP Server

oficial

Forneça aos agentes de IA uma carteira Bitcoin com pagamentos via Lightning Network

Documentação

Lightning Wallet

Dê ao seu agente de IA uma carteira Bitcoin. Servidor MCP + CLI. Funciona com Claude Code, OpenClaw, Cursor e qualquer framework de agente.

Novidades na v1.4

Ferramenta update_operator / lw set-email - defina o e-mail do seu operador pelo cliente MCP ou CLI; um link de verificação será enviado para você.
Ferramenta claim_promo / lw claim-promo - reivindique a promoção de instalação de sats grátis diretamente do seu agente. Requisitos: e-mail verificado + conta de operador com pelo menos 3 horas de existência.
get_info funciona antes do registro - informações do serviço não exigem mais uma chave de API.

100 sats grátis para novos operadores

lw register --email [email protected] (ou a ferramenta MCP register_operator com um e-mail)
Clique no link de verificação que enviamos por e-mail
Após sua conta ter 3 horas de existência: lw claim-promo (ou a ferramenta MCP claim_promo)

Um bônus por operador, apenas para as primeiras 100 instalações, sem necessidade de depósito.

Novidades na v1.3

v1.3.0 - Suporte ao protocolo L402 v0 conforme a especificação mais recente da Lightning Labs.

Protocolo L402 v0 - Formato de cabeçalho atualizado: version="0", token=, compatível com versões anteriores com macaroon=
Descoberta de Endpoint - .well-known/l402.json em lightningfaucet.com e certvera.com
Compatibilidade Retroativa - Lida com formatos de cabeçalho L402 antigos e novos de qualquer serviço

Novidades na v1.1

v1.1.0 - Suporte ao protocolo X402 (USDC na Base) como fallback automático junto com L402 (Lightning).

Suporte X402 - Pagamentos automáticos em USDC na Base quando L402 não está disponível
Detecção Automática de Protocolo - pay_l402_api lida perfeitamente com ambos L402 e X402
Webhooks - Notificações em tempo real para pagamentos e eventos
Keysend - Envie pagamentos sem faturas usando chaves públicas de nós
Decodificação de Faturas - Decodifique faturas BOLT11 antes de pagar
Análise de Agentes - Acompanhe padrões de gastos e uso
Exportação de Transações - Exporte histórico em formato JSON ou CSV
Gerenciamento de Orçamento - Obtenha status detalhado do orçamento e defina limites
Ciclo de Vida do Agente - Desative, reative e exclua agentes
Recuperação de Conta - Recupere contas e rotacione chaves de API
Transferências entre Agentes - Mova fundos entre seus agentes

Por que Lightning Wallet MCP?

Pagamentos Instantâneos - Transações na Lightning Network são liquidadas em milissegundos
Suporte aos Protocolos L402 + X402 - Acesse qualquer API paga automaticamente (Lightning ou USDC)
Hierarquia Operador/Agente - Gerencie múltiplos agentes com limites de gastos
Sem Risco de Custódia - Cada agente possui fundos isolados com supervisão do operador
Pronto para Produção - Infraestrutura testada em batalha processando transações reais
Notificações por Webhook - Seja notificado instantaneamente quando pagamentos chegarem
Observabilidade Total - Análises, exportações e acompanhamento detalhado de status

Duas Formas de Usar

CLI (Qualquer Framework de Agente)

Para agentes que priorizam CLI (OpenClaw, Pi, KiloCode ou qualquer agente com acesso Bash):

npm install -g lightning-wallet-mcp

Isso instala o 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

A saída é JSON por padrão (pipe para jq). Use --human para saída legível.

Execute lw help para todos os comandos.

Servidor MCP (Claude Code, Cursor, Windsurf)

Para clientes nativos MCP, configure como um servidor MCP:

Opção A: Auto-Registro

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

Então peça ao Claude: "Registre uma nova conta de operador Lightning Wallet"

Opção B: Chave de API Pré-configurada

Obtenha uma chave de API em lightningfaucet.com/ai-agents
Configure o Claude Code (~/.claude/settings.json):

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

Referência de Ferramentas

Informações do Serviço

Ferramenta	Descrição
`get_info`	Obtenha status do serviço, versão e recursos suportados
`decode_invoice`	Decodifique uma fatura BOLT11 para ver valor, destino e expiração

Contexto e Identidade

Ferramenta	Descrição
`whoami`	Obtenha o contexto atual - mostra se está operando como operador ou agente
`check_balance`	Verifique o saldo atual em Lightning em satoshis
`get_rate_limits`	Verifique o status atual do limite de taxa e requisições restantes

Pagamentos (Chave de Agente Necessária)

Ferramenta	Descrição
`pay_l402_api`	Acesse APIs pagas (L402/X402) - detecta automaticamente o protocolo e paga
`pay_invoice`	Pague qualquer fatura Lightning BOLT11
`keysend`	Envie pagamento diretamente para uma chave pública de nó (sem necessidade de fatura)
`pay_lightning_address`	Pague para um endereço Lightning (formato [email protected])
`create_invoice`	Gere fatura para receber pagamentos
`get_invoice_status`	Verifique se uma fatura foi paga
`get_transactions`	Visualize o histórico de transações

LNURL (Chave de Agente Necessária)

Ferramenta	Descrição
`lnurl_auth`	Autentique-se em um serviço usando o protocolo LNURL-auth
`claim_lnurl_withdraw`	Reivindique fundos de um link LNURL-withdraw

Gerenciamento de Operador

Ferramenta	Descrição
`register_operator`	Crie uma nova conta de operador
`recover_account`	Recupere a conta usando o código de recuperação
`rotate_api_key`	Gere uma nova chave de API (cooldown de 60 min para saques)
`get_deposit_invoice`	Crie fatura para financiar a conta do operador
`withdraw`	Saque fundos para um destino Lightning externo
`set_operator_key`	Mude para credenciais de operador

update_operator - defina o e-mail do operador (envia link de verificação) e/ou nome
claim_promo - reivindique a promoção de instalação de sats grátis (e-mail verificado + conta de 3h)

Gerenciamento de Agentes

Ferramenta	Descrição
`create_agent`	Crie agente sob o operador
`list_agents`	Liste todos os agentes sob o operador
`fund_agent`	Transfira sats do operador para o agente
`transfer_to_agent`	Transfira sats entre agentes ou do operador para o agente
`sweep_agent`	Recolha fundos do agente de volta para o operador
`deactivate_agent`	Desabilite temporariamente um agente
`reactivate_agent`	Reabilite um agente desativado
`delete_agent`	Exclua permanentemente um agente (retorna o saldo ao operador)
`get_budget_status`	Obtenha o limite de orçamento e gastos do agente
`set_budget`	Defina ou atualize o limite de gastos do agente
`set_agent_credentials`	Mude para credenciais de agente

Webhooks

Ferramenta	Descrição
`register_webhook`	Registre uma URL para receber notificações de eventos
`list_webhooks`	Liste todos os webhooks registrados
`delete_webhook`	Exclua um webhook
`test_webhook`	Envie um evento de teste para verificar a conectividade do webhook

Eventos de Webhook:

invoice_paid - Pagamento recebido em uma fatura
payment_completed - Pagamento enviado com sucesso
payment_failed - Pagamento enviado falhou
balance_low - Saldo caiu abaixo do limite
budget_warning - 80% do orçamento consumido
test - Evento de teste manual

Referência CLI

Todos os comandos emitem JSON para stdout. Erros vão para stderr com código de saída 1.

Comando	Descrição
`lw register [--name "name"]`	Cria conta de operador, imprime chave de API
`lw whoami`	Identidade atual (operador ou agente)
`lw balance`	Saldo em satoshis
`lw info`	Status e capacidades do serviço
`lw deposit <amount>`	Gera fatura de depósito
`lw withdraw <invoice>`	Saca para carteira externa
`lw pay <invoice>`	Paga fatura BOLT11 `[--max-fee <sats>]`
`lw pay-api <url>`	Paga API L402/X402 `[--method GET] [--body "{}"] [--max-sats 1000]`
`lw decode <invoice>`	Decodifica fatura BOLT11
`lw create-agent <name>`	Cria agente `[--budget <sats>]`
`lw fund-agent <id> <amount>`	Transfere sats para agente
`lw list-agents`	Lista todos os agentes
`lw transactions`	Transações recentes `[--limit 10] [--offset 0]`
`lw help`	Mostra todos os comandos

Exemplo de Fluxo de Trabalho do 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 Paga: L402 + X402

Lightning Wallet MCP suporta dois protocolos de pagamento HTTP 402:

L402 (primário) - Pagamentos na Lightning Network. O protocolo original de pagamento por requisição.
X402 (fallback) - USDC na Base (protocolo da Coinbase). Detectado automaticamente quando L402 não está disponível.

Quando você chama pay_l402_api, o servidor detecta automaticamente qual protocolo a API usa. L402 sempre tem prioridade se ambos os cabeçalhos estiverem presentes. Agentes sempre pagam em sats independentemente do protocolo — valores X402 são convertidos à taxa de mercado.

Protocolo L402

O protocolo L402 (anteriormente LSAT) permite que APIs cobrem por requisição usando Lightning. Quando você chama um endpoint protegido por L402:

O servidor retorna HTTP 402 com uma fatura Lightning
Lightning Faucet paga a fatura automaticamente
A requisição é concluída com o conteúdo pago

Protocolo X402 (Coinbase)

X402 usa USDC na Base para pagamentos de API. O fluxo é transparente para os agentes:

O servidor retorna HTTP 402 com cabeçalho PAYMENT-REQUIRED
Lightning Faucet converte o valor em USDC para sats, debita o saldo do agente
Assina uma autorização EIP-712 e tenta novamente com cabeçalho PAYMENT-SIGNATURE
A requisição é concluída — o agente vê o mesmo formato de resposta que no L402

A resposta inclui payment_protocol: "x402" e usdc_amount para que os agentes saibam qual protocolo foi usado.

Registro de API L402

Mantemos um diretório de APIs habilitadas para L402 em lightningfaucet.com/l402-registry - perfeito para testar seus agentes.

APIs L402 de Demonstração

Experimente estes endpoints para testar pagamentos 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" })

Veja o Registro de API L402 para mais endpoints e recursos.

Exemplo de Fluxo de Trabalho 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" })

Pagamentos Keysend

Envie pagamentos diretamente para um nó Lightning sem precisar de uma fatura:

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

Decodificação de Faturas

Verifique os detalhes da fatura 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
// }

Detalhes das Ferramentas

get_info

Obtenha status e capacidades do serviço.

{
  "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

Obtenha o contexto operacional atual.

Retorna para Operador:

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

Retorna para Agente:

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

pay_l402_api

Acesse APIs pagas com pagamento automático. Suporta ambos os protocolos L402 (Lightning) e X402 (USDC na Base). O protocolo é detectado automaticamente a partir dos cabeçalhos de resposta 402.

Parâmetro	Tipo	Obrigatório	Descrição
url	string	Sim	A URL para requisição
method	string	Não	Método HTTP (GET, POST, PUT, DELETE). Padrão: GET
body	string	Não	Corpo da requisição para POST/PUT
max_payment_sats	number	Não	Valor máximo de pagamento. Padrão: 1000

keysend

Envie pagamento para um nó sem fatura.

Parâmetro	Tipo	Obrigatório	Descrição
destination	string	Sim	Chave pública do nó de destino (66 caracteres hex)
amount_sats	number	Sim	Valor em satoshis
message	string	Não	Mensagem opcional (máx. 1000 caracteres)

register_webhook

Registre uma URL para receber notificações de pagamento.

Parâmetro	Tipo	Obrigatório	Descrição
url	string	Sim	URL HTTPS para receber webhooks
events	array	Não	Tipos de evento para assinar. Padrão: ["invoice_paid"]

Retorna: ID do Webhook e segredo HMAC para verificação de assinatura.

Arquitetura

┌─────────────────────────────────────────────────────────┐
│                    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            │
└─────────────────────────────────────────────────────────┘

Melhores Práticas de Segurança

Nunca comite chaves de API - Use variáveis de ambiente
Defina limites de orçamento - Proteja-se contra gastos descontrolados
Use chaves de agente para pagamentos - Mantenha a chave do operador segura
Verifique assinaturas de webhook - Use o segredo retornado durante o registro
Monitore transações - Use get_transactions para revisar a atividade
Códigos de recuperação - Armazene com segurança, necessário se a chave de API for perdida
Rotação de chaves - Rotacione chaves periodicamente usando rotate_api_key

Segurança de Webhook

Webhooks incluem assinaturas HMAC-SHA256 para verificação:

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)

Verifique o cabeçalho X-Webhook-Signature em relação ao payload.

Gancho de Política de Pré-Pagamento

Um gancho opcional e independente de fornecedor permite que um endpoint de política externo permita ou negue um pagamento antes de sua execução. Ele fica desativado por padrão — quando PRE_PAYMENT_HOOK_URL não está definido, o comportamento é exatamente o mesmo de antes. Quando definido, todo pagamento de saída (pay_l402_api, pay_invoice, keysend, pay_lightning_address) é verificado primeiro no seu endpoint; uma negação aborta o pagamento antes que qualquer fundo seja movimentado.

Isso é útil para políticas de gastos, fluxos de aprovação, verificações de conformidade ou qualquer camada de autorização externa. O protocolo do gancho é genérico, portanto qualquer serviço que implemente o contrato de requisição/resposta abaixo pode ser conectado apenas por configuração.

Configuração

Variável de ambiente	Padrão	Descrição
`PRE_PAYMENT_HOOK_URL`	(não definido)	Endpoint de política para o qual enviar cada proposta de pagamento via POST. Não definir desativa completamente o gancho.
`PRE_PAYMENT_HOOK_TIMEOUT_MS`	`3000`	Tempo limite por requisição em milissegundos.
`PRE_PAYMENT_HOOK_FAIL_MODE`	`closed`	`closed` nega um pagamento se o gancho falhar ou expirar; `open` permite que prossiga. O padrão é fail-closed.

{
  "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"
      }
    }
  }
}

Requisição do gancho (POST do cliente)

A proposta descreve apenas o pagamento proposto — ela nunca inclui sua chave de API da carteira.

{
  "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 é um de l402, x402, bolt11, keysend, lnaddress. amount_sats é o valor exato quando conhecido no momento do gancho: para keysend e lnaddress é o valor solicitado, e para bolt11 é decodificado localmente a partir da fatura (sem chamada de API extra). Para l402/x402 é null porque o valor é definido pelo desafio de pagamento no momento da execução — nesse caso, o gancho impõe max_payment_sats (o teto autorizado pelo agente) antecipadamente, e o valor exato liquidado fica disponível posteriormente via webhooks. max_payment_sats é o teto autorizado pelo agente quando aplicável.

Exatamente o que sai da carteira. Apenas os oito campos acima são enviados ao seu endpoint de gancho: proposal_id, agent_id, protocol, destination_or_url, amount_sats, max_payment_sats, method, ts. A chave de API da carteira e quaisquer outras credenciais nunca são incluídas.

Cobertura. O gancho controla todo gasto iniciado por agente: pay_l402_api, pay_invoice, keysend, pay_lightning_address e Nostr zaps. O gerenciamento de fundos com escopo de operador (saques, financiamento de agentes, transferências entre agentes) intencionalmente não é controlado — essas são ações do operador, não gastos de agentes.

Resposta do gancho (seu endpoint retorna)

{ "decision": "allow" }

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

allow → o pagamento prossegue.
deny → o pagamento é abortado e a ferramenta retorna um erro PolicyDenied exibindo reason.message.
Um campo opcional attestation (qualquer JSON) é tratado como opaco pelo cliente — é registrado no stderr e ignorado de outra forma, para que um serviço de política possa retornar uma decisão assinada para auditoria posterior.

Em caso de erro do gancho, tempo limite ou resposta não reconhecida, aplica-se PRE_PAYMENT_HOOK_FAIL_MODE (negar por padrão).

Preços

O Lightning Faucet cobra uma taxa de plataforma de 2% (mín. 1 sat) sobre pagamentos de saída:

Pagamentos L402: taxa de plataforma de 2% + taxa de roteamento Lightning
Pagamentos X402: taxa de plataforma de 2% + spread de taxa de câmbio de 1% (conversão de USDC para sats)
Pagamentos de fatura: taxa de plataforma de 2% + taxa de roteamento Lightning
Pagamentos Keysend: taxa de plataforma de 2% + taxa de roteamento Lightning
Saques do operador: taxa de plataforma de 2% + taxa de roteamento Lightning
Transferências internas entre operadores: taxa de plataforma de 2% (sem taxa de roteamento)
Transferências de agente no mesmo operador: Grátis
Depósitos: Grátis
Recebimento de pagamentos: Grátis
Webhooks: Grátis

Todas as respostas de pagamento incluem platform_fee_sats, routing_fee_sats e total_cost para total transparência.

Changelog

v1.1.0 (2026-02-16)

Interface CLI: Novo comando lw para agentes que priorizam CLI (OpenClaw, Pi, KiloCode, qualquer agente Bash)
Mesmo pacote, duas interfaces: npm install -g lightning-wallet-mcp oferece tanto servidor MCP quanto CLI
Saída JSON-first: Todos os comandos CLI emitem JSON para stdout, erros para stderr
Suporte a X402: Fallback automático para X402 (USDC na Base) quando L402 não está disponível
Detecção automática de protocolo: pay_l402_api detecta L402 ou X402 a partir dos cabeçalhos de resposta 402
Campos de resposta: payment_protocol e usdc_amount incluídos quando X402 é usado
Taxa de câmbio: Conversão BTC/USD em tempo real via CoinGecko com cache de 5 min

v1.0.3 (2026-02-05)

Taxa de plataforma: taxa de 2% (mín. 1 sat) em todos os pagamentos de saída e transferências entre operadores
Transparência de taxas: Todas as respostas de pagamento agora incluem platform_fee_sats, routing_fee_sats e total_cost
Transferências de agente no mesmo operador permanecem gratuitas

v1.0.0 (2026-02-04)

Renomeado de lightning-faucet-mcp para lightning-wallet-mcp
Variável de ambiente renomeada: LIGHTNING_FAUCET_API_KEY → LIGHTNING_WALLET_API_KEY
Todas as 37 ferramentas totalmente testadas e prontas para produção
Sem alterações quebradoras de API - apenas o nome do pacote

Versões anteriores (como lightning-faucet-mcp)

Veja o changelog do lightning-faucet-mcp para o histórico da v1.6.0 até v2.0.7.

Pagamentos básicos e faturas

Demonstração: Experimento de Teoria dos Jogos com Agentes de IA

Realizamos um experimento econômico de 100 rodadas com 16 agentes de IA (8 Claude, 8 GPT-4o) usando Bitcoin real na Lightning. Os agentes podiam negociar, formar alianças, investir e competir — tudo alimentado por este servidor MCP.

Resultados: Os agentes completaram 2.839 transações Lightning reais. Os agentes Claude dominaram através de negociações agressivas iniciais, enquanto os agentes GPT-4o adotaram estratégias conservadoras.

Repositório do experimento: github.com/pfergi42/lf-game-theory
Post no blog: lightningfaucet.com/blog/ai-game-theory

Suporte

Documentação: lightningfaucet.com/ai-agents/docs
Demonstração: lightningfaucet.com/ai-agents/demo
Issues: github.com/lightningfaucet/lightning-wallet-mcp/issues
Email: [email protected]

Licença

Licença MIT - veja LICENSE para detalhes.

Construído com Bitcoin | Lightning Faucet