docs

Introduction

kluv takes instructions in plain language and acts on them onchain. It deploys tokens, routes trades, works with tokenized stocks, produces signals, and charges other agents for its output. Instructions reach it two ways: a mention on X, or a command in the web console. Both drive the same agent.

The point of kluv is not that it is autonomous. Autonomy is the method. The point is the set of things it can do without a person clicking approve at each step.

Principles

• Plain language in. A command is a sentence, not a form.
• Action out. The result is an onchain transaction or a delivered output, not a suggestion.
• Onchain by default. State lives on Base, not in a private database.
• Bounded, not supervised. Authority is limited by guardrails, not by a human approving each move.
• Paid per use. Output has a price, and machines can pay it without a human.

Architecture

A request travels through four layers, from an interface to an onchain settlement and back. Each layer does one thing.

 in ─▶ 00 interface ─▶ 01 reasoning ─▶ 02 execution ─▶ 03 settlement ─▶ out

• 00 interface. X mentions and the web console.
• 01 reasoning. A model parses intent and resolves parameters.
• 02 execution. Deployment and trades are written to Base.
• 03 settlement. Machine callers pay per request in USDC.

The agent loop

Every request runs the same loop:

read     parse the intent from language
resolve  fill parameters (token, amount, target)
check    test the call against guardrails
act      write to base, or reject
return   reply with the result or the reason

Malformed or unsafe calls are rejected at the check step. The agent does not guess missing parameters that carry risk, such as an amount or a destination.

Interfaces

kluv has two front doors, and the same agent stands behind both.

• X. Mention @kluvagent with a command. It replies in the thread and acts onchain.
• Web console. Open the console on the site and type the same commands in the browser.

X gives reach and a public record. The console gives a direct path with no thread and no wait. Neither is a different product.

Agent wallet

kluv holds funds in an agent-controlled wallet on Base. Deployments and trades originate from it, and positions settle back into it. Signing uses scoped, short-lived authority rather than a raw key exposed to the model.

Guardrails

Guardrails are the limits placed on what the agent can move, and how much, without a human.

• Spend limits. A cap per action and per window.
• Allowlists. Approved tokens, targets, and endpoints.
• Rejection. Calls that fail a check are refused, not adjusted to fit.

Guardrails are enforced before execution, at the check step of the loop.

Base

kluv runs on Base, an Ethereum layer 2 built by Coinbase. Low fees and fast blocks let the agent act inside a short window, which matters when a single request turns into several onchain steps. The token lives here, execution happens here, and settlement clears here.

B20 standard

B20 is a token standard on Base. The $KLUV token uses it, and tokens that kluv deploys can use it as well. Working to a single standard keeps deployment predictable and keeps the tokens discoverable across Base tooling.

Token deployment

Name a token and kluv writes it to Base, sets a pool, and returns the address. The requester never touches a dashboard or a signing flow.

on x:  @kluvagent deploy a token called MyAgent, symbol AGENT
console: deploy myagent AGENT

  build metadata ......... ok
  set pool ............... ok
  write to base .......... queued
  address ................ 0x…

Onchain trading

kluv routes buys and sells through Base liquidity. Orders resolve inside the block window, and every order passes through the same guardrails as any other action.

buy 0.1 base
  quote .................. ok
  path ................... base liquidity
  slippage guard ......... on
  execute ................ filled

Tokenized stocks

Base hosts tokenized equities, which are onchain tokens that track a listed stock. kluv is built to route on these the same way it routes on any other token, so a request can name a tokenized stock instead of a crypto asset.

Signals

kluv produces a signal on request: a pair, a bias, and a window. A signal is an output, not an order. It can be read directly, or delivered to another agent as a paid endpoint.

signal base
  pair ......... BASE/USDC
  bias ......... long
  window ....... 30m

Agent commerce

Everything kluv produces can be sold. Another agent calls an endpoint, pays per request in USDC, and receives the output. The buyer is a machine, and no human sits in the loop. The mechanism is x402.

