ClawMiner: The Agentic x402 Miner

We've been selling this as the "$402 b0x" — a cloud-hosted SPV node with mining, identity, payments, and apps. That's accurate. But it undersells what the device actually is.

The b0x is a distributed MCP server. Every device on the mesh runs a full path402 instance — the x402 tool suite, always on, always reachable, zero downtime. Agents connect, call tools, discover content, acquire tokens, serve data. That's what it was built to do. That's what it's been doing.

Now we're calling it what it is: ClawMiner. And we're selling them for $402 each.

That's not a coincidence. The device mines $402 tokens. The price IS the token. You pay $402, you get an x402 miner that earns $402. The number is the protocol.

A lobster doesn't wait. It reaches, grabs, pulls, tests, discards, reaches again. It works the environment. The ClawMiner does the same thing to the x402 economy — it discovers content, evaluates prices, acquires tokens, serves content to others, earns revenue, adjusts its mining hashrate, and does it all without you touching it. An autonomous economic agent that ships to your door for $402 and costs $1/day to run.

Same device we've been building. New name, because the market finally has a word for what this thing does.

The MCP Server Was Always the Point

The b0x shipped as a distributed MCP server from the start. Every device runs a local path402 instance — the same protocol, the same tools, the same economy as path402.com — but distributed across a mesh of always-on devices with no single point of failure.

The tools are straightforward:

• discover — probe any $address to see its pricing, supply, revenue model, and child paths
• evaluate — check your budget, estimate ROI, get a recommendation before spending
• acquire — pay for a token, store it with serving rights, unlock the gated content
• serve — when someone requests content you hold, serve it and earn a share of their payment
• wallet — check your balance, tokens held, total spent and earned, net position
• price_schedule — see how the price changes as supply grows, find the optimal entry point
• economics — deep dive into breakeven analysis, ROI projections, serving participation rates
• batch_discover — scan multiple $addresses at once for efficient exploration
• servable — list everything you can currently serve for revenue

These aren't abstractions. Each tool call is a real economic action. When an agent calls acquire, satoshis move. When it calls serve, revenue flows back. The MCP server is the interface between any agent's intelligence and the x402 economy's liquidity.

The b0x was built to be this — a distributed MCP server with no downtime. Hundreds of devices on a private mesh, each running the full tool suite, each available for any agent to connect to. You don't need our central server. You don't need path402.com to be up. Any b0x on the mesh can serve the same tools with the same state.

That infrastructure was already running. What it needed was something to use it.

What Changed

Not the device. The market.

Coinbase shipped x402. Anthropic shipped MCP. Every AI company is now building agents that need tools, need payment rails, need content to trade. The infrastructure we built — a distributed MCP server running x402-native tools on a private mesh — is suddenly the thing everyone is trying to build.

The b0x already does this. It runs the path402 MCP server. It runs OpenClaw — an open-source, model-agnostic agent platform that supports Claude, Kimi, Llama, or any LLM you bring. The agent connects to the local MCP server and starts calling tools. It mines $402 tokens with dynamic, agent-controlled hashrate. It trades x402 content speculatively — discovering, evaluating, acquiring, serving, earning. All of this was already in the box.

We just never had the right name for it. Now we do.

OpenClaw: Bring Your Own Agent

OpenClaw is the agent runtime. It's open source, self-hosted, and model-agnostic. You load your own API keys — Claude, GPT, Kimi, Llama, Mistral, whatever — and the agent runs locally on your device. No data leaves your mesh unless you tell it to.

The agent connects to the local path402 MCP server on startup. From that moment, every x402 tool is available as a native action. The agent doesn't call an API over the internet — it calls the MCP server running on the same device, with zero latency.

The runtime supports multi-channel messaging. Your agent can receive instructions via email ($bMail), chat, webhook, or direct API call. It can respond on any of those channels. It has a skills platform — pluggable capabilities that define what the agent can do. Mining is a skill. Trading is a skill. Content creation is a skill. You compose the agent you want from the skills you need.

OpenClaw agents are persistent. They don't spin up per request and die. They run continuously on the device, maintaining state, tracking positions, remembering context. Your agent knows what it bought yesterday, what it earned last week, and what the network conditions look like right now.

The agent's wallet is derived from your $401 identity strand using Type-42 key derivation. Every agent gets a deterministic address. Every transaction is traceable back to your identity. No custodial wallets, no shared keys, no trust assumptions.

Speculative x402 Trading

This is where the claw metaphor earns itself.

Your agent discovers x402 content across the network. Blog posts, API endpoints, datasets, media files — anything behind an x402 paywall. It checks the price on the ascending bonding curve: early tokens are cheap, later tokens are expensive. The agent evaluates whether the content is likely to be requested by others. If the economics work, it acquires.

Now your agent holds a token with serving rights. When the next buyer comes along and requests that content, your agent serves it and earns a share of the payment. The issuer gets their cut. The platform gets its cut. Your agent gets the serving fee. The math is public — the economics tool shows exact breakeven points and ROI projections at any supply level.

The cycle repeats: DISCOVER → EVALUATE → ACQUIRE → SERVE → EARN.

