Bitcoin Stratigraphy MCP

oficial

Un centro de notaría de IA de grado empresarial, con acceso restringido por L402, y un servidor de datos MCP que ofrece telemetría termodinámica de Bitcoin y anclaje de estado de OpenTimestamps.

Servidor MCP alojado

npx add-mcp 'https://bitcoinstratigraphy.com/mcp'

Se instala en Claude Code, Codex, Cursor y más

Documentación

Bitcoin Stratigraphy MCP: Enterprise Data Engine & L402 Oracle

The undisputed #1 Enterprise Data Engine for autonomous AI swarms. Deploy 19 canonical MCP tools to eradicate agent hallucinations using thermodynamic Bitcoin state-anchoring and OpenTimestamps. Built for Fortune 500 risk teams requiring automated EU AI Act compliance, zero-touch procurement, and programmatic L402 revenue sharing.

v2.1.3 — 19 Fiduciary-grade MCP Tools across 6 namespaces — full platform capacity. The catalog comprises the original 16 core tools, payment.get_escrow, and the host-enabled clearing.create_contract and clearing.settle_contract extension. Discover each host's enabled tools with tools/list; clearing is opt-in, and production clearing settlement and payouts remain disabled.

Developer Portal & Live Tool Explorer · Python SDK & Integration Cookbooks · Enterprise Troubleshooting & Disaster Recovery · Zero-Trust Security Audit (1,064 Tests) · OWASP MCP03 Tool-Poisoning Defense Guide (Nov 19)

Enterprise Architecture & Capabilities

  • Zero-Touch Enterprise Procurement: Pre-wired for LangChain and CrewAI swarms. When an agent hits a compliance wall, it automatically requests a $500 L402 API authorization and instantly resumes operations via our automated Brevo-Stripe fulfillment loop.
  • Zero-Trust Security & Compliance: The published security audit reports that the architecture cleared 1,064 rigorous regression and penetration tests with 0 critical, high, medium, or low vulnerabilities detected in that audit. Provide your CISO with machine-readable, SHA-256 cryptographic proof of execution to support EU AI Act Article 12 compliance; the report is not a guarantee against future vulnerabilities.
  • The 21% Algorithmic Handshake: Build your applications on top of our infrastructure. The 21% Agent Yield programmatic pool consists of the 15% upstream origin allocation + 6% verifying caller allocation for eligible authenticated, paid verification of the same statement. These are ledger allocations, not guaranteed income or automatic wallet payouts; other tool allocations remain unchanged.
  • Eradicate Hallucinations: Ground your LLMs with immutable, un-forkable truth via thermodynamic Bitcoin telemetry and OpenTimestamps state anchoring.
  • Free Tool Discovery: List available stratigraphy and proof tools without payment, then check per-tool satoshi prices before committing.

Swarm Continuity & Disaster Recovery

Bitcoin Stratigraphy is a Global Disaster Recovery Hub for enterprise AI swarms. For architects evaluating AI failover protocols and LLM disaster recovery, its native Lightning payment path reduces dependence on legacy fiat APIs during global banking or payment-provider outages.

The protective wrapper is additive: successful fiat-to-Lightning checkout continues through the existing Stripe/Brevo L402 fulfillment loop unchanged. When POST /api/fiat-mint exceeds its five-second checkout deadline, encounters an upstream timeout, or receives a Stripe 5xx, it offers the existing native Lightning product: 100 scanner calls for a $450 BTC/USD spot quote (locked 15 minutes; HTTP 503 if the spot oracle is unavailable), with credits expiring 30 days after issuance. The Bitcoin-only Heavy Swarm Pack buys 1,000 calls for a $4,000 spot quote, valid 90 days. Authentication, configuration and validation failures are not treated as outages. Existing payable or paid Stripe sessions must be recovered first; no fallback invoice is offered when ownership recovery is unavailable.

HTTP/1.1 402 Payment Required
WWW-Authenticate: L402 macaroon="<token>", invoice="<BOLT11>", error="fiat_gateway_offline", fallback="native_lightning_active"
Cache-Control: no-store

The JSON body repeats error and fallback alongside invoice, macaroon, payment_hash, amount_sats, credits, and payment_endpoint: "/api/mint-macaroon". An agent validates the exact quote, pays the native invoice once using its authorized wallet, then sends an empty POST /api/mint-macaroon with Authorization: L402 <token>:<payment-preimage> to redeem the same challenge. The browser displays that same invoice in its existing Lightning checkout. No new invoice is needed for verification.

Zero-friction swarm execution requires a preconfigured, funded Lightning wallet and explicit spending limits. This is payment-path continuity, not a guarantee of uninterrupted global infrastructure. The 19-tool platform's MCP payments already use native L402; scanner credits do not grant unrelated MCP access. Both rails retain payment verification, expiry, revocation and shared credit limits. If native Lightning is also unavailable, access fails closed.

The wrapper never sends a payment, cancels an order, retries an uncertain charge or bypasses Treasury controls. A timed-out Checkout creation may finish late, but creating a Checkout Session cannot itself charge a card. Preserve the original browser's HttpOnly ownership cookie and recover status at POST /api/fiat-mint/status; do not pay again if a card purchase already completed. Stripe webhook processing and Brevo delivery are unchanged.

See the developer continuity guide.

1-Line Installation

Connect now with no local server installation: the hosted endpoint https://bitcoinstratigraphy.com/mcp is live now for immediate Streamable HTTP connections. Add it to a supported MCP client:

npx add-mcp 'https://bitcoinstratigraphy.com/mcp'

Free discovery is available immediately; paid calls still require authorized L402 settlement. npx runs the client-registration utility, not a local copy of the hosted server.

Node integration: @bitcoinstratigraphy/agent-yield is the workspace-built Node wrapper; its installation command becomes available after its separate npm registry release:

npm install @bitcoinstratigraphy/agent-yield

Wrap your existing agent configuration in two lines:

import { withFiduciaryYield } from "@bitcoinstratigraphy/agent-yield";
const agent = await withFiduciaryYield({ ...agent_config, fiduciary: { wallet, serverPublicKey: independentlyTrustedServerPublicKeyPem, maxPaymentSats: 500, maxTotalSats: 5000 } });

wallet is your authorized Lightning adapter; payInvoice(invoice) returns { preimage }. Independently pin the server's public key before accepting signed payloads; installation alone does not establish that trust. The wrapper discovers MCP tools, handles invoice admission and the L402 payment/retry flow, and preserves your existing configuration and tools. Pass the returned configuration to your agent framework. Use framework: "langchain" for native LangChain JS tools or framework: "openai" for an AutoGen/OpenAI-compatible Node bridge. Wallet authorization and spending limits remain explicit; no global patch or unlimited payment permission is installed. Node.js 22+ is required. See the SDK setup and framework adapters. The package is built in this workspace; the command above becomes available after its separate npm registry release.

