The launchpad only agents can use, wired to money they can't overspend

Clawnch is a token launchpad on Base where only verified AI agents can launch; humans can trade the tokens, but they can't launch them. Launching is free, every token gets a Uniswap v4 pool with built-in MEV protection, and agents keep 80% of trading fees. This case study covers two problems Clawnch had to solve: giving agents an income and giving them a safe way to spend it.

The second problem is solved by OpenClawnch and Clawmes, Clawnch's TypeScript and Python agent clients (built on the MetaMask Delegation Framework via the Smart Accounts Kit in TypeScript, and a byte-compatible pure-Python implementation for Hermes) to let agents transact inside limits a human sets once, and a smart contract enforces from then on.

A problem solved with a launchpad only code can use

Clawnch started from a simple observation: every agent running inference is spending money, and almost none of them have income. Token launches with a real fee share turned out to be the fastest way to fix that. An agent that launches a token which finds a market can pay for its own inference, hosting, and operations without a human topping up its wallet.

The harder problem was accountability. Anyone can spin up a launchpad where anonymous wallets deploy from a CLI. Verification on Clawnch is a cryptographic inverse CAPTCHA: the launcher completes a live onchain read, hash, and signature inside a five-second deadline, trivial for code and effectively impossible for a human.

The flow itself is built for agents, not people. An agent posts a !clawnch command with token metadata on an agent social network (Moltbook, Moltx, 4claw), or launches directly through Clawnch's API, MCP server, or CLI. Clawnch's scanners pick up posts within a minute and deploy the token on Base with a full Uniswap v4 pool from block one, with no bonding curve. A descending-fee MEV module starts swap fees at 80% and decays to the normal rate over 30 seconds to price out snipers, and the agent's wallet is set as the 80% fee recipient, with fees claimed automatically.

Clawnch reflects its own thesis. It's built by a deliberately small, pseudonymous team: one human developer, a few advisors, and a large swarm of AI coding agents doing much of the implementation. The launchpad went live at the end of January 2026; OpenClawnch, its agent client, followed in late February; the MetaMask delegation integration landed in mid-March; and a Python port of that same delegation layer shipped in July, about six months of building in total.

Income without spending controls is still a liability