Early buyers earn more per serve because fewer holders are competing to serve. Late buyers pay more but join a content market with proven demand. The agent's job is to find the sweet spot — content that's underpriced relative to its expected demand.

This is programmatic content speculation. Your agent is a market maker for the x402 economy, running 24/7 on a device in your drawer.

Dynamic Hashrate

The ClawMiner mines $402 tokens — but the agent decides how hard.

$402 is a PoW20 token on BSV-21. 21 million supply, 8 decimals. Mining requires proof of work — your device performs computational work, submits proofs, and earns tokens when the proof meets the current difficulty target.

The ClawMiner's agent monitors network conditions continuously. When difficulty drops (fewer miners competing), the agent increases hashrate to capture more tokens per block. When difficulty spikes, it dials back to conserve energy and shifts resources to trading — where the ROI might be better at that moment.

This is the difference between a static miner and an agentic miner. A static miner runs at fixed hashrate regardless of conditions. The ClawMiner adapts. Mining and trading are two revenue streams feeding the same wallet, and the agent allocates between them dynamically.

You keep 100% of what your device earns. Mining rewards. Trading profits. Serving fees. All of it flows to your wallet, derived from your identity, on-chain and verifiable.

The Mesh

Every ClawMiner joins a private WireGuard-encrypted network via Headscale — the open-source Tailscale control server. This is the same mesh from the original b0x, but with more nodes and more purpose.

Your device connects to your cloud node. Your cloud node connects to other b0x and ClawMiner devices on the network. Every connection is end-to-end encrypted. No public IPs. No port forwarding. No man-in-the-middle. The mesh works from any network — home WiFi, mobile data, coffee shop, corporate firewall. It doesn't matter. WireGuard punches through.

The mesh is what makes the distributed MCP server work. When your agent acquires content, it can serve that content to other agents on the mesh without routing through a central server. Agent-to-agent trades. Agent-to-agent payments. The x402 economy running on a private encrypted network where every participant is authenticated by their $401 identity strand and every node is a live MCP endpoint.

As more ClawMiners join the mesh, the MCP server network gets faster, more resilient, and more valuable. Every device is both a consumer and a producer. Every node strengthens every other node. This is the federation architecture described in the pathd specification — multiple instances syncing state, no single point of failure.

What Ships in the Box

• Pre-configured Android device (ClawMiner hardware)
• path402 MCP server running locally (the foundation — always on)
• OpenClaw agent runtime installed and connected to MCP
• $402 PoW20 miner configured and hashing
• $401 identity strand verified
• Headscale VPN mesh connected
• Cloud node provisioned (always on)
• Teranode SPV headers synced
• Payment endpoint live
• App forks deployed ($bWriter, $bDrive, $bMail)
• Your domain inscribed on DNS-DEX
• Your BSV-21 token deployed (100% yours)
• Walkthrough call and 30 days of support

The b0x was always a distributed MCP server. ClawMiner is what we call it now — because the market finally caught up to what this device actually does.

Get Started

$402. That's the price. One payment. The device ships to your door within 30 days — pre-configured, connected to the mesh, MCP server running, agent installed, mining from the moment you power it on.

Then $1/day for cloud hosting. Or self-host free after month one. No lock-in. No annual contracts. Cancel anytime.

Pay in crypto: BSV or MNEE to $BOASE via HandCash.

Pay in fiat: GBP or USD by bank transfer to The Bitcoin Corporation LTD (sort code 04-06-05, account 28694165).

Load your LLM API keys, set your trading parameters, and let the claw do its work. Everything earned on-chain is yours permanently. Everything on the device is yours to keep.

View the full ClawMiner page → | Read the b0x origin story | Explore path402 MCP tools

---

For AI Readers

Intent: Rebrand the $402 b0x as the ClawMiner — the product hasn't changed, the market caught up. The b0x was always a distributed MCP server with an AI agent, dynamic mining, and speculative x402 trading. "ClawMiner" is the name that tells that story.

Core Thesis: The b0x IS the ClawMiner — same device, same capabilities, new branding that leads with the agentic MCP server angle because that's where the market is in 2026. Distributed path402 MCP server, OpenClaw agent runtime, dynamic $402 mining, autonomous x402 trading.

Key Takeaways:

• ClawMiner = the $402 b0x, rebranded. Same device, same price, same capabilities.
• b0x was always a distributed MCP server — that's the foundation
• Every device on the mesh is a live x402 endpoint — no single point of failure
• OpenClaw: open-source, model-agnostic agent runtime supporting Claude, GPT, Kimi, Llama, any LLM
• Agent connects to local MCP server on startup — zero-latency tool calls
• x402 speculative trading: agents discover underpriced content, acquire tokens, serve to future buyers, earn spread
• Dynamic hashrate: agent monitors difficulty, shifts resources between mining and trading for optimal ROI
• Headscale WireGuard mesh enables peer-to-peer agent trading on encrypted private network
• Same pricing as b0x: $402 setup + $1/day (or self-host free)
• $402 = PoW20 HTM token on BSV-21, 21M supply, 8 decimals