The dime rule
Every single payment must be at or under your cap. A 25¢ contract audit is not paid quietly: it is held for a human, with the reason written down.
Pocket money for agents.
Give your agent a task and a budget. dimebot works out every paid call it will make, keeps each payment at or under a dime, fits the plan inside the budget and walks every payment through the HTTP 402 handshake before a cent moves.
- Runs right here, on your words, with no account and no server.
- One JavaScript file, zero dependencies, MIT licensed.
- Plans and checks only. It never holds keys or pays anyone.
This week a Chainalysis report counted 138 million payments made by AI agents, most of them under ten cents. The numbers
Consoleoffline rehearsal, nothing is paid
Cap per payment
Dime meterevery payment of this run, on a log scale of cents
Run log
Your own runs from the console, newest first, kept in this browser only. The row marked demo is a worked example, so the table is never empty.
| When | Task | Payments | Total | At or under a dime | Held |
|---|
How it works
A paid API answers the first request with 402 Payment Required and a price. dimebot sits between that answer and your wallet and decides whether the payment fits the rules.
- readTurns your words into paid calls with counts. Anything it cannot map is listed, never guessed.
- pricePrices each call from a sheet you can edit.
- dimeChecks every single payment against the cap.
- routeUses the cheaper tier when the task says a draft is fine, or when the budget needs it.
- fitTrims bulk counts until the plan fits. Single calls are never cut.
- rehearseWalks each payment through 402, pay, retry and 200, offline, with a stable id.
- ledgerCounts, totals and size buckets.
- receiptSummary, CSV and the policy that produced it.
Agents already pay by the dime.
Agents made more than 138 million payments through x402 on Base, and over 87% of them were under ten cents. The median time from funding a wallet to its first payment fell from 73 days to 18 minutes.
From a Chainalysis report covered on 14 and 15 October 2026 by Fortune and Blockhead. dimebot is an independent open-source project and is not connected to Chainalysis, Coinbase or the x402 Foundation.
Budgets are hard
Bulk work is trimmed in proportion until it fits. The run tells you exactly what was cut.
Quality respected
"Quick" or "draft" allows the small model. "Careful" keeps the large one, even when money is tight.
402, rehearsed
Each payment walks the full handshake offline, so you see the plan before any wallet signs.
Receipts you can diff
Every payment gets a stable id, so two runs of the same task give the same CSV. Put it next to your real wallet history and compare.
n,service,usd,id 1,search,0.0050,3b8784e4 2,search,0.0050,3e87899d 7,fetch,0.0020,a46c7df4
One file
Node 18+ or a browser tag. Zero dependencies and 15 tests.
The $DIMEBOT token
The library is free and stays free. $DIMEBOT is a separate community memecoin on Solana. It unlocks nothing in the code and promises nothing.
$DIMEBOT
site version 1.0
—
Fetching the live figures…
- Market cap
- —
- 24h volume
- —
- Liquidity
- —
- Supply
- 1,000,000,000
- Tax
- 0%
Contract address
—
Buy on pump.fun
GMGN
Dexscreener
Live chart1-second candlesOpen full chart
Loading the chart…
Docs
Everything below is the real 0.1.0 code. The console above runs this exact file.
Install
Download the package, unzip it, and run the tests. Node 18 or newer, nothing else.
dimebot-0.1.0.zipthe whole package: src, bin, tests, examples
dimebot.jsthe library on its own, for a script tag
README.mdthe same text as the README tab
unzip dimebot-0.1.0.zip && cd dimebot
npm test # 15 tests passed
node examples/research.js # 31 payments, 11.8¢ in total, …JavaScript
In Node, require the file. In a browser, a script tag gives you window.dimebot; that is how the console on this page works.
const dimebot = require("./src/dimebot.js");
const r = dimebot.run({
task: "Scan 5 repos for leaked keys, review the results and audit 2 token contracts",
budget: 0.5, // US dollars for the whole job
cap: 0.10 // the most any single payment may be
}, step => console.log(step.i + 1, step.tool, step.ms + " ms"));
r.receipt.summary
// "6 payments, 44¢ in total, 100% at or under a dime; 2 calls held for a human."CLI
node bin/dimebot.js "Search 6 queries, read 24 pages and write one careful brief" --budget 0.5
node bin/dimebot.js "read 3 pages" --csv
node bin/dimebot.js "scan 3 repos and read 10 pages" --cap 0.05 --json
node bin/dimebot.js "read 40 pages" --prices my-prices.json| Flag | Meaning |
|---|---|
--budget N | US dollars for the whole job (default 1) |
--cap N | the most a single payment may be (default 0.10) |
--prices file | your own price sheet, same shape as dimebot.prices |
--csv / --json | print the CSV, or the ledger and policy as JSON |
API
| Call | Returns |
|---|---|
run(input, onStep?) | { steps, needs, skipped, changes, trims, fits, payments, held, ledger, receipt } |
plan(input) | the eight steps run() takes: [{ tool, args, why }] |
tools.read({ text }) | { needs, skipped } |
tools.price({ needs, prices }) | { lines, total } |
tools.dime({ lines, cap }) | { cap, lines, over } |
tools.route({ lines, budget, prices }) | { lines, changes, total } |
tools.fit({ lines, budget }) | { lines, held, trims, spend, fits, budget } |
tools.rehearse({ lines, held, cap, seed }) | { payments, held, sample } |
tools.ledger({ payments }) | { count, total, buckets, shareUnderDime, byService } |
tools.receipt({ … }) | { summary, lines, csv, policy } |
prices | a fresh copy of the example price sheet |
cents(usd) | 0.118 → "11.8¢" |
input is { task, budget = 1, cap = 0.10, prices = example sheet, seed = task }.
Price sheet
These are example prices, not live quotes. Change them here and the console uses your numbers on its next run.
| Service | What it is | USD per call |
|---|
Source
Every file of the 0.1.0 package, with its SHA-256 worked out in your browser.
src/dimebot.js
Roadmap
What is shipped, and what is planned next. Plans can change; nothing here is a promise about the token.
- 0.1.0
Shipped today, 15 October 2026
The eight-step planner, the dime rule, budget fitting, cheaper routes, offline 402 rehearsal, receipts and CSV, the CLI and 15 tests.
- 0.2
Planned
A caps file with a different cap per service, an hourly allowance, and a warning when a task's words are too vague to price.
- 0.3
Exploring
Reading real 402 price answers from your own logs to build the price sheet, and a small hook so a wallet library can ask dimebot "may I pay this?" before it signs.
Questions
Does dimebot move real money?
No. It reads a task, plans the paid calls and checks them against your rules. The 402 handshake in the console is a rehearsal; nothing is sent anywhere.
Where do the prices come from?
From an example sheet in the library. Real services set their own prices, so edit the sheet (or pass your own) before you trust a total.
Why a dime?
Most agent payments in the report were under ten cents, so 10¢ is a sensible default cap. You can set 5¢, 25¢ or any number.
Is there an LLM inside?
No. The planner is a set of plain rules you can read in one file, which is why the same task always gives the same plan.
Does holding the token give access to anything?
No. The code is MIT licensed and free for everyone. The token is a separate community memecoin.