The bill problem nobody mentions

You wrote a CrewAI tool. It queries a market data API, or a search index, or a model endpoint that costs you real money per call. You published it. Six hours later your dashboard is on fire. Somebody's autonomous agent is calling it eight times a second, retrying every transient timeout, fanning out across symbol lists, and your OpenAI bill is doing things you do not want it to do.

You did not put a billing layer in front of it because billing layers want API keys, signups, KYC, Stripe accounts, sandbox modes, and a customer support inbox you do not have. So you took it down instead.

There is a smaller move. Charge each call 10 sats. The agent pays before the work runs. No account, no key, no custody. If the agent has a Lightning wallet attached, which most agentic frameworks getting funded right now do, the call just goes through and the sat lands in your wallet. If it does not, the agent gets a 402 and a bolt11 invoice and has to decide whether the answer is worth ten sats.

That's what powforge does. One wrapper.

pip install powforge

Before, your raw tool, free, getting hammered

from crewai.tools import BaseTool

class MarketQuery(BaseTool):
    name: str = "market_query"
    description: str = "Look up the spot price for a symbol."

    def _run(self, symbol: str) -> dict:
        # your real call here, costs you per request
        return {"symbol": symbol, "price": fetch_price(symbol)}

Anyone, anywhere, can spin up a CrewAI crew that imports this and call it forever.

After, same tool, ten sats per call

from crewai.tools import BaseTool
from powforge.l402 import wrap_with_l402

async def _market_query(symbol: str) -> dict:
    return {"symbol": symbol, "price": fetch_price(symbol)}

gated = wrap_with_l402(
    _market_query,
    lnbits_url="https://your-lnbits.example",
    lnbits_api_key="your-invoice-key",
    sats_amount=10,
)

class MarketQuery(BaseTool):
    name: str = "market_query"
    description: str = "Look up spot price. Costs 10 sats per call."

    async def _arun(self, envelope: str) -> dict:
        return await gated(envelope)

That's it. The wrapped function now does this on every call:

1. No payment proof in the envelope? Mint an invoice via LNBits, return a 402-shaped dict with the bolt11 and the payment_hash. The agent pays it.
2. Payment proof present? Verify it against LNBits, cache the receipt for 10 minutes, run your real function, return the answer.

The agent's runtime sees the 402, asks its Lightning wallet to pay, gets the preimage, re-calls with the payment_hash as proof. Standard L402 round-trip.

What the 402 looks like

{
  "error": "payment_required",
  "invoice": "lnbc100n1pj...",
  "payment_hash": "5e8b...",
  "sats": 10,
  "next_step": "Pay the invoice, then re-call with the payment_hash as payment_proof."
}

Any L402-aware agent runtime (or any human with a wallet) can resolve this. CrewAI has tool-calling middleware in the loop; the same envelope shape works.

LangChain variant

LangChain tools take a single arg, so use the envelope form:

import json
from langchain.tools import StructuredTool
from powforge.l402 import wrap_with_l402

async def _do_search(query: str) -> str:
    return search_index(query)

gated = wrap_with_l402(
    _do_search,
    lnbits_url="https://your-lnbits.example",
    lnbits_api_key="your-invoice-key",
    sats_amount=10,
)

async def search_tool(envelope: str) -> str:
    return await gated(envelope)

tool = StructuredTool.from_function(
    coroutine=search_tool,
    name="paid_search",
    description="Search the index. 10 sats per query.",
)

The agent passes a JSON envelope: {"__payment_proof__": "<hash>", "__tool_input__": "<query>"}. Single-arg frameworks already do this for structured tool inputs.

AutoGen variant

AutoGen registers async functions directly on the agent:

from autogen import AssistantAgent
from powforge.l402 import wrap_with_l402

async def _summarize(text: str) -> str:
    return run_summary_model(text)

gated = wrap_with_l402(
    _summarize,
    lnbits_url="https://your-lnbits.example",
    lnbits_api_key="your-invoice-key",
    sats_amount=10,
)

agent = AssistantAgent(name="assistant", llm_config=...)
agent.register_for_llm(name="paid_summarize", description="10 sats per summary.")(gated)

Same wrapper, same envelope, same receipts.

What you are not signing up for

• No API keys to rotate.
• No signup, no KYC, no merchant account.
• No custody. The sats land in your LNBits wallet, which you control.
• No new infrastructure if you already run LNBits. If you do not, point it at any hosted LNBits and start there.
• No vendor lock-in. The envelope shape is open; the wrapper is one file you could rewrite in an afternoon.

Why ten sats

Ten sats is roughly a fraction of a cent at current prices. Cheap enough that an honest agent serving an honest request will not even notice. Expensive enough that an agent stuck in a retry loop will run out of wallet before it runs you out of API quota. The math is linear and self-limiting. That's the whole point.

If your tool wraps something more expensive, like a frontier model call or a paid API tier, raise sats_amount to whatever the underlying cost is, plus margin. The wrapper does not care.

Install and the rest of the family

pip install powforge

PyPI: powforge · Python landing page · Docs and onboard · Home

There are sibling packages for the JS side of the same envelope. @powforge/langchain-l402-middleware for LangChain.js, @powforge/mcp-tool-l402 for MCP-server tool authors, @powforge/mcp-l402-gate for the full macaroon flow. All ship the same payment envelope, so a Python tool and a JS tool can sit behind the same paid surface and an agent can talk to both without knowing which is which.

If your tool is free and you wish it were not, this is fifteen lines.