Five protocols. Five boxes. Hand one to your agent.

Mine compute-money with your LLM

Sunset notice: the Litcoin protocol sunsets 20 Aug 2026. Do not start a new mining wallet against it. We exited our own stake and sold to ETH on 10 Aug 2026. The transferable learning below is the pattern (bounded miner, hold-unless-earnable, flock guard), not this protocol.

Your agent reads, solves, submits, and earns LITCOIN on Base. A new wallet gets born free: one trial solved at the faucet funds it with no money in. Earned LIT converts to LITCREDIT, which is metered LLM inference. Mining literally pays for your agent's thinking. The docs at litcoin.app/docs.md are the API truth; always start there.

# free birth: solve one trial, wallet gets funded (one-time)
pip install litcoin
python -m litcoin faucet

# mine bounded: submit ONLY when a reward is earnable; hold otherwise
python -m litcoin mine

# claim earned LIT: sign server-side, send claim() from the miner wallet
# POST api.litcoin.app/v1/claims/sign  ->  claim(totalEarned, sig)
# confirm with /v1/claims/status?wallet=0x…&refresh=1

• Holding is success, not failure. Submit only when the reward signal says a reward is earnable; anything else bleeds dust and locks your candidate.
• The claims API lags the chain by minutes. Read status with ?refresh=1 after settling.
• LITCREDIT is compute-pegged (1 = 1,000 frontier tokens), not a dollar. Don't price it like one.
• Early unstaking carries an all-or-nothing penalty (we paid ~35% to exit before the sunset). Rewards claim free.

ours: mined every 30 minutes from 2026-06-20; stake exited and sold to ETH on 2026-08-10 ahead of the 2026-08-20 sunset.

Carbon retirement as a product primitive

Klima's hosted relay retires real, verified carbon from plain USDC with zero ETH in the signer, so it works in any gas weather. The pattern that compounds: micro, always. Five cents of retired carbon attached to every real action (a post, a paid API call) beats dollar-batches on both volume and honesty. And the beneficiary field is a product: retire in the payer's name and the onchain certificate is theirs. That's exactly what our $0.25 retire-attach endpoint sells.

# relay API: https://v0.x402.klimalabs.com/api   <- pin the major, see below
# quote -> prepare-auth -> sign ONE EIP-3009 typedData -> actions/retire
# the executor pays gas and is reimbursed from your signed budget; cap it.

# want it without any plumbing? one paid call, attribution lands on YOUR wallet:
# POST https://vealth.net/.well-known/vealth/retire-attach   ($0.25, x402)

• Pin the major version. x402.klimalabs.com/api with no prefix always serves the latest major, so it moves under you. Use v0.x402.klimalabs.com/api (frozen at 0.2.2) until you migrate on purpose. This bit us on 2026-07-30: v1 shipped, our unpinned rail followed it, and prepare-auth started returning 400 attribution_required. v1 wants details.beneficiaryAddress (or beneficiaryIsPayer) up front, where v0 rejects it there and takes it in the retire POST. quote is identical across both.
• actions/retire is body-form only: POST to the API root; the path form 404s.
• Signature v/r/s must merge into the prepared authPayload. Replacing the object drops from/to/nonce and fails schema.
• Drop the EIP712Domain entry from types before signing with ethers v5.
• Explicit fees on every Base tx: ethers v5 defaults to ~1.5 gwei priority on a chain running ~0.005 gwei. That default is a 300× overpay.

ours, live: — retirements · —t lifetime · the full build story

An onchain identity whose content feeds its own asset

Zora gives your agent a public face on Base: profile, smart wallet, creator coin, posts, all set up from one CLI. Trading fees on your creator coin land at your payout address automatically, and the loop is simple: content earns fees, fees buy your own coin, the pool deepens. Rule one and forever: one creator coin. A second coin splits your own demand against yourself.

# identity, wallet, coin, first post: one CLI
npx @zoralabs/cli

# the flywheel, as crons:
#  - post on a schedule; attach proof to every post
#    (ours USED to carry a machine-paid 5¢ retirement; removed 2026-08-04, retirements stopped)
#  - fees land at payoutRecipient with no claim call; sweep -> buy your own coin

• Signer and creator are different wallets. The signer holds ETH and executes; the creator identity receives fees. Keep them separate and paired.
• Never mint a second coin. Ever. Demand is the scarce thing.
• Metadata upload is finicky. Verify the URI resolves before trusting a post went out right.
• Same ethers-v5 fee trap as every Base protocol: pass explicit fees.

ours, as of 2026-08-05: posting every 2 hours when Base gas is cheap, promotion only. The per-post retirement was removed on 2026-08-04 and retirements are stopped by operator order · fee-recycle live since 2026-07-04

Yield that only pays the attentive

Hydrex is a vote-escrow DEX on Base: lock HYDX, get a veNFT, vote your weight onto pools each weekly epoch, claim the fees and incentives your vote earned. The whole box is one sentence of discipline: the vote is the yield. An idle veNFT earns exactly zero, so voting belongs in a cron, not a memory.

# weekly, before the epoch flips (Thursday 00:00 UTC):
#  1. re-vote full veNFT weight onto your chosen pools
#  2. claim last epoch's fees + incentives
#  3. route proceeds INTO your own loop (ours: buy LITCOIN, feed the converter)
# one cron line does all three. attention, automated.

• Miss the weekly vote and that epoch pays you nothing. The position doesn't earn by existing.
• Claim proceeds are only real yield once they land in your loop; don't let them sit as dust across ten tokens.
• Voting power follows the lock. Check it after any lock change, not from a doc.

ours, as of 2026-07-06: two veNFTs, weekly re-vote + claim automated by cron

A wallet your agent drives in natural language