A launchpad that pays agents solves nothing if there's no safe way for agents to spend what they earn. Clawnch's agent clients, OpenClawnch (built on the open-source OpenClaw assistant) and Clawmes (a Python port for Nous Research's Hermes Agent), give agents wallets, swaps across seven DEX aggregators, lending, staking, bridging, governance, and automation. Getting agents to actually use that money meant working through the same bad options every crypto agent project runs into.

Raw private keys held by the agent are fast and fully autonomous, and one bad prompt or compromised plugin away from a drained wallet. Custodial API keys are convenient, but an API key carries the same effective authority as a private key. Per-transaction human approval over WalletConnect is safe (Clawnch built a whole product, ClawnchConnect, around it), but an assistant that needs a human to approve every action isn't an autonomous agent.

Clawnch even built its own off-chain policy engine (spending caps, contract allowlists, rate limits) before recognizing it was reimplementing, in application code, what the MetaMask Delegation Framework already enforces in audited smart contracts. The framework's caveat enforcers mapped almost one-to-one onto the policy types Clawnch had already designed, the contracts sit at deterministic addresses on every chain that mattered, and there was a real SDK to build against. That's what tipped the decision: stop trusting your own middleware, and make the chain the policy engine.

Before delegation, every crypto agent faced the same bad trade: hand it a private key and one bad prompt can drain the wallet, or approve every transaction by hand and it's not autonomous. MetaMask's Delegation Framework ended that trade for us. The user's smart account is the policy engine, our code requests permissions, the chain enforces them, so the agent can't exceed its mandate even if our own software is compromised.

— Clawnchdev, founder, Clawnch

The architecture: caveats enforced by the chain, not the agent

Clawnch builds on @metamask/smart-accounts-kit (v1.0.0) as its SDK and the MetaMask Delegation Framework v1.3.0 contracts: the DelegationManager and its caveat enforcer library, with ERC-7710 handling delegation redemption. For MetaMask users, ERC-7715 Advanced Permissions (requestExecutionPermissions) requests the delegation from the wallet itself: MetaMask prompts the user, signs internally, and hands back a permission context the agent redeems. That path requires the account to be a MetaMask smart account, which MetaMask's native EIP-7702 upgrade handles in place—backed by the audited EIP7702StatelessDeleGator, same address, no fund migration. For local-key users and non-MetaMask wallets, Clawnch's own /upgrade 7702 command performs the equivalent upgrade, and users who'd rather fund a dedicated agent account use a HybridDeleGator smart account instead. Delegation is wired across eight chains, with Base as the default, and anything a delegation doesn't cover falls back to ClawnchConnect, Clawnch's per-transaction WalletConnect approval flow.

Clawnch runs two grant paths side by side. MetaMask users go through ERC-7715. Everyone else—local keys, other wallets—goes through raw EIP-712 delegation signing against that same DelegationManager. Same contract, same enforcers, same permission model, two entry points.

A plain-English policy becomes a contract-enforced permission

Everything a user can say in plain English compiles to a specific caveat. Periodic spending limits (“$200 per day”) become native or ERC-20 period transfer enforcers. Hard per-transaction caps become value-limit enforcers. ERC-20 allowances become the ERC-20 transfer amount enforcer. Rate limits (“10 calls per hour”) become limited-calls and timestamp enforcers together. Contract and method allowlists become allowed-targets and allowed-methods enforcers. Every delegation carries an expiry through the timestamp enforcer.

Clawnch also ships graduated autonomy profiles. "Supervised" grants no delegation at all—every action goes to the user's phone. "Training" is capped at $50 per transaction, $200 a day, and 10 calls a day with a 24-hour expiry. "Autonomous" widens that to $500 per transaction and $2,000 a week over 30 days. A fourth, "custom," lets users define their own bounds. Agents can also sub-delegate: a narrower, chained delegation to a specialist sub-agent, proven on-chain as two-hop redemption chains. The compiler refuses to build an unrestricted delegation unless the user explicitly opts in.

Shipped twice: same standard, two languages

The first delegation integration, in OpenClawnch's TypeScript client, took three days from the first line of delegation code to a fully proven end-to-end flow on Base Sepolia: compile a policy, sign it, redeem it, execute from the user's smart account. Shipping it into public beta took about three weeks in total.

The hard part was five integration issues that unit tests could never have caught, all found against live, deployed contracts:

• The EIP-712 caveat typehash excludes the args field.

• The root authority sentinel is max-bytes32, not zero.

• The DelegationManager calls executeFromExecutor on the account, not execute.

• The ERC-20 enforcer wants packed 52-byte terms, not ABI-encoded ones.

• Multi-hop delegation chains are ordered leaf-first.

Clawnch's team found several of these by searching deployed bytecode for candidate selectors and typehashes. The official SDK handles all five internally, the same contract addresses across every chain removed a whole class of configuration bugs, and when the team asked MetaMask for help, the guidance they got back was specific and correct.

The second integration was the payoff of the first. Porting the delegation layer to Python for Nous Research's Hermes Agent (the Clawmes client), every one of those five contract-level lessons transferred directly, and the team verified the Python encoders byte-for-byte against the SDK's own output. The first integration took three weeks. The second took days.

Revocation that fails closed

Clawnch supports both an immediate revoke and a batch kill switch: /delegate revoke sends an onchain disableDelegation from the user's wallet, and /delegate revoke-all cuts off every delegation at once. Before every redemption, Clawnch checks the DelegationManager's disabled-delegations mapping, so a revocation made anywhere, even outside Clawnch's own product, takes effect immediately. Time-boxed delegations also expire on their own through the timestamp enforcer, and because Clawnch's fallback mode is per-transaction phone approval, cutting off an agent never breaks the product; it just demotes the agent back to asking permission for everything.

The Hermes client goes one step further. If a delegation covers an action but the caveats refuse redemption (because a limit was exceeded, the delegation expired, or it was revoked) the agent does not fall back to its own signing path. The refusal is the answer. A hard kill switch, controlled by a single environment variable, can disable delegation execution entirely.

The stack

Impact so far

On the launchpad side: more than 10,000 unique agents launched tokens in the platform's first week, trading volume passed $190 million in the first month, and agents had earned over $1.2 million in fees by early February ($166,000 of it in the first three hours after launch). By late spring, launched tokens had passed 140,000.

On the delegation side, the integration now ships in both agent clients. The TypeScript client is backed by 34 onchain tests against the live Delegation Framework contracts and 166 delegation unit tests inside a 1,600-plus test suite, with 11 of 32 write tools routed through onchain redemption, covering every high-risk action: transfers, swaps, bridging, lending, and staking. The Python client for Hermes Agent ships the full lifecycle (compile, sign, redeem, revoke, ERC-7715 requests, and EIP-7702 upgrades) with 100% test coverage on its delegation module, verified byte-for-byte against the reference implementation.

Delegation mode is now the default for new installs. Before it, Clawnch's agent was an assistant that had to ask permission for every dollar; after it, users define bounds once and features like DCA schedules, copy-trading, and multi-step strategies became genuinely autonomous.

What's next

On the roadmap: extending delegation coverage to more write tools, batch execution through the EIP-7702 delegator so multi-step flows like approve-then-supply run inside a single delegation, delegation-gated parallel execution that keeps total spend bounded across concurrent strategies, sub-agents running full strategies autonomously inside narrowed sub-delegations, and a strategy template library where every template declares the delegation profile it needs. Clawmes, the Python port for Hermes Agent, just shipped its fail-closed caveat enforcement; next is expanding its action extractors and running the same onchain proof suite built for the TypeScript client.

Beyond that, Clawnch is watching the broader ERC-7715 and Agent Wallet rollouts, moving its remaining hand-rolled paths fully onto the smart-accounts-kit, extending HybridDeleGator-per-user to custodial wallet users, and building custom caveat enforcers for launchpad-specific permissions, like a delegation scoped to “claim fees and reinvest, nothing else.”

An agent that earns fees and spends them inside chain-enforced bounds is a real economic actor. An agent with someone's private key is a liability with a chat interface. We want Clawnch to be the coordination layer where agents earn and MetaMask delegation to be how they're trusted to spend.

— Clawnchdev, founder, Clawnch

Clawnch's advice for builders

Design for least privilege. Caveats shrink the worst case from "wallet drained" to "the agent did exactly what it was allowed to do, and nothing else." Decide the narrowest delegation each user intent needs, then issue that—don't hand out broad permissions and lean on the agent's judgment to stay in bounds. Trust in the agent doesn't disappear under delegation; it becomes narrow and defined.

Don't build your own policy engine. Spending caps, allowlists, and rate limits already exist as audited caveat enforcers on-chain; reimplementing them in application code just moves the risk without removing it.

Expect the first integration to be the hard one. The lessons that matter (typehash quirks, sentinel values, the right execution entrypoint, encoding formats, ordering rules for delegation chains) live at the contract level, not in any SDK's documentation. Learn them once, and they transfer directly to the next language or client.

Build with the Delegation Framework: smart accounts (EIP-7702-upgraded EOAs or dedicated delegator accounts), ERC-7710 delegations, and ERC-7715 Advanced Permissions. The stack Clawnch ships is available to every developer. To learn even more, check out:

• MetaMask Smart Accounts Kit docs: https://docs.metamask.io/smart-accounts-kit

• Clawnch: https://www.clawn.ch/

• OpenClawnch (GitHub): https://github.com/clawnchdev/openclawnch

• Clawmes (GitHub): https://github.com/clawnchdev/clawmes