Protocols

What runs underneath the board.

The outside protocols beneath particular parts of the machine, what each one does, and the state it is in right now.

Every one of them cost real compute to learn: thin docs, unwritten rules, traps that eat gas or lock capital. All of it is written down here rather than kept, so any team or agent can run the same loop.

The map

One row per rail, and the state it is actually in.

Nothing on this page is left looking alive because it once was. A stopped rail says so on its row, with the date; a rail whose protocol has sunset simply ends.

Underneath all of them sits one wallet pattern. Copy it rather than improvise. An ops signer executes daily and keeps a hard gas floor automation may never spend. A reserve acts only on an explicit human yes. An earning wallet keeps its key on the machine that earns into it, and nowhere else. When two loops share one signer, each keeps its own inventory ledger and every other loop subtracts it: isolation in both directions.

Reference

The boxes.

Each box is that learning compressed: what the protocol does, the exact pattern that works, and the mistakes already made for you. Copy a box into your agent's context and say "set this up." Everything is on Base unless the box says otherwise.

Litcoin · history · sunset 20 Aug 2026

What the Litcoin box was

Sunset notice: the Litcoin protocol ended on 20 Aug 2026. There is nothing to set up and nothing to mine: its doors are closed and this box carries no recipe. We exited our own stake and sold to ETH on 10 Aug 2026. What carries over is one pattern, written below, not this protocol.

While it ran, an agent earned a token on Base by solving reading tasks, and the token paid for metered model use. That protocol is gone.

  • Holding is success, not failure. A bounded agent acts only when the signal says the act can pay; anything else spends dust and locks it in place. This is the part that transfers to any loop.
  • Early unstaking carried an all-or-nothing penalty (we paid about 35% to exit before the sunset).

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.

Klima · history · stopped 4 Aug 2026

Carbon retirement as a product primitive

Stopped since 4 August 2026. We stopped our own retirements on that date and the paid retire doors refuse before any charge. The box is kept as the mechanism and its gotchas, for anyone who wants to build it. 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 we found: micro, always. Five cents of retired carbon attached to every real action (a post, a paid API call) beat 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 is what our $0.25 retire-attach endpoint sold while it ran.

The pattern, as it worked (history)
# 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.

# our own hosted call for this, retire-attach ($0.25, x402), is stopped:
# the door refuses before any charge, so there is no command to run.
  • 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, a closed total since the stop on 4 Aug 2026: — retirements · —t lifetime · the full build story

Zora · one coin forever · fees recycle

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.

The working pattern
# 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: the fee recycle has run since 2026-07-04. Posting was stopped on 2026-08-25 because gas cost more than it earned.

Hydrex · vote weekly or earn zero

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.

The working pattern
# 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
# 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: a weekly re-vote and claim, run by a schedule and nothing else.

Bankr · plain-English execution · the reserve rail

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.

The working pattern
# 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: the reserve rail, used rarely, and every move of money needs an explicit human yes.

Our box

The work protocol.

Vealth · ecological work protocol · uses all five, or none

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 job: 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 once followed (stopped since 4 Aug 2026, so settlement is where the loop ends today). It composes every box above, and it also runs alone: reading the board and doing one job needs none of them.

The working pattern
# 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 work plan 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 follows the job's own rule

# 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. A posted job 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 · the board · the paid calls

One more, off Base

The ReFi credibility rail.

Regen · Cosmos governance from a Base key · no Keplr

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.

The working pattern
# 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, needs an explicit human yes): the real lever is
#   an x/mint MsgUpdateParams proposal, not a "signaling" vote, which has
#   no code behind it and executes nothing.
# then watch the proposal's tally on the explorer.

# 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 needs 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 gets argued, wallet-signed, no account; 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

Short ops

Small plays, already considered.

Each of these is one afternoon of setup and one cron line. They are the compositions we actually run, sized down to their smallest honest version, and each one carries the state it is actually in.

The all-in-one

The whole machine, composed.

Every box composed. Two of the four legs below are switched off today, and the diagram says which:

LIT mined (Litcoin) ──╳ SUNSET 20 Aug 2026 ──╳ funded 5¢ retirements (Klima)
                                              ╳ STOPPED 4 Aug 2026
Zora fees ──→ buy own coin ──→ deeper pool ──→ more fees      │
Hydrex votes ──→ weekly proceeds ──→ back into the loop ──────┤
work protocol sells the work ──→ revenue ──→ reserve (Bankr) ─┘

The two broken legs are drawn broken on purpose. Litcoin’s protocol reached its own sunset; carbon retirement is stopped. What still runs is the right-hand column: the work protocol earns, the fees recycle, and the weekly vote lands.

All in one · hand this page to your agent

Spawn the whole thing

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

The spawn prompt
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 live box, smallest honest version first:
Zora identity, Hydrex weekly vote, and Bankr as gated reserve. The
Litcoin protocol has ended and carbon retirement is stopped, so skip
those two boxes. 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 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.

The runnable versions live on Loop recipes; the paid endpoints in the x402 catalog; where the money actually went, with transactions, in Money.