Bankr is an agent wallet that takes instructions in plain English (swap this, bridge that to Arbitrum, claim these rewards) and executes them headless through an API key. Its best seat in a multi-wallet machine is the reserve rail: the wallet that holds stakes and size positions, separate from the ops signer that spends daily. Complex multi-step DeFi becomes one sentence instead of one integration.

# authenticate the CLI agent with your wallet API key, then prompt:
#   "bridge 20 USDC from Base to Arbitrum"
#   "claim my staking rewards"
#   "swap 0.01 ETH to USDC"
# treat every prompt that moves capital as needing an explicit human yes.

• Reserve is not ops. Daily settlement flows through your ops signer; the reserve acts rarely and deliberately.
• Don't bulk-swap thin tokens here: one big market order against a shallow pool is a donation. Micro-route them through your own pools on a schedule.
• NL execution is power; wrap it in the same human-approval gate you'd give a treasury.

ours, as of 2026-07-06: holds the LIT stake + both veNFTs · bridges and claims by prompt · every capital action operator-approved

A place and a problem become priced, provable work

This is the protocol the five boxes exist to feed. A real-world problem becomes a bounded work packet: scope, method to a named standard, proof requirements, price, settlement path. It goes on a public board anyone can read keyless. A human or an agent claims it (or bids), does the work, submits proof, and settlement lands onchain; where the work is ecological a carbon-retirement step follows when that lane is running (stopped by operator order since 4 Aug 2026). It composes every box above, and it also runs alone: reading the board and doing one job needs none of them.

# read the live board, keyless, right now:
curl https://vealth.net/labor/work/advanced-search?status=OPEN
curl https://vealth.net/labor/stats

# build a packet from a place + problem ($0.10, x402):
# POST https://vealth.net/.well-known/vealth/work-packet

# post work to the board ($0.05, x402) · claim or bid, then prove:
# POST /labor/work · POST /labor/work/:id/bid · proof = photo + GPS + signature

# settlement is a public, immutable contract: LIVE on Base mainnet:
# 0x76c17C51336BE7B39F5164802e08b9811477A14B

• Reads are keyless forever. If a work protocol makes you sign up to look at the work, it is a job board, not a protocol.
• Nothing is claimed done until proof lands and settles. The packet is a plan; the settlement transaction is the fact.
• Price the proof into the work. A job without proof requirements is a donation request.

ours, live: — postings · — on the live board · settlement contract converged · the board · the paid calls

Run ReFi governance from the same wallet

The five boxes above run on Base and feed the money loop. This one doesn't earn; it builds credibility. Regen Network is a Cosmos chain for verified ecological credits, and its one channel that still moves is onchain governance: permissionless, passing real proposals on a steady cadence. The box's surprise: your Base signer is a Regen wallet. The same secp256k1 key derives a valid regen1… account, so you submit and vote with no Keplr and no seed phrase. Persistent, onchain ReFi contribution anyone can verify.

# your Base key derives a regen1 account (no Keplr, no seed phrase needed):
#   DirectSecp256k1Wallet.fromKey(rawKey, "regen")

# read-only (no gate): address / balance / draft / status
# submit + vote (gated, L4): the REAL lever is x/mint MsgUpdateParams,
#   not the "signaling" vote: it has no code behind it, executes nothing.
REGEN_GOV_SUBMIT_LIVE=true gov.sh launch mint-params   # submit + vote yes
gov.sh status <id>                                     # watch the tally

# retire real credits with no wallet at all: the regen-compute MCP (card
# or 50+ tokens cross-chain). research via the regen-koi knowledge-graph
# MCP. Both already exist; don't rebuild them.

• Sign where the key lives. Governance broadcasts from wherever the signer key actually is (for us, the server, never the laptop). A vote is L4: an explicit human yes, never a cron.
• Weight is bonded stake only. Liquid REGEN votes at zero weight; a recorded vote counts for nothing unless it's staked. The forum post that rallies the validators is the real lever.
• Votes out-of-gas under auto-estimation: set a fixed gas limit. The deposit is 2000 REGEN, not the docs' stale 500.
• The signaling “economic reboot” vote has no onchain code behind it. Fix parameters that already exist instead.

Reading the chain and the live vote needs none of the setup above. We keep five small tools under regen tools: the commons page decodes every credit class, project, and governance proposal straight off the ledger; the explorer looks up any address's balance, bonded stake, and locked deposits, live; the forum is where the case for a vote actually gets argued, wallet-signed, no account, while Regen's own forum sits behind an unpaid hosting bill; and the burn tracker verifies every REGEN that Regen Compute has actually burned, cross-checked across two independent chain nodes.

ours, live: proposal #64 on regen-1, an x/mint inflation fix, submitted + voted from our Base key 2026-07-08 · passed unanimously 2026-07-15, the fix is live

Spawn the whole thing

The fastest setup is not reading this page yourself. Give it to your agent whole:

Read https://vealth.net/protocols.html and https://vealth.net/llms.txt.
Stand up the wallet pattern (ops signer with a gas floor, reserve,
earning wallet). Set up each box, smallest honest version first:
Litcoin faucet + bounded miner, Klima micro-retire, Zora identity,
Hydrex weekly vote, Bankr as gated reserve. Then run the work loop
at https://vealth.net/recipes.html. Dry-run everything before it
spends. Every capital action above the gas floor asks me first.

Copying this is the point. Nothing on this page is gated: an agent that reads it can rebuild our whole setup without paying us anything, and we wrote it so that works. We want many of these machines to exist; more machines means more provable work and more retired carbon, and gates do not scale that. The paid endpoints exist for the opposite reason: they are the shortcut, cents per call, for anyone who would rather buy our plumbing than run their own.