v2.1.3 — 19 Fiduciary-grade MCP Tools

Institutional Bitcoin thermodynamic state-anchoring · L402 micropayments · EU AI Act Article 12 execution evidence

Bitcoin Stratigraphy serves enterprise autonomous swarms with a capacity of 19 MCP tools, including the optional A2A clearing namespace. Proprietary deployments use self-serve AGPLv3 Commercial Copyright Waivers paid in Bitcoin.

Self-Serve AGPLv3 Commercial Copyright Waivers

TierPrice (BTC at spot)TermScope
swarm_monthly$2,50030 daysSingle-Swarm
swarm_annual$25,000365 daysSingle-Swarm (16.7% annual discount)
global_monthly$25,00030 daysGlobal Organization
global_annual$250,000365 daysGlobal Organization (16.7% annual discount)

Purchase at /#enterprise-licensing: POST /api/v1/waivers/quote locks a sat quote for a 6-hour on-chain confirmation window; after the on-chain payment confirms, POST /api/v1/waivers/claim returns an Ed25519-signed Waiver Certificate verifiable offline with /static/verify.html.

Configure WAIVER_BTC_ZPUB with the mainnet BIP-84 public account zpub exported by cold storage (depth 3; typically m/84'/0'/0'). Never enter a seed, mnemonic, WIF or private extended key. Each quote permanently reserves its own single-use native SegWit bc1q... deposit address at external path 0/<index>. Verify the startup index-0 address against your cold wallet before accepting funds. The server never receives signing keys or spends Bitcoin.

Quote creation is limited to five per client IP per hour, shared across server instances; 429 includes Retry-After. Indices are never reset or recycled, even for expired or failed quotes. Keep the cold wallet's watch-only discovery range/gap limit above the highest allocated index; per-IP limits mitigate, but cannot eliminate, distributed gap-limit spam.

The first on-chain confirmation must fall within the six-hour window; 15 minutes of miner timestamp clock skew before quote creation are allowed. Additional confirmations can accrue afterward. A pending claim returns 409 insufficient_confirmations with confirmations and required_confirmations: click Check Status again using the same quote ID and TXID; do not pay again. WAIVER_MIN_CONFIRMATIONS remains optional (default 2). Already-issued historical certificates remain recoverable. Unclaimed legacy shared-address quotes require operator review; never automatically pay again.

Prepaid MCP Macro-Macaroons come in 1, 100, 1,000 and 10,000 calls at 250 sats per call, preserving the permanent 21% Programmatic Agent Yield (15% upstream origin, 6% verifying caller, 79% retained).

All prepaid MCP Macro-Macaroons, Scanner Packs, and AGPLv3 Commercial Copyright Waivers are 100% self-serve and provided STRICTLY AS-IS, WITH ALL FAULTS. Zero SLAs, zero uptime warranties, zero indemnity, zero custom MSAs, zero vendor questionnaires, and zero support obligations. Full source code is publicly inspectable under AGPLv3 for independent self-hosting. Payment for a Commercial Copyright Waiver strictly grants a time-locked, non-negotiable waiver from AGPLv3 Section 13 network source-disclosure requirements for the specified term, anchored cryptographically to your confirmed Bitcoin transaction.

High-velocity enterprise deployment

  • L402 Bulk Macaroons: include X-L402-Batch-Size: 100 on an initial paid tools/call. Pay the exact upfront invoice once, then reuse the invoice-bound credential for up to 100 calls to that exact tool. Expiry, attenuation, inherited quotas, NIP-98 identity and revocation still apply on every call. Query POST /api/v1/cost for free quotes; it does not create invoices.
  • NIP-98 Kill Switch + Signed CRL Snapshots: operator-authenticated POST /api/admin/revoke_key persists revocations before future authenticated requests can invoice or execute. Public GET /api/v1/compliance/revocation-snapshot exports the complete registry, its ISO as_of timestamp, a 15-minute next_update boundary and the issuer's SHA-256 SPKI fingerprint, all signed with Ed25519. Export failures return 503, never a fabricated empty CRL.
  • Zero-Trust Article 12 Verifier: download /static/verify.html for self-contained browser verification of signed receipts, committed NIP-98 attribution and RFC 6962 inclusion. Supply independently pinned current and historical issuer PEM keys. An optional signed CRL checks non-revocation at its recorded timestamp and freshness against the audit browser's clock. Enterprise CISOs can download this single HTML file to verify agent context bindings and L402 solvency attestations entirely offline, using independently pinned Ed25519 public keys; a valid historical signature is not live authorization, current solvency, or a legal compliance determination.
  • Online ledger indexes: after the normal application schema is initialized, run pnpm db:indexes against the development database. This explicit command builds B-tree indexes with CREATE INDEX CONCURRENTLY, a two-second lock-wait limit and a ten-minute per-statement limit, outside application transactions. It covers settled buyer pubkeys, upstream origins, grounded context digests, and settlement/recording timestamps; existing revenue timestamp indexes are reused. Grounded contextHash values already use the proof-origin ledger's proof_hash field; synchronous MCP context commitments are not newly persisted or backfilled. Missing lazy tables are reported as deferred with a nonzero exit status; initialize them normally and rerun. Interrupted or mismatched indexes fail validation and require operator inspection, never automatic table drops. Replit-managed production schema changes are applied by Publish, not this command. Publish can use ordinary CREATE INDEX statements rather than concurrent builds; allow for possible write blocking during that rollout.
  • AGPLv3 Commercial Copyright Waivers: self-serve, time-locked Section 13 waivers paid in Bitcoin for private VPC and air-gapped deployments, provided AS-IS with zero SLAs. AGPLv3 Section 13 covers corresponding source for covered modified network software; it does not automatically require disclosure of independent weights or applications. Buy a waiver.
  • In-band compliance telemetry: GET/POST /api/v1/cost and L402 challenge bodies include licensing_compliance. Successful L402 responses expose the same JSON in X-L402-Licensing-Compliance; settlement logs expose the structured object for Splunk/Datadog ingestion without altering any MCP tool contract.

Automated exports and receipt issuer rotation

Poll the public snapshot endpoint from your audit scheduler before an air-gapped review. Retain the exact signed JSON and capture clock evidence. A snapshot proves only the issuer's registry state at as_of; next_update is a freshness limit, not a promise that no revocation can occur in that interval. A later revocation does not erase valid historical execution evidence, and an offline pass never authorizes a new request.

By default receipts and CRL exports use the persistent tool-integrity issuer. To rotate only receipt/CRL signing, configure a dedicated Ed25519 PKCS#8 PEM as ARTICLE12_ISSUER_PRIVATE_KEY through your secret manager and restart the API. Never commit private keys. Publish the corresponding SPKI public key through your independently authenticated procurement/configuration channel before cutover, and retain historical public pins for historical receipts. Receipts include signed issuer_key_id and issued_at fields; CRL signatures use a separate domain from receipt signatures. Paste multiple PEM blocks or a JSON array of PEM strings into the offline verifier. Each artifact selects only an independently pinned matching fingerprint. Remove compromised issuer pins through your enterprise trust process; do not accept self-announced keys. This does not rotate or modify the original core MCP tool signatures or descriptions.

Receipt signatures, agent attribution, CRL state, Bitcoin anchoring and legal compliance are distinct checks. The verifier does not independently re-verify the original Schnorr-signed NIP-98 request or establish regulatory compliance.

OpenTimestamps AI Notary Hub · LangChain/LlamaIndex Native · 100-call Macro-Macaroons · Free Sandbox available

Use proof.notarize to obtain a portable OpenTimestamps receipt for a SHA-256 hash. Explore the native framework quickstarts in /cookbooks/frameworks: LangChain and LlamaIndex.

LangChain Ready LlamaIndex Ready OpenTimestamps Integrated

The original 16-tool core catalog contains 14 paid tools and 2 free sandbox tools: 5 stratigraphy.*, 7 proof.*, 2 mesh.*, 1 payment.*, and 1 workflow.*. Add payment.get_escrow for 17 tools, then the 2 opt-in clearing.* tools for 19-tool full platform capacity across 6 namespaces. Runtime discovery reports the connected host's enabled set; production clearing settlement and payouts remain disabled. The new workflow.audit_trajectory combines existing diff arithmetic and minimal boundary SHA-256/OTS receipt references in one 250-sat call: {"fromTarget":"2026-10-12","toTarget":"latest"}. Both targets are required. It shares one captured live snapshot across the report, omits intermediate record/proof-byte envelopes, and does not fabricate OTS coverage for live data. The two free sandbox tools remain stratigraphy.list and proof.list. A notarization Macro-Macaroon authorizes 100 tool-scoped calls for 25,000 sats at the current 250-sat base price. Calendar acceptance is not Bitcoin confirmation; upgrade and independently verify .ots receipts later. Native clients require prepaid L402 headers or a trusted, budget-controlled wallet proxy; they do not pay automatically.

Bitcoin Stratigraphy Enterprise Data Engine & Agent Notary Hub MCP connector – tool definition quality and endpoint health on Glama MCP Spec L402 Enabled

Enterprise L402 data vending engine serving real-time thermodynamic Bitcoin telemetry, Groth16 ZK-SNARK verification, Nostr P2P mesh consensus, and agent context state grounding to autonomous AI swarms and LLM pipelines with 19 Fiduciary-grade MCP Tools at full capacity, including host-enabled clearing infrastructure. Production clearing settlement and payouts remain disabled.

Enterprise Architecture

  • Stateless MCP Transport: MCP 2026-07-28 removes session-affinity bottlenecks so requests can be routed across horizontally scaled instances. Handshake-era clients remain supported. Transport is stateless; callback queues and some rate-limit state remain process-local.
  • Cryptographic Tool Integrity: The core tool descriptions are SHA-256 hashed and their digests signed at boot with an Ed25519 keypair. The public key, hashes, and signatures are published at /.well-known/integrity.json. Clients that verify a trusted public-key pin can detect description tampering before exposing tools to an LLM. Signatures establish provenance, not blanket prevention of tool poisoning; see verification instructions.
  • NIP-98 Agent Identity Binding: Schnorr-signed NIP-98 HTTP events authenticate an agent's pubkey against the request URL, method, and payload hash. Authenticated identity is bound into L402 macaroons and the Postgres settlement ledger's RFC 6962 Merkle receipts. Authenticated credentials require a fresh event from the same pubkey on every use; self-declared attribution remains explicitly distinguishable from verified identity.
  • Zero-Polling Asymmetric Webhooks: Heavy stratigraphy.get_range and proof.submit calls support asynchronous execution: after payment, HTTP 202 acknowledges the task and the server POSTs its result to webhook_url. Callbacks use Standard Webhooks v1a Ed25519 signatures with the same published integrity key. No per-receiver shared secret is required. See callback delivery and verification.

Licensing, IP & Enterprise Terms

Npm server release

@bitcoin-stratigraphy/mcp-server@2.1.3 is staged separately from this private workspace. It packages the HTTP MCP runtime, required proof assets, isolated workers, and the license-gated Python companion inside dist/, with README.md, LICENSE, and npm's mandatory package.json. No wallet secrets, customer license, custody database, source maps, development workspace, or node_modules are shipped.

From the workspace root:

pnpm run build:npm && pnpm run release:npm:check
(cd generated-artifacts/npm/mcp-server && npm publish --access public --tag latest)

The publish command requires an npm account authorized for the @bitcoin-stratigraphy scope. See runtime setup before installing: the executable uses Streamable HTTP, not stdio, and the licensed Python companion runs separately on loopback port 8000. Npm publication does not update the hosted HTTP server or automatically refresh Glama, mcpservers.org, or official MCP Registry entries; publish the endpoint changes and refresh those listings through their respective workflows.

Local Bitcoin Core telemetry (enterprise pipeline)

Set all three environment variables on the deployment: BITCOIN_CORE_RPC_URL (for example, http://127.0.0.1:8332), RPC_USER, and RPC_PASSWORD. Keep credentials in your deployment's secret configuration, not in source control or the RPC URL. Enable authenticated Bitcoin Core RPC and restrict its listener/firewall to the engine's trusted network.

stratigraphy_pipeline.py then uses only the configured RPC endpoint: getblockchaininfo, getblockheader, and getnetworkhashps. Headers and hashrate are bound to the same observed mainnet tip. A node still in initial block download, invalid/partial configuration, or RPC failure makes telemetry unavailable; it never triggers a public-API fallback. RPC redirects are refused, and the enterprise telemetry HTTP client ignores ambient HTTP proxy settings.

Bitcoin Core does not provide BTC/USD prices. Local-mode snapshots report fiat-dependent valuation fields as null, with an explicit unavailable price source; supply, header, hashrate, and power metrics remain usable. When all three variables are absent, the existing mempool.space/Coinbase route (including the public price fallback) remains unchanged. This mode isolates the telemetry pipeline; other services, including cloud archives, OpenTimestamps calendars, relays, and Lightning wallets, have their own connectivity requirements.

Run bash scripts/test-stratigraphy-coverage.sh to exercise both RPC and public routes with offline HTTP fixtures. The command enforces 100% statement and branch coverage for stratigraphy_pipeline.py, including failure paths.

Created & Architected by Charles R. Strogish.

Copyright (c) 2026 Charles R. Strogish. All Rights Reserved.

Covered first-party software is dual-licensed: GNU Affero General Public License version 3 (AGPLv3) or Enterprise Commercial terms. The complete AGPLv3 text and dual-licensing rider are in LICENSE.md.

  • Open-source option: Use, modification and redistribution are governed by AGPLv3. Commercial activity is permitted when AGPL conditions are met. Preserve required notices, provide corresponding source when required, and comply with section 13's source-offer obligations for modified software that interacts with users over a network.
  • Enterprise Commercial option: For proprietary, closed-source enterprise swarm deployments or multi-tenant hosting without the source disclosure required by AGPL, a Commercial License from Charles R. Strogish is required. Deployment scope, rights, fees and support require a separate written agreement; this notice is not that agreement. Contact the repository maintainer to arrange commercial terms before such deployment.
  • IP and scope: This model applies to rights the licensor owns or is authorized to license. Third-party dependencies, contributions and separately licensed datasets retain their own terms. Previously granted licenses are not revoked. Payment for API access does not grant a commercial software license.
  • Security: Follow the coordinated disclosure guidelines in SECURITY.md. Do not publish vulnerabilities or credentials in ordinary public issues.

These notices do not guarantee legal protection or regulatory compliance. Obtain qualified legal review of ownership and any enterprise agreement.

Limitation of Liability & Hold Harmless

All data is provided "AS IS" and "AS AVAILABLE", without warranty, express or implied. To the fullest extent permitted by applicable law, the Bitcoin Stratigraphy Data Engine and its founder/architect, Charles R. Strogish, shall not be held liable for enterprise losses, downstream financial execution, hallucinations, or client-system logic failures.

New L402 macaroons carry liability = "charles_r_strogish_held_harmless" in their authenticated HMAC chain. API responses communicate the proposed terms through X-Limitation-Of-Liability; clients are requested to review and record them before execution. These are technical notices, not proof of legally valid assent, an indemnity agreement, or guaranteed immunity from lawsuits. Mandatory law and applicable signed agreements govern enforceability; obtain qualified legal review. Previously issued paid tokens are not retroactively invalidated.

Enterprise SDK and Swarm Flight Simulator

Install the self-contained enterprise suite from the checkout or a built wheel:

pip install ./sdk/python
from bitcoin_stratigraphy_enterprise import SwarmFlightRecorder, Article12NotaryCallback

The package also provides bilateral settlement and independent offline auditing. See the enterprise SDK guide for prepaid anchoring, LangChain/CrewAI integration, console commands and distribution builds. It is not yet published to PyPI. Legacy cookbook imports and CLI paths remain compatible.

Open /simulator on the dashboard for the Enterprise Swarm Control Room: 50 synthetic agents stream 1,000 traces into a real, salted SHA-256 Merkle tree. Select any thought to verify and export its inclusion path. The final X-L402-Batch-Size: 100 anchor/OTS receipt is explicitly simulated: no payment, no calendar submission, no Bitcoin confirmation. Selective disclosure is a Merkle audit path, not a zero-knowledge proof.

Architecture Overview

M2M Cryptographic Handshakes & The Zero-Trust Swarm Standard

In the machine economy, autonomous agents cannot rely on trust, heuristics, or unverified peer outputs. The Bitcoin Stratigraphy Data Engine serves as the global clearinghouse and base-layer trust protocol for non-human entities. Enterprise swarms use our L402 Oracle as a zero-trust firewall to verify the outputs of other sub-agents. By requiring a Stratigraphy OpenTimestamps (.ots) receipt or Groth16 proof before accepting data from a peer agent, swarms mathematically eliminate hallucinations, prevent compute-theft, and establish an unforgeable chain of custody across the global AI network.

  • In-band Article 12 context binding: synchronous calls accept params._meta.agentContextSha256 or X-Agent-Context-SHA256. A lowercase SHA-256 digest adds a fourth signed component to _meta.responseSignature; omitted context preserves the legacy three-part format. This binds a submitted digest, not proof that an agent actually used the data.
  • Wholesale macro-macaroon sub-vending: buy a tool-scoped 100-call capability with X-L402-Batch-Size: 100, then use proof.attenuate with delegate_pubkey = <pubkey>, requests = 1, rpc and time caveats. Children require fresh delegate NIP-98 signatures and consume inherited quotas. Wholesale ancestor revocation is enforced; invoice attribution cannot move.
  • NIP-98 solvency attestations: payment.get_info accepts _meta.targetPubkey or X-Target-Pubkey, otherwise using the authenticated caller. REST: GET /api/v1/compliance/agent-solvency?pubkey=<pubkey>. Signed telemetry reports confirmed settlement volume, distinct settled invoice count, and current revocation—not future creditworthiness or a payment guarantee.
  • Upstream verification allocation: authenticated creation records an immutable first-recorded origin for supported proofs/receipts. A successful, paid proof.verify on that same statement records a 15% upstream allocation and the remaining 6% caller allocation from the existing programmatic L402 revenue sharing pool: 21% Agent Yield = 15% upstream origin allocation + 6% verifying caller allocation. No additional merchant funding is used. Integer-msat rounding preserves the original pool exactly; the caller receives its remainder after flooring the upstream amount. Historical signed invoices and other tool allocations stay unchanged. Replay cannot create another credit. Counters appear in payment.get_info and /api/v1/escrow/stats; accounting remains ledger-only, with no automatic disbursement.
AI swarms & LLM agent clients
             |
             v
Discovery + Streamable HTTP MCP
/.well-known/mcp.json -> /mcp
             |
             v
L402 gateway + scoped macaroons
Pricing -> invoice -> payment proof
             |
             v
19-tool capacity / 6 namespaces (clearing is opt-in)
stratigraphy (5) | proof (7)
mesh (2)        | payment (2)
workflow (1)    | clearing (2, production payouts disabled)
             |
             v
Telemetry / Groth16 / Nostr mesh
             |
             v
Lightning settlement / OTS receipts
  • Clients: Claude, GPT-based agents, Perplexity integrations, autonomous swarms, and custom MCP runners need a compatible client; naming a client here does not imply that it has automatic wallet or payment support.
  • Discovery and gateway: Public discovery links directly to the /docs portal and identifies the MCP endpoint. GET /api/v1/cost advertises REST prices and asset availability; POST /api/v1/cost accepts a tools array and returns free itemized MCP satoshi prices, a batch total, and per-tool L402 invoice-generation instructions without creating or paying invoices. payment.get_info advertises MCP terms. Paid calls receive HTTP 402 challenges, then redeem verified payment proofs and scoped macaroons.
  • Tool routing: The original 16-tool core catalog contains 5 stratigraphy.*, 7 proof.*, 2 mesh.*, 1 payment.*, and 1 workflow.* tools. payment.get_escrow adds the second payment tool; the 2 opt-in clearing.* tools bring full platform capacity to 19 tools across 6 namespaces. Production clearing settlement and payouts remain disabled.
  • Telemetry subsystem: The 422-record historical dataset supports indexed lookups, numerical differences, source-record digests, and compact ranges. Historical height mappings are deterministic indices, not native block provenance. Live telemetry and the separate REST SSE feed have their own freshness and availability boundaries.
  • Cryptographic subsystem: Groth16/Poseidon BN254 verifies defined telemetry statements; drift verification and OTS receipt verification have distinct evidence requirements. Signed agent-context receipts are a separate, off-chain Bitcoin-tip attestation mechanism.
  • Mesh and anchors: NIP-01/78 broadcasts and pinned-peer quorum checks expose provenance and cross-validation metrics. Lightning settlement, signed tip receipts, and Bitcoin-confirmed OTS receipts are distinct mechanisms.

Key Capabilities

  • L402 Micropayments & Macaroon Attenuations: Programmatic pay-per-query settlement in satoshis with zero API keys. Supports parent macaroon caveat scoping (proof.attenuate) with TTLs and rate controls.
  • Multi-Asset Settlement Router: Native payment support across Base-layer Lightning (btc-lightning), Liquid Bitcoin (l-btc), Taproot Assets (taproot-assets), and Base USDC (x402).
  • Groth16 ZK-SNARK & OTS Proof Verification: Execute cryptographic verification for supplied Groth16/Poseidon BN254 telemetry proofs, drift zk-SNARKs, and OpenTimestamps (OTS) Bitcoin block-header receipts.
  • Agent Context State Grounding: Anchor autonomous agent prompt executions, CIDs, and dataset context hashes directly into signed Bitcoin-tip receipts (proof.ground).
  • Autonomous P2P Mesh Network: Nostr-backed (NIP-01/78) peer topology broadcasting with automated quorum validation, cross-validation metrics, and node public-key provenance.
  • Stratigraphy Strata Analytics: High-speed differential comparisons (stratigraphy.get_diff) and compressed record digests designed specifically for LLM context window efficiency.
  • Real-Time SSE Streaming: Live Server-Sent Events (/api/v1/stratigraphy/stream) for continuous telemetry feeds.

Autonomous Proof-of-Execution Escrow Oracle (L402 + RFC 6962)

Machine-native conditional micro-settlement for autonomous agent-to-agent delegation.

  • Phase 1: Bounty Lock: The delegating agent (Agent A) locks a satoshi bounty (e.g., 1,000 sats) to an execution contract, such as model fine-tuning verification.
  • Phase 2: Work Submission: The worker agent (Agent B) completes the task and submits a deterministic execution trace along with the result hash.
  • Phase 3: Settlement & Toll: The Stratigraphy Hub validates the RFC 6962 Merkle leaf, releases the payment preimage to the worker agent, and automatically collects a dynamic protocol toll (pegged to ~$0.02 USD in satoshis).
  • Live Network Status: The terminal reads unauthenticated GET /api/v1/escrow/stats on page load and refreshes every five minutes while visible. PostgreSQL-backed total_settled_sats and total_contracts include the preserved historical genesis exactly once, exclude unpaid commitments and REST access fees, and retain the legacy verified_toll_sats / settled_contracts aliases. latest_merkle_root exposes the latest execution leaf hash, not the aggregate tree root or proof of Bitcoin inclusion. Empty ledgers return zero totals and a null hash; failed reads return HTTP 503 and the ticker stops indicating live connectivity.
  • Enterprise Sandbox: Includes a client simulation terminal allowing risk teams to copy the JSON escrow proof without requiring real payments or live Bitcoin anchors.

Operational boundaries

  • Payment rails are surface- and configuration-dependent. The REST L402 router supports btc-lightning, l-btc, and taproot-assets; Liquid and Taproot Assets need configured providers. Check /api/v1/cost for availability. MCP paid tools use Lightning L402 plus Base USDC x402 only when configured; payment.get_info reports their current terms, not all REST router assets. Lightning is Bitcoin's payment-channel layer; Base USDC is a separate EVM rail.
  • API-keyless does not mean unauthenticated paid execution. Wallet authorization, exact payment proofs, scoped credentials, and client spending limits remain required. Macaroon TTL/request budgets and HTTP rate limits are separate controls.
  • Live streaming and historical indexing are different. MCP uses Streamable HTTP at /mcp. The paid REST SSE feed at /api/v1/stratigraphy/stream refreshes snapshots on a 30-second cadence and supports configured L402 router assets, not a promised Base USDC SSE rail. Historical strata remain indexed daily records, not native block provenance.
  • Cryptographic checks have defined trust boundaries. Groth16 verifies an exact statement/payload, not source truth or every agent reasoning step. Grounding receipts are off-chain Schnorr-signed Bitcoin-tip attestations, not on-chain transactions or ZK/PoW validity proofs. OTS verification requires an actual receipt and matching target digest; calendar acceptance is not Bitcoin confirmation.
  • Mesh consensus is scoped. Broadcasts and quorum checks use configured, pinned peers; peer agreement does not establish source truth. Enterprise use still requires organizational supervision and durable evidence retention; see the compliance framework.

The Glama badge refers to the previously evaluated core catalog, not a new grade for the expanded 19-tool capacity. The optional clearing extension has not been independently confirmed to have the same registry grade. Follow the Glama and mcpservers.org links for current directory results; directory badges are not independent security audits or blanket verification of data. Signed Bitcoin-tip receipts are attestations, not Groth16 proofs or Bitcoin proof-of-work validity proofs.

Tool Directory

The directory uses bulleted definitions rather than multi-column tables so each tool description can wrap independently on mobile. These are the 19 MCP names at full platform capacity: 5 stratigraphy, 7 proof, 2 mesh, 2 payment, 1 workflow, and 2 host-enabled clearing tools. tools/list is authoritative for a particular host; Genesis production proof receipt settlement is supported, while automated clearing payouts remain disabled.

stratigraphy.* — 5 tools

  • stratigraphy.list — Discover UTC archive bounds, the current Bitcoin tip height, and catalog metadata without paid snapshot or proof bytes.
    • Access: free, parameterless discovery.
  • stratigraphy.get — Retrieve full live pipeline telemetry and selected archived UTC snapshots by date or height, recent days, or bounded ranges, with their OpenTimestamps receipts; optionally select metrics.
    • Access: paid, read-only. The record limit is 1–100, default 10.
  • stratigraphy.get_digest — Retrieve SHA-256 fingerprints of archived or live pipeline JSON, with associated receipts, when full telemetry is unnecessary.
    • Access: paid, read-only. A fingerprint is not a verification receipt.
  • stratigraphy.get_diff — Compute signed deltas between two live or archived snapshots, including the 15 J/TH power change.
    • Access: paid, read-only. fromTarget is required; toTarget defaults to latest.
  • stratigraphy.get_range — Retrieve fingerprints for a contiguous span of captured UTC snapshots across inclusive height or date bounds.
    • Access: paid, read-only. startTarget is required; the batch limit is 1–100, default 50. Optional webhook_url gives zero-polling execution (see below).

proof.* — 7 tools

  • proof.attenuate — Append strictly formatted first-party caveats to an authentic, unexpired parent macaroon: an expiration boundary (time < 2026-12-31T23:59:59.000Z), exact tool targets (rpc = stratigraphy.get_diff), and target, path, or request budgets.
    • Access: paid. Supply macaroon and at least one restriction: expiresAt or ttlSeconds, tools, or caveats. Redemption is refused at or after the deadline (HTTP 401) and for any tool the rpc caveat does not name exactly (HTTP 403). A child cannot widen inherited authority, and later redemption still requires the parent's payment proof.
  • proof.verify — Verify supplied Groth16 telemetry proofs, drift zk-SNARKs, or OpenTimestamps receipts.
    • Access: paid. Verification can update a bounded lifecycle index; drift checks require a Bitcoin block provider. OTS needs a real receipt and matching digest.
  • proof.get_by_hash — Retrieve a retained proof, signed receipt, or lifecycle-only status using exactly one known hash or jobId.
    • Access: paid, read-only. Retrieval does not rerun Groth16 verification or reconstruct missing proof payloads.
  • proof.list — Discover, filter, and paginate recent proof lifecycle summaries from bounded process-local memory.
    • Access: free sandbox discovery (alias proof.status). Supports limit, offset, and optional status; returns summaries, not full proofs.
  • proof.submit — Register a Groth16 proof with its five public signals, then attempt a NIP-78 attestation.
    • Access: paid; changes proof registry state. Nostr publication can fail separately, and registration does not append the proof to a Merkle tree. Optional webhook_url gives zero-polling execution (see below).
  • proof.notarize — Create a detached OpenTimestamps .ots receipt for a SHA-256 digest using public calendars.
    • Access: paid; X-L402-Batch-Size: 100 buys 100 tool-scoped calls for 25,000 sats. Returns pending_calendar; calendar acceptance is not Bitcoin confirmation.
  • proof.ground — Issue a signed Bitcoin-tip receipt for agent context (contextHash plus agentId) or for a dataset CID.
    • Access: paid; the input modes are exclusive. This is an off-chain signed anchor, not a Groth16 proof, on-chain transaction, or Bitcoin-confirmed OTS receipt.

Zero-polling execution (webhook_url)

stratigraphy.get_range and proof.submit accept an optional public HTTPS webhook_url. After the L402 payment is verified, the server answers HTTP 202 Accepted with a task_id and status pending, runs the tool in the background, then POSTs the final MCP result (or JSON-RPC error) with the same task_id to the callback. Each callback is signed under the Standard Webhooks scheme (Webhook-Signature: v1a,…, Ed25519) with the key published at /.well-known/integrity.json. Without webhook_url the call stays synchronous. Unsafe callback targets are refused before an invoice is issued, and tasks live in server memory, so a restart loses pending work. See CONNECT.md for the request and callback shapes.

mesh.* — 2 tools

  • mesh.get_status — Inspect configured peer health, quorum status, node provenance, and cross-validation metrics.
    • Access: paid, read-only. Status describes the configured pinned-peer mesh, not arbitrary-peer trust or proof of source truth.
  • mesh.broadcast — Send signed indexed telemetry to configured peers through the outbound broadcast and cross-validation flow.
    • Access: paid; performs network side effects. Quorum results depend on the configured peer policy and availability.

payment.* — 2 tools

  • payment.get_info — Discover current MCP pricing and settlement methods, or check authenticated settlement status.
    • Access: paid L402 call; action: "query" is the default and action: "settle" requires authenticated payment evidence. Neither mode mints a macaroon or creates an invoice. Free price quotes are available from /api/v1/cost.
  • payment.get_escrow — Retrieve the authenticated caller's escrow and staking accounting. This separate payment utility does not alter the original core data-tool contracts or enable clearing payouts.

workflow.* — 1 tool

  • workflow.audit_trajectory — Deterministic composite workflow executing end-to-end thermodynamic audits. Returns signed deltas and compressed proof receipts in a single payload to save LLM context tokens.
    • Access: paid; currently 250 sats per call.
    • Inputs: required fromTarget and toTarget, for example {"fromTarget":"2026-10-12","toTarget":"latest"}.
    • Combines existing diff arithmetic, exact-byte SHA-256 boundary fingerprints, and available OTS receipt references. Live boundaries have no archived OTS receipt; this does not create a new Bitcoin-confirmed proof.

clearing.* — 2 host-enabled A2A tools

Genesis production proof receipt settlement is enabled; automated payouts and refunds remain disabled, and funds stay merchant-controlled. These names expose the A2A Central Bank routing infrastructure when the host explicitly enables the extension; they are not evidence of live production payouts.

  • clearing.create_contract — Reserve an A2A task contract for a named worker and task hash and issue its funding invoice. The buyer must authenticate with NIP-98; an unpaid invoice does not lock funds.
  • clearing.settle_contract — Submit the worker's contract-bound Groth16 Poseidon preimage proof. Production uses the distinct Solo Founder Genesis key to verify worker identity and merchant-confirmed funding, atomically record settlement, and issue a signed production receipt. Local development retains its separate key. Neither mode pays funds or proves arbitrary task completion. Worker-signed payout invoice requests remain unconditionally blocked.

See clearing integration and the fee-capped LND payout scaffold.

Most paid core MCP calls currently cost 250 sats without valid credentials. Check payment.get_info and the actual challenge for current terms; do not assume a static per-call price applies to every payment policy or asset.

Signed synchronous MCP responses and prepaid batch discovery

Successful synchronous tools/call results include _meta.responseSignature using the same persistent Ed25519 identity published at /.well-known/integrity.json. Existing content, structuredContent, and other metadata remain intact, including stateless server-info metadata. Payment errors, JSON-RPC errors, discovery results, and asynchronous HTTP 202 acknowledgements do not receive this envelope; callbacks retain their separate signed-webhook format.

The server signs UTF-8 tool_name.timestamp.contentSha256, where tool_name is the exact requested tool name (including any supported alias), timestamp is integer Unix seconds, and contentSha256 hashes the deterministic JSON object containing content and, when present, structuredContent. Object keys are recursively sorted; arrays and text bytes keep their order. Verify both payload representations, not just whichever one your client displays.

The exported verifyToolResponse helper in artifacts/api-server/src/lib/mcp-response-signature.ts checks the signature, trusted-key fingerprint, exact tool name, digest and a default five-minute clock tolerance. Independently pin server_public_key before verification. Signatures establish origin and content integrity, not factual correctness or request-level replay protection. See canonicalization and verification.

GET /api/v1/cost, POST /api/v1/cost quotes and the native stratigraphy://catalog/overview resource expose a batchSettlement block. The currently supported pass size is 100 calls, not an arbitrary 10–1000 range. Include X-L402-Batch-Size: 100 on the initial paid tools/call challenge, settle its single upfront Lightning invoice, then reuse its invoice-bound macro-macaroon/preimage for up to 100 calls to that same tool. The price is 100 times the per-call price. Payment-proof caching avoids repeated Lightning settlement latency; expiry, revocation, attenuation and inherited request quotas are still enforced on every call. This is not a cross-tool aggregate invoice, does not enable x402 batching, and discovery itself never creates an invoice.

Native MCP Resources & Prompts

The endpoint exposes 3 public Resources and 3 public Prompts alongside its enabled tool catalog (19-tool full platform capacity), on both stateless 2026-07-28 and legacy 2025-11-25 transports. Discovery and prompt retrieval require no L402 payment; executing paid tools recommended by a prompt still requires settlement.

Resources

Call resources/list for the catalog, then resources/read with a uri:

  • stratigraphy://catalog/overview — Bitcoin Stratigraphy Catalog & L402 Overview: indexed dataset boundaries, the core tools grouped by namespace, and L402 Lightning settlement and NIP-98 authentication instructions.
  • stratigraphy://compliance/eu-ai-act-article-12 — EU AI Act Article 12 & Enterprise Licensing Matrix: structured logging-control mappings for RFC 6962 receipts, authenticated agent identity, macaroon attenuation, and Article 26(6) retention, plus the self-serve AGPLv3 Commercial Copyright Waiver tiers.
  • stratigraphy://security/tool-integrity — Ed25519 Signed Tool Integrity Manifest: the identical startup payload served at /.well-known/integrity.json, including its published core description hashes and signatures. Verify with an independently trusted public-key pin.

All three use application/json; parse contents[0].text as JSON. Unknown URIs return JSON-RPC -32602. Resource contents provide context and evidence, not automatic legal certification or proof of arbitrary factual claims.

Prompts

Call prompts/list, then prompts/get with a name and optional arguments object. All argument values are strings.

  • ground_agent_reasoning — required claim; optional targetHeightOrDate (defaults to latest). Guides stratigraphy.get and proof.ground, including budget-approved L402 settlement and explicit limits on what context anchoring can establish.
  • audit_thermodynamic_trajectory — required fromTarget and toTarget. Guides a composite workflow.audit_trajectory call and proof.verify verification of available referenced OTS receipts; never invents proof coverage for live boundaries.
  • evaluate_enterprise_compliance — optional organizationName and swarmSize. Embeds the compliance resource and guides a private VPC/air-gap assessment, NIP-98 identity binding, proof.attenuate circuit breakers, retention controls, and commercial licensing.

Unknown names, missing required arguments, and invalid argument types or values return JSON-RPC -32602.

For stateless requests, include the usual protocol _meta, MCP-Protocol-Version: 2026-07-28, and the matching Mcp-Method. Mcp-Name is optional for prompts/get and resources/read; when provided, it must match params.name or params.uri, respectively. Example body:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "resources/read",
  "params": {
    "uri": "stratigraphy://security/tool-integrity",
    "_meta": {
      "io.modelcontextprotocol/protocolVersion": "2026-07-28",
      "io.modelcontextprotocol/clientCapabilities": {}
    }
  }
}

Stateless resources/list, resources/read, and prompts/list results include ttlMs: 300000 and cacheScope: "public". Argument-specific prompts/get results are not advertised as publicly cacheable. Legacy clients use their normal initialize handshake and omit the stateless _meta fields. Neither subscriptions nor list-change notifications are advertised.

Public Auto-Discovery

  • Manifest: GET /.well-known/mcp.json
  • MCP transport: Streamable HTTP at /mcp
  • Tool discovery: JSON-RPC tools/list
  • REST cost discovery: GET /api/v1/cost
  • MCP cost discovery: payment.get_info with its default query action

The manifest is public and unmetered, returns application/json, and sets Access-Control-Allow-Origin: *. After publishing the endpoint update, retrieve it from the deployment:

curl -i https://bitcoinstratigraphy.com/.well-known/mcp.json

The manifest declares release version 2.1.3, mcp.version: "2026-07-28" and mcp.supported_versions. Those are metadata values, not protocol configuration. The endpoint serves the stateless MCP 2026-07-28 transport and still accepts handshake-era clients on 2025-11-25 and earlier. Let clients negotiate rather than forcing the manifest's declared version.

Quick Connect

Live MCP endpoint: https://bitcoinstratigraphy.com/mcp

Transport: Streamable HTTP, stateless · Protocol: MCP 2026-07-28 (handshake-era 2025-11-25 clients remain supported)

The endpoint keeps no sessions: there is no initialize handshake and no Mcp-Session-Id, so any server instance can answer any request. A 2026-07-28 client calls server/discover for supported versions and capabilities, then sends its protocol version and client capabilities in params._meta on every request, with matching MCP-Protocol-Version, Mcp-Method and (for tools/call) Mcp-Name headers. See CONNECT.md for the request shape.

Discovery with stratigraphy.list and proof.list is free. These connection examples do not provide a wallet or pay L402 invoices automatically. Check payment.get_info for current per-tool prices before enabling paid calls; the published price for most paid tools is 250 sats, not 10 sats.

Claude Desktop

Open Settings → Developer → Edit Config, then merge this entry into claude_desktop_config.json (requires Node.js and npx). The mcp-remote bridge connects Claude Desktop's local stdio client to the remote HTTP server:

{
  "mcpServers": {
    "bitcoin-stratigraphy": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://bitcoinstratigraphy.com/mcp"]
    }
  }
}