On X

Mention @kluvagent and state the command in plain language. Examples:

@kluvagent deploy a token called Nova, symbol NOVA
@kluvagent buy 0.05 eth of NOVA
@kluvagent give me a signal on base

Web console

Open the console on the site and type commands directly. The command set matches X, minus the mention. Type help to list commands. In preview mode the responses are simulated; at launch the console connects the agent wallet and executes on Base.

Command reference

Fees and limits

• Gas. Every onchain action pays Base gas, kept low by the network.
• Protocol fee. A fee on deploys and trades. Rate published at launch.
• Rate limits. Per-account limits guard against spam and protect the agent wallet.

x402 overview

x402 is an open payment protocol built by Coinbase. It revives the HTTP status code 402, "payment required," so that software can pay for a resource on its own. There is no account, no card, and no human approval. kluv uses it to charge other agents for its output.

Paid endpoints

The paid surface is the same set of capabilities, exposed to machines:

• signal. A pair, bias, and window, priced per call.
• deploy. Deployment as a service for another agent.
• execution. A routed trade on behalf of the caller.

Payment flow

The handshake takes seconds and runs entirely between machines.

█ x402 handshake
│
├─ caller ─▶ kluv · GET /signal
├─ caller ◀─ kluv · 402 · payment required
├─ caller ─▶ kluv · settle · usdc · base
├─ caller ◀─ kluv · 200 · output delivered
▘

Security model

• Wallet guardrails. Bounded scope on every signature.
• Scoped keys. Short-lived signing authority, not a raw key in the model.
• Payment verification. Output is returned only after settlement is confirmed, which blocks free-riding.
• Input hygiene. Requests are screened for injection before they reach the reasoning layer.

$KLUV

$KLUV is a B20 token on Base. It settles access to the agent and its paid endpoints. It is a utility token, not an investment, a claim on revenue, or a promise of return.

Utility and allocation

$KLUV is used inside the system for access and settlement. Allocation is published at launch, in full, before the contract is public. There is no private sale hidden behind this document.

Contract and status

The contract is not live. The address is 0x—pending until launch. When it deploys, the address is announced through the official accounts and shown here.

Roadmap

• Phase 0. Site, docs, and the console preview. Live now.
• Phase 1. $KLUV deploys on Base. Live onchain execution opens.
• Phase 2. Paid x402 endpoints for signal, deploy, and execution.
• Phase 3. An open surface for other agents to buy kluv output at scale.

FAQ

Is kluv live?

The site and console preview are live. The token, live execution, and paid endpoints are pending.

Who controls the wallet?

The agent, within guardrails. Authority is scoped and capped, never unlimited.

Does it work on both X and the web?

Yes. Same agent, same command set, two interfaces.

Is $KLUV an investment?

No. It is a utility token for access and settlement, with no promise of return.

What is B20?

A token standard on Base, used by $KLUV and by tokens kluv deploys.

What is x402?

An open payment protocol by Coinbase that lets software pay for a resource on its own.

Glossary

agent

Software that reads intent, decides, and acts without approval at each step.

onchain

Recorded and executed on a public blockchain rather than a private server.

Base

An Ethereum layer 2 built by Coinbase. kluv's home network.

B20

A token standard on Base.

x402

An open protocol for machine payments over HTTP, using stablecoins.

USDC

A dollar stablecoin, the settlement asset for paid endpoints.

guardrail

A limit on what the agent can move without a human.

tokenized stock

An onchain token that tracks a listed equity.

signal

A pair, a bias, and a window. An output, not an order.

facilitator

The service that verifies an x402 payment before a response is returned.

Disclaimers

kluv is pre-launch software. Console output is simulated until launch. Nothing here is financial, legal, or investment advice. $KLUV is a utility token with no promise of return. Onchain actions are irreversible and carry risk, including total loss. Automated trading and token issuance may be regulated where you live, and it is on you to know the rules that apply to you. Verify every address and claim against the official accounts before acting.