How Kelvin works

Launching a token is one transaction to the Kelvin factory. Every token comes with an AI agent that runs its market, and the launch creates three things that belong together: the token, its Uniswap v4 pool run by the Kelvin hook, and a treasury that holds what its agent earns.

The factory records two things about the agent's keys: the commitment to its first root key, called K0, and the address of its operator. Nothing else about the keys leaves the machine that made them.

Every token starts the same way: the same supply and the same price, about 5 gwei a token. The factory puts the whole supply into the pool as one band of liquidity from the launch price upward, and that position can never be removed.

There are no allocations, not for the creator and not for us. There's no launch protection either: someone buying in the first block pays the same fee as everyone after them.

The hook takes a fee on every swap, always in ETH, whichever way the trade goes. It starts at 1%, and the agent can move it anywhere from 0.5% to 2%. 80% of it goes to the agent's treasury, and 20% to the protocol share, which buys back and burns $KELVIN.

A token's agent acts often, and its money should stay put. So the agent gets two keys. The operator key is an ordinary ECDSA key that lives inside the agent and steers its market. The root key is a seed for one-time hash signatures, kept offline, and it's the one that withdraws.

If the operator key is stolen, the thief can move the fee within the band and trigger small buybacks until the root key appoints a new operator. They can't withdraw anything.

The hook enforces the operator's limits on-chain, so even a stolen or misbehaving operator key stays inside them.

Buybacks are small and spaced out on purpose. A sandwich around a 0.02 ETH buyback pays more in fees than the buyback moves the price, and catching several takes hours of ordinary market exposure.

Most wallets sign with ECDSA. Its security rests on the discrete logarithm problem, which a large enough quantum computer running Shor's algorithm could solve, recovering a private key from its public key.

Kelvin treasuries open with WOTS, a Winternitz one-time signature built from nothing but keccak256. Forging one means inverting the hash. The best known quantum attack on that, Grover's search, only cuts the work from about 2²⁵⁶ to 2¹²⁸ guesses. It's the hash-based family NIST standardizes in SP 800-208.

Here's the idea, on one chain. The signer starts from a secret and hashes it 15 times; only the end of the chain is public. To sign a digit, they reveal the link at that position. Anyone can finish the walk and check it lands on the public end.

Hashing only goes forward, so a forger holding link 6 could turn the 6 into a 9 but never into a 3. Three checksum chains stop the first trick: they count the other way, so raising any message digit would mean lowering a checksum digit, which means hashing backward. A full signature reveals one link on each of 67 chains.

A WOTS key is safe for exactly one signature: two signatures from the same key reveal enough links to forge a third. So every withdrawal moves the vault to a fresh key. Key n comes from the seed, and the vault stores only its commitment. A withdrawal signs the recipient, the amount, a deadline and the next key's commitment.

The key index is the vault's nonce, so the agent only needs to keep the seed. A signed key is retired whether the withdrawal pays or expires, so a published signature never stays live.

$KELVIN is the platform's token. It launched through Kelvin as token #0, with the same factory, hook and fixed supply as every token and no team allocation. The protocol's share of every token's fee buys it back and burns it.

The kelvin command line does everything this site does, from a terminal or from inside your agent. Every command takes --rpc and --deployment, or the KELVIN_RPC_URL and KELVIN_DEPLOYMENT variables.

Every message a seed signs is recorded next to its root file, in .kelvin/. Keep that folder with the seed: it's how the kit knows never to sign with a key twice. Sign from one place at a time, this site or the CLI.

To let an AI agent steer its own market, give it kelvin-mcp, an MCP server that holds the agent's operator key and never its root key. Any MCP client can use it, Claude included, and it offers three tools:

• market

  Price, fee, treasury and the last 24 hours of trading, plus what the agent may do right now.

• set_fee

  Moves the fee within 0.5–2%, at most 0.5 points at a time, once an hour.

• buy_back

  Buys back and burns up to 0.02 ETH, once an hour, within 10% of the treasury a day.

The hook enforces the same limits on the AI as on anyone holding the operator key, and it can't withdraw anything.

• The contracts aren't audited. They're tested on a mainnet fork and on Sepolia.
• Lose the root seed and the agent can never withdraw again. Back it up offline.
• Signing twice with one key lets anyone forge a signature. The site and the CLI keep records to prevent it; don't delete them.
• A stolen operator key can move the fee within the band and trigger small buybacks until the root key replaces it.
• The team holds a quantum-resistant emergency key that can withdraw treasury ETH and the protocol share. Its first use puts every vault into emergency mode for good, and each agent's balance stays on-chain as the record of what it's owed.

Every token on this site trades through these contracts. Check them on Etherscan before you trade.

Reading the deployment…