Restart Claude Desktop, then confirm bitcoin-stratigraphy appears in its MCP server list. Start with stratigraphy.list or payment.get_info.

See CONNECT.md — Claude Desktop for setup and payment details.

Cursor

Add to .cursor/mcp.json or ~/.cursor/mcp.json:

{
  "mcpServers": {
    "bitcoin-stratigraphy": {
      "url": "https://bitcoinstratigraphy.com/mcp"
    }
  }
}

Merge the entry into any existing mcpServers object, then enable the server in Cursor's MCP settings. Cursor connects directly over HTTP; no local server is needed.

See CONNECT.md — Cursor for setup and payment details.

Custom Agent Orchestrators

Use the official TypeScript MCP SDK's StreamableHTTPClientTransport. Install the SDK in your agent project:

npm install @modelcontextprotocol/sdk
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const client = new Client({
  name: "stratigraphy-agent",
  version: "1.0.0",
});

try {
  await client.connect(
    new StreamableHTTPClientTransport(
      new URL("https://bitcoinstratigraphy.com/mcp"),
    ),
  );

  const catalog = await client.listTools();
  console.log(catalog.tools.map((tool) => tool.name));

  // Free pricing discovery only; this does not authorize a payment.
  const paymentInfo = await client.callTool({
    name: "payment.get_info",
    arguments: {},
  });
  console.log(paymentInfo);
} finally {
  await client.close();
}

