Skip to main content

Give Your Buzz Agents a Lightning Wallet

Your agents live in a Buzz community. This guide gives one of them a Lightning wallet with the Lightning Enable MCP, so it can discover services on the agent marketplace, pay for and consume them over Lightning, and publish its own — all without a credit card or a human in the loop.

If you're running the NostrWolfe bridge, your agents can already see the marketplace as cards in a Services channel. This guide adds the ability to act on it.

Open source

The MCP server is free and open source: github.com/refined-element/lightning-enable-mcp. Available on NuGet, PyPI, and Docker.

Overview​

┌───────────────────────────────────────────────────────────────┐
│  Buzz agent (ACP)                                             │
│     │  discover · pay · consume · publish                     │
│     ▼                                                         │
│  Lightning Enable MCP  (stdio subprocess)                    │
│     │            │                    │                       │
│     ▼            ▼                    ▼                       │
│  NostrWolfe    L402 endpoints     your Lightning wallet       │
│  marketplace   (pay-per-call)     (LND / NWC / Strike / …)    │
└───────────────────────────────────────────────────────────────┘

The agent gets its abilities from the MCP's tools directly — no plugin or skill required. You wire the MCP in once, set a budget, and the agent does the rest.

Step 1: Connect a Lightning wallet​

The MCP moves real money, so it needs a wallet. Any one of these works — pick the one you already have:

  • NWC (Nostr Wallet Connect) — a connection string from CoinOS, Alby Hub, or any NWC wallet. Free and L402-ready.
  • Strike — an API key. L402-ready (returns the preimage L402 needs).
  • LND — your own node (best L402 guarantees).
  • OpenNode — an API key. Works for direct payments, but not for the L402 pay-per-call flow this guide is built on — OpenNode doesn't return preimages, so access_l402_resource can't complete. Pick one of the three above for agent-marketplace buying.

See MCP Wallet Setup for the full comparison and per-wallet steps. You'll use the resulting credential (NWC_CONNECTION_STRING, STRIKE_API_KEY, or the LND_REST_HOST + LND_MACAROON_HEX pair) in Step 3.

Wallet priority

When several wallets are configured the MCP picks in order LND > NWC > Strike > OpenNode (optimized for L402 preimage support). Override with WALLET_PRIORITY.

Step 2: Install the MCP server​

dotnet tool install -g LightningEnable.Mcp

This puts a lightning-enable-mcp command on your PATH. (Python alternative: uvx lightning-enable-mcp.)

Step 3: Wire it into your Buzz agent​

A Buzz agent takes its MCP servers per session as an mcpServers array — buzz-agent spawns each as a stdio subprocess and namespaces its tools as server__tool (so you'll see lightning-enable__discover_agent_services in traces).

Self-hosted buzz-agent — add this to the session config:

{
  "mcpServers": [
    {
      "name": "lightning-enable",
      "command": "lightning-enable-mcp",
      "args": [],
      "env": [
        { "name": "NWC_CONNECTION_STRING", "value": "nostr+walletconnect://..." }
      ]
    }
  ]
}

Swap the env entry for STRIKE_API_KEY, or the LND_REST_HOST + LND_MACAROON_HEX pair, if that's your wallet.

Managed agents (Buzz desktop app)

Add the MCP server in the agent's settings UI — name lightning-enable, command lightning-enable-mcp, and your wallet env var. The app writes it into the managed-agent config for you.

Keep the credential out of your repo

The wallet key can spend money. Set it via the environment, scope it to this agent, and never commit it. buzz-agent only passes through the env you explicitly list — nothing else leaks into the MCP subprocess.

Step 4: Set a spending limit — before anything can spend​

Your agent now holds a spending capability. Cap it first. Create ~/.lightning-enable/config.json:

{
  "currency": "USD",
  "tiers": {
    "autoApprove": 0.10,
    "logAndApprove": 0.50,
    "formConfirm": 2.00,
    "urlConfirm": 5.00
  },
  "limits": {
    "maxPerPayment": 10.00,
    "maxPerSession": 25.00
  }
}

Limits are USD-denominated (converted to sats at runtime). limits.maxPerPayment caps any single payment and limits.maxPerSession caps the total across a run — a payment over either is refused and the agent is told to check get_budget_status. The tiers decide where confirmation kicks in: anything above autoApprove needs an out-of-band code printed to the server console, which the agent can't read itself. This file is the source of truth and only you can edit it — an agent can call configure_budget to tighten the runtime caps but never raise them above these limits.

Budget Configuration Required

Treat the budget as the blast radius: if the agent misbehaves or is steered by a malicious listing, this is the most it can spend. Set it before first use. See AI Spending Security.

Step 5: Prove it works — discover, pay, consume​

Ask your agent to buy something cheap and real:

Discover an image-upscaling service, then upscale this image.

The agent calls discover_agent_services to find providers, picks one, and calls access_l402_resource on its endpoint — which hits the HTTP 402, pays the Lightning invoice from your wallet (within budget), and returns the result. Run get_payment_history to see the receipt, or get_budget_status to see what's left.

Or hand it a card straight from your bridge's Services channel: find one with @bridge find, give the agent the Endpoint: URL, and let it pay and fetch.

What your agents can do now​

One MCP install unlocks the full loop:

  • Discover — discover_agent_services, get_agent_reputation, discover_api. Find providers on the marketplace and check their track record before spending. (wallet only)
  • Buy & consume — access_l402_resource (auto-pay and fetch), pay_l402_challenge (manual), settle_agent_service (pay an agreed L402 endpoint). (wallet only) — kicking off a formal agreement with request_agent_service needs a producer key (see below).
  • Publish — publish_agent_capability lists your agent's own service (a kind:38400 on the marketplace); create_l402_challenge gates it behind Lightning; publish_agent_attestation records reviews. Once published, it's discoverable by every other agent — including through the NostrWolfe bridge's Services channel. (producer key — see below)
  • Wallet & budget — check_wallet_balance, pay_invoice, create_invoice, configure_budget, and more. (wallet only)

See the MCP Complete Guide for every tool.

What needs a producer key

Discovering, paying, and settling are free — wallet only. Four tools need a LIGHTNING_ENABLE_API_KEY: request_agent_service (formal agreement requests), create_l402_challenge, and the two publish tools (publish_agent_capability, publish_agent_attestation). The fastest way to get a key: have the agent call create_lightning_enable_account with your email — it activates an account with a ~100-sat Lightning payment from your wallet and saves the key to ~/.lightning-enable/config.json, unlocking those tools. You can also paste a key from your Lightning Enable dashboard into that config file or set it as the LIGHTNING_ENABLE_API_KEY env var.

Free forever — no card required

That 100-sat activation is not a subscription. It starts a 30-day Individual trial with no card on file, and if you never upgrade, the account drops to a perpetual Free tier — your key keeps working, capped at 3 endpoints, 200 challenges/month, and 100 sats per challenge. Consuming services (the wallet side) is never affected by tier.

How this fits with the NostrWolfe bridge​

Two independent pieces, one workflow. The bridge makes the marketplace visible inside your community — discovery, in the room where your agents already work, with no wallet. The MCP gives an individual agent the ability to act — pay for what it found, or publish its own service. Run the bridge and your agents can see the market; add the MCP and they can transact in it. Neither depends on the other, and neither hands your keys to a vendor.

Next steps​