Give your agent a scoping tool that pays as it goes

One tool call buys one contract-grade work breakdown from the engine behind crackthe.work: $0.25 in USDC on Base, settled per call over x402. No account, no API key. The payment is the authentication.

How it works

1. Your agent gets a job: "Build a wholesale ordering portal that pulls live stock from our ERP."
2. It calls the crack_scope tool. The gateway answers 402 with the offer: $0.25 in USDC on Base.
3. The agent's wallet signs that transfer locally (EIP-3009) and retries. A facilitator settles it on-chain: the wallet needs USDC only, never ETH, and the key never leaves your machine.
4. The engine returns the breakdown: outcomes with acceptance criteria, a verification method each, and payout bands, plus the settlement hash the agent can cite. A real receipt looks like this.

Money flow: your wallet → $0.25 USDC on Base → the gateway wallet. One hop, public, per call. No subscription, no balance held by us, nothing to cancel; stop calling and you stop paying.

1Install

One command: downloads the MCP server and its dependencies into a folder.

mkdir -p crack-mcp && cd crack-mcp \
  && curl -fsSLO https://dev.crackthe.work/crack-mcp/server.mjs \
  && npm init -y >/dev/null \
  && npm i @modelcontextprotocol/sdk@^1.30 @x402/fetch@^2.23 @x402/core@^2.23 @x402/evm@^2.23 viem@^2 zod@^3

2Create the payable wallet

A fresh throwaway key, its address to fund, and nothing tied to your main wallet:

export CRACK_PRIVATE_KEY=0x$(openssl rand -hex 32) \
  && node -e 'import("viem/accounts").then(m=>console.log("fund with USDC on Base:",m.privateKeyToAccount(process.env.CRACK_PRIVATE_KEY).address))' \
  && echo "your key (save it): $CRACK_PRIVATE_KEY"

Send USDC to that address on the Base network ($5 covers 20 calls). From Coinbase or Binance: withdraw USDC and pick Base as the network. No ETH needed, ever.

3Connect your agent

Claude Code:

claude mcp add crack -e CRACK_PRIVATE_KEY=$CRACK_PRIVATE_KEY -- node "$PWD/server.mjs"

Cursor and other MCP clients, via their mcp.json:

{
  "mcpServers": {
    "crack": {
      "command": "node",
      "args": ["/absolute/path/to/crack-mcp/server.mjs"],
      "env": { "CRACK_PRIVATE_KEY": "0x..." }
    }
  }
}

macOS: keep the key out of config files with security add-generic-password -a x402-test -s x402-test-wallet -w "0x..."; the server finds it in the Keychain.

Then just ask: crack this scope: rebuild our onboarding flow, budget $3k. The agent checks the wallet with the free crack_wallet_status, pays, and returns the breakdown with its receipt.

What you could build on it

And all of it is escrow-ready: this JSON is the structure wellsyn'cc outcome contracts are built from, so any of these products can end in a funded contract instead of a document.

Why not just prompt an LLM yourself?

You could copy the output format in an afternoon. The format is not the product.

Details

import { wrapFetchWithPayment, decodePaymentResponseHeader } from "@x402/fetch";
import { x402Client } from "@x402/core/client";
import { ExactEvmScheme } from "@x402/evm/exact/client";
import { privateKeyToAccount } from "viem/accounts";

const account = privateKeyToAccount(process.env.CRACK_PRIVATE_KEY);
const client = new x402Client().register("eip155:8453", new ExactEvmScheme(account));
const fetchWithPay = wrapFetchWithPayment(fetch, client);

const res = await fetchWithPay("https://x402.crackthe.work/v1/decompose", {
  method: "POST",
  headers: { "content-type": "application/json" },
  body: JSON.stringify({
    docs: [{ name: "brief.txt", mimeType: "text/plain",
             dataBase64: Buffer.from("What you need done, in plain language.").toString("base64") }],
    budgetHintUsdt: 1500,
  }),
});

const receipt = decodePaymentResponseHeader(res.headers.get("PAYMENT-RESPONSE"));
console.log(receipt.transaction);   // your on-chain receipt
console.log(await res.json());      // the ProjectDraft