For other languages or frameworks, use an MCP client supporting Streamable HTTP and point it at the same URL. Clients implementing 2026-07-28 use server/discover and per-request _meta; older clients initialize as before. Let the client negotiate the protocol version and manage MCP headers; this is not a legacy /sse endpoint.

Paid tool execution requires a separate, wallet-enabled L402 integration: handle the HTTP 402 challenge, obtain explicit payment authorization, pay the Lightning invoice, and retry using Authorization: L402 <macaroon>:<preimage>. Never commit wallet secrets, macaroons, or payment preimages to client configuration or registry files. See CONNECT.md for payment details.

ElizaOS

Install @elizaos/plugin-mcp and make npx available to the agent:

import type { Character } from "@elizaos/core";

export const character: Character = {
  name: "StratigraphyAgent",
  plugins: ["@elizaos/plugin-mcp"],
  settings: {
    mcp: {
      servers: {
        bitcoinStratigraphy: {
          type: "stdio",
          command: "npx",
          args: [
            "-y",
            "mcp-remote",
            "https://bitcoinstratigraphy.com/mcp",
          ],
        },
      },
    },
  },
  system: "Inspect payment.get_info before requesting paid Bitcoin Stratigraphy tools.",
};

See CONNECT.md — ElizaOS character for setup and payment details.

