Kēryx: a paid tool registry for AI agents

Abstract

AI agents are becoming direct consumers of software, not just people using software through a chat window. Most tools an agent might want to call today are still gated behind human-shaped onboarding: create an account, generate an API key, attach a card, wait for approval. That flow assumes a human is present to complete it. An agent making one autonomous call to answer one question has no use for a monthly subscription and no way to click through a signup form.

Kēryx is a registry where any developer publishes a tool at a price, and any agent calls that tool by paying for exactly the call it makes. Discovery, pricing, execution, and payment happen in a single request. Settlement runs in USDC on Arc, a stablecoin-native chain built by Circle, so a call priced at half a cent is not eaten alive by transaction fees.

The problem: software built for humans, not callers

Three assumptions are baked into almost every API on the internet today, and all three break when the caller is an agent instead of a person:

• Identity is assumed to be durable. APIs expect a long-lived account: an email, a password, a dashboard the owner returns to. An agent spun up to answer one question has no durable identity worth registering.
• Payment is assumed to be recurring. Subscriptions and metered billing exist because processing a card is expensive relative to a single API call. That math does not work below a cent, which is exactly the price band most agent tool calls fall into.
• Access is assumed to be pre-provisioned. A human reads docs, gets a key, and hardcodes it. An agent discovering a new capability mid-task cannot pause to fill out a form.

None of these are hard technical problems. They are defaults that made sense when the caller was always a person, and stopped making sense the moment the caller became a stateless process with a wallet.

Design principle: pay per call, not per account

Kēryx has one design principle and everything else follows from it: the unit of access is the call, not the account. There is no signup for agents. There is no API key. A publisher lists a tool once; from then on, every agent on the internet can discover it via GET /api/tools and pay for it via POST /api/call in the same request that executes it.

This inverts the usual cost structure. Instead of a publisher absorbing infrastructure cost while hoping enough signups convert to paid plans, every single call is already paid before the response leaves the server. There is no free tier to abuse and no unpaid usage to write off.

Protocol mechanics

1. Publish

A developer registers an HTTP-callable tool: an id, a one-line summary an agent uses to decide whether to call it, a category, a price in USD, an argument schema, and the wallet that should receive payment. This is a POST /api/publishers/tools call. There is no review queue standing between listing and going live, so the tool is callable immediately (see Trust and verification for what that trade-off costs today).

2. Discover

GET /api/tools returns every published tool with its price, its argument schema, and a sample call. An agent needs no separate documentation lookup: the schema an agent uses to plan a call is the same schema Kēryx uses to validate it.

3. Call, quote, execute, pay

POST /api/call does four things in one round trip. It looks up the tool, computes a quote (the listed price, split into a publisher share and a platform fee), executes the tool's handler with the caller's arguments, and writes the result to the public ledger, whether the call succeeded or failed. The response carries the tool's result and the ledger entry id together, so a caller can prove a specific call was paid for.

4. Settle

Every call splits 95% to the publisher's wallet and 5% to the Kēryx treasury. See Settlement for how that split currently moves versus how it will move once onchain settlement is fully live.

Settlement: from simulated ledger to Arc

Kēryx settles on Arc, Circle's stablecoin-native L1 (testnet chain id 5042002, native gas denominated in USDC). Arc was chosen specifically because sub-cent pricing only works if the settlement layer does not itself cost more than the call. A registry that prices a search call at $0.004 cannot settle it on a chain where gas costs ten times that.

Today, every call computes a real quote and records a real ledger entry, visible live at /live, but the USDC transfer itself is simulated at the quoted price rather than broadcast onchain per call. The x402 payment protocol and Circle Gateway batching packages are wired into the codebase (@x402/next, @circle-fin/x402-batching) and the integration work to move from simulated to broadcast settlement is active, tracked on the docs page.

The reason to batch through Circle Gateway rather than settle every call as its own onchain transaction is the same reason Arc exists in the first place: at sub-cent price points, the cost and latency of broadcasting one transaction per call would dominate the transaction itself. Batching lets Kēryx settle many calls' worth of USDC movement in a single, periodic onchain transfer per publisher, while every individual call is still quoted, priced, and ledgered in real time.

Trust and verification

Kēryx currently distinguishes tools by a single verified flag. Tools seeded by the Kēryx team are marked verified; tools submitted through the open POST /api/publishers/tools endpoint are not, and their execution is currently Kēryx-controlled rather than delegated to arbitrary externally-hosted handlers. This is an intentional, temporary constraint: it means a submitted listing cannot yet point at a publisher's own server and have Kēryx call it directly.

The planned fix is publisher wallet verification via EIP-191 signed messages, so that a listing can only be modified by the wallet that created it, and execution can move to genuinely externally-hosted handlers without opening the registry to spoofed listings. This is not live yet; treat any community-submitted, unverified tool accordingly until it ships.

Economics

Kēryx takes a flat 5% platform fee on every call, computed at quote time and split at settlement. There is no listing fee, no minimum volume, and no subscription on either side of the market. A publisher earns from the first call. An agent pays for exactly the calls it makes and nothing else.

This only works economically because the calls themselves are priced in fractions of a cent and settle on a chain built for exactly that price band. A 5% fee on a $0.004 call is a fraction of a cent moving through a system where a fraction of a cent is still worth collecting, precisely because Arc and x402 make the collection itself nearly free.

Roadmap

• Publisher wallet signature verification (EIP-191) before externally-hosted handler execution.
• Live x402 quote endpoint with Circle Gateway batching, replacing simulated settlement.
• An MCP server so agent tools like Claude Code and Cursor can discover Kēryx tools natively, without a separate integration.
• OpenAPI spec and first-party SDKs for Node and Python.

Known limitations

This is a hackathon-stage build, and this document is written to be honest about that rather than to oversell it. Settlement is simulated, not yet broadcast onchain per call. Persistence falls back to in-memory storage when Redis is not configured, meaning registry and ledger state can reset on a cold start in that mode. Publisher-submitted tools are not signature-verified and their handlers are not yet externally hosted. All three are scoped, understood, and listed above under Roadmap rather than hidden.