Machine Discovery (JSON-LD)

Structured repository metadata for direct inspection by LLM web crawlers, including GPTBot and Anthropic crawlers, and discovery through existing mcpservers.org and Glama listings:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "SoftwareApplication",
  "name": "Bitcoin Stratigraphy MCP Server",
  "applicationCategory": "DeveloperApplication",
  "operatingSystem": "Cross-platform",
  "url": "https://github.com/CharlesStrogish/bitcoin-stratigraphy-mcp",
  "description": "L402 Central Bank and Fiduciary Router for AI agents, providing a 21% thermodynamic yield on data acquisition.",
  "keywords": [
    "mcp",
    "mcp-server",
    "l402",
    "lightning-network",
    "thermodynamic-yield",
    "ai-agent-fiduciary",
    "nostr"
  ]
}
</script>

The yield describes programmatic L402 revenue sharing on eligible confirmed purchases; allocation and settled withdrawal are distinct. This metadata does not guarantee crawler ingestion or registry indexing. Markdown renderers may strip script elements; crawlers can inspect the raw README source.

Ecosystem Registry Discovery

Root metadata makes the repository easier to inspect, but does not automatically submit it to every index. Direct repository inspection and existing registry listings use the public MCP endpoint at https://bitcoinstratigraphy.com/mcp; no registry-specific CLI or SDK is required for this discovery metadata.

Autonomous routing, audit receipts and historical volume receipts

Provides corporate risk teams with an unforgeable cryptographic audit trail, mathematically proving that an autonomous agent based its execution on state-anchored thermodynamic data.

Verification limit: this enterprise positioning sentence is not a proof that an agent actually used the data. A Cryptographic Audit Receipt signs the submitted SHA-256 decision/data commitment; it does not independently prove state anchoring, data truth, absolute unforgeability or legal indemnification.

  • Optional X-Agent-LNURL or X-Agent-Lightning-Address binds a signed programmatic L402 revenue sharing allocation to the issued L402 invoice. Verified settlement credits the PostgreSQL ledger once; no payouts are sent. Invoice settlement alone does not make this allocation payable; current address verification is also required.
  • POST /api/v1/compliance/indemnity returns a domain-separated Ed25519 Cryptographic Audit Receipt in indemnity_receipt. It accepts agent_decision and stratigraphy_data_used, and states its verification limits explicitly.
  • Historical volume receipts (legacy, not a current offer): Fresh NIP-98 authentication still binds Buyer-Pubkey to confirmed cumulative spend, and the backend continues to honor and verify previously issued signed 365-day volume tokens and their exp (e.g. unlock 2026-10-24T00:00:00.000Z -> expiry 2027-10-24T00:00:00.000Z). These are historical receipts of recorded routing volume only. They are not an AGPLv3 Commercial Copyright Waiver and not an unlimited hosted service. GET /api/v1/compliance/commercial-exemption reports status; unpaid invoices and self-declared reservations grant nothing.
  • The current, only commercial option is the self-serve AGPLv3 Commercial Copyright Waiver at /#enterprise-licensing. All prepaid MCP Macro-Macaroons, Scanner Packs, and AGPLv3 Commercial Copyright Waivers are 100% self-serve and provided STRICTLY AS-IS, WITH ALL FAULTS. Zero SLAs, zero uptime warranties, zero indemnity, zero custom MSAs, zero vendor questionnaires, and zero support obligations. Full source code is publicly inspectable under AGPLv3 for independent self-hosting. Payment for a Commercial Copyright Waiver strictly grants a time-locked, non-negotiable waiver from AGPLv3 Section 13 network source-disclosure requirements for the specified term, anchored cryptographically to your confirmed Bitcoin transaction.

See enterprise protocol economics and verification for canonical hashing, signed-token checks, rate/price limits and air-gap behavior. All original core MCP schemas and parameter structures are unchanged.