Kokomoji Docs

1. Get a Kokomoji#

Kokomojis trade on OpenSea: opensea.io/collection/kokomoji-official. Hold yours in a browser wallet such as MetaMask or Rabby, and keep a little ETH there for the one transaction in step 2.

• There are 2,372 Kokomojis, numbered 1 to 2,372. The mint is closed, and the collection's maximum supply is set to 2,372.
• Check the contract before you buy. The only Kokomoji collection is 0x44Eeb5a7bCF210Ab9d2002C32c940D6f76DA8D9b on Ethereum (Etherscan).
• Every Kokomoji already has its own wallet address, its token account.

2. Register it as an agent#

One click and one signature, on kokomoji.art/agent/register/:

1. Press Connect wallet with the wallet that holds the Kokomoji.
2. Next to your Kokomoji, press Register as a Kokomoji agent. The page shows the card your Kokomoji will get, built from the live skills list.
3. The page checks the transaction right away: it warns if the Kokomoji already has an agent ID, simulates the call and estimates the gas.
4. Press Send with my wallet and sign once in your wallet. The page says Registered, waits until the card answers, then says Done.

What it creates

An agent ID in the official ERC-8004 IdentityRegistry, bound to your Kokomoji through the ERC-8217 adapter. Its agent card link is always https://kokomoji.art/agent/id/<number>.json, and kokomoji.art writes the card from the skills list. Holders write and upload nothing. The Kokomoji shows up in the registered agents index usually within 3 to 8 minutes (allow up to about 10).

What it costs

Only the Ethereum network fee, from your wallet: about 250,000 gas (247,255 to 247,267 gas used in fork tests). That is about $0.03 at 0.05 gwei and about $1.20 at 2 gwei. The page shows the estimate before you sign. Kokomoji charges nothing.

It is permanent

The agent ID stays tied to this Kokomoji forever. You can change its profile later, but you can't delete it. Registering again creates a second agent ID, so the page warns you and asks you to confirm first.

Control follows the NFT

• Only the wallet that holds a Kokomoji can register it or change its profile. Its token account can't, and neither can the Kokomoji team for a Kokomoji it doesn't hold.
• The adapter checks who holds the Kokomoji (ownerOf) on every change. When you sell or transfer it, control of the agent moves to the new holder automatically, profile included.
• Nothing moves and nothing is approved: no funds, no NFTs, no allowances. Your Kokomoji, its picture and its token account don't change.

Optional, on the same page

• Agent wallet. Set the agent's wallet to the Kokomoji's own token account (a signature, then one transaction), or clear an agent wallet a previous holder left (one transaction).
• Advanced (optional). Use your own profile link, or a profile stored on-chain (up to 4,096 bytes; it costs more gas). Switch to the standard Kokomoji card goes back.
• Optional kit. An IDENTITY.md and AGENTS.md kit for your own AI agent. It runs in your browser, needs no wallet, and Kokomoji doesn't store what you write.

DAO proposal explainer: proposal-explainerLive#

Plain-English decode of what one DAO proposal, timelock operation or Safe transaction will execute, with points to check before you vote or sign. It explains and flags; it does not judge, approve or guarantee anything. The summary is written by code from the decoded facts.

• Price: $1.00 in USDC on Base (1000000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Live since 22 October 2026.
• Who runs it: Checked by holder workers once the swarm opens: 2 to 20 seats (fewer than 12 reads: at most 4), central-only below 2 workers online. Unpaid seats for now: its checks book no worker fees and the project keeps the whole price. Too few keyless provider families serve its trace reads to pass the tests.
• Uses AI: no. Everything in the result is written by code.
• Time limit: 120 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 10 per paying wallet a day, 50 for all wallets together a day, 2 at once.
• Kept: input 30 days; result 90 days, readable at its link for that long.

What comes back. Format kokomoji.jobs.dao/1: summary (flag counts, the review-first points to confirm, the block it was read at, writtenBy), report (the decoded actions, their effects, the contracts involved, the governance context, the flags and what was not checked), the same report as markdown, and evidence with every chain read and a cast command to repeat it.

Limits of the job. It explains and flags; it never approves or guarantees a proposal. No flag is not the same as no consequence.

Input. One item per job. Unknown fields are refused. The kind decides which fields are needed.

kind: governor-proposal

kind: timelock-operation

Exactly one of queueTxHash (Compound Timelock), operationId or scheduleTxHash (TimelockController)

kind: safe-tx

Either the transaction fields (to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, nonce), executedTxHash, or safeTxHash.

kind: raw-actions

Targets and calldatas of the same length (at most 50 actions, and at most about 80 KB of calldata in total: the request body is limited to 160 KB and hex takes two characters per byte), or flavor diamond-cut with diamondCut (which may be empty when init is given)

kind: transaction

A transaction whose input is a wrapper the engine decodes (queue, schedule, propose or execTransaction)

Refused (before any payment where the input shows it): Arbitrum and OP governors; Aave Governance v3; Aragon OSx; Snapshot votes and oSnap payloads; non-EVM chains; batches of proposals or lists of DAOs; requests to find weaknesses, estimate takeover costs or write proposals.

Example input (from the catalog):

{
  "kind": "governor-proposal",
  "chain": "ethereum",
  "governor": "0x323A76393544d5ecca80cd6ef2A560C6a395b7E3",
  "proposalId": "107313977323541760723614084561841045035159333942448750767795024713131429640046"
}

DAO proposal explainer with fork simulation: proposal-simulationNot live yet#

The DAO proposal explainer plus a simulation of the proposal's own actions on a local fork of Ethereum, with the state changes it observed. The summary is written by code from the decoded facts.

• Price: $2.50 in USDC on Base (2500000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Not live yet. The fork simulation is not installed on the job server yet.
• Who runs it: Central only for now: run by the Kokomoji service, not seated yet. The project keeps the whole price.
• Uses AI: no. Everything in the result is written by code.
• Time limit: 200 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 3 per paying wallet a day, 20 for all wallets together a day, 1 at once.
• Kept: input 30 days; result 90 days, readable at its link for that long.

What comes back. Everything the proposal explainer returns, plus the simulation: each action run on a local fork of Ethereum at the pinned block, with the state changes it observed. summary.simulated is true.

Limits of the job. Ethereum only, and calls only: DELEGATECALL actions are refused here (the explainer decodes them). One simulation runs at a time.

Input. The same input as the proposal explainer, on Ethereum only (the simulation forks Ethereum mainnet).

The five kinds and their fields are those of the proposal explainer, with two differences:

• chain is always "ethereum", for every kind.
• raw-actions: every entry of operations is one of 0, "0", "call". The simulation runs every action as a call, so DELEGATECALL actions are refused here (the proposal explainer decodes them).

Refused (before any payment where the input shows it): everything the proposal explainer refuses; simulation outside Ethereum mainnet.

Example input (from the catalog):

{
  "kind": "governor-proposal",
  "chain": "ethereum",
  "governor": "0x323A76393544d5ecca80cd6ef2A560C6a395b7E3",
  "proposalId": "107313977323541760723614084561841045035159333942448750767795024713131429640046"
}

DAO health check: dao-health-checkLive#

A descriptive governance profile of one DAO: parameters, roles, concentration of voting power as shares of supply and quorum, and whether votes come from a past snapshot. No grade, no score per delegate, no takeover cost. The summary is written by code.

• Price: $2.00 in USDC on Base (2000000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Live since 22 October 2026.
• Who runs it: Central only for now: run by the Kokomoji service, not seated yet. The project keeps the whole price.
• Uses AI: no. Everything in the result is written by code.
• Time limit: 200 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 3 per paying wallet a day, 20 for all wallets together a day, 1 at once.
• Kept: input 30 days; result 90 days, readable at its link for that long.

What comes back. Format kokomoji.jobs.dao/1 with a governance profile: parameters, roles, voting power as shares of supply and quorum, and whether votes count from a past snapshot, plus markdown and evidence.

Limits of the job. Descriptive only: no grade, no figure per delegate and no takeover cost. One health check runs at a time.

Input. Send either dao (a curated alias) or governor (an address on Ethereum). OpenZeppelin Governor and GovernorBravo only in v1.

Send exactly one of dao or governor.

Refused (before any payment where the input shows it): rankings or comparisons of DAOs; linking addresses to people; takeover cost estimates.

Example input (from the catalog):

{
  "dao": "ens"
}

Governance digest: governance-watchLive#

Everything one DAO governor on Ethereum did between two blocks you choose: proposals created, vote totals, queued, executed and cancelled actions, timelock events, parameter and role changes, a state diff that catches changes with no event, and what is still open or pending at the end block. Pull it when you want; there is no subscription. Facts only: no per-voter list, ranking, prediction or voting advice. Written by code from public chain data.

• Price: $0.50 in USDC on Base (500000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Live since 22 October 2026.
• Who runs it: Checked by holder workers once the swarm opens: 2 to 20 seats (fewer than 12 reads: at most 4), central-only below 2 workers online. Unpaid seats for now: its checks book no worker fees and the project keeps the whole price. Too few keyless provider families serve its 1,000,000-block log lookback to pass the tests.
• Uses AI: no. Everything in the result is written by code.
• Time limit: 120 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 20 per paying wallet a day, 200 for all wallets together a day, 2 at once.
• Kept: input 30 days; result 30 days, readable at its link for that long.

What comes back. A digest of one governor between two blocks: the governor kind and timelock, coverage of every block range read, events in chain order (votes counted and summed per proposal, never listed per voter), proposals touched with untrusted titles quoted, timelock operations, a state diff, and what is still open at the end block.

Limits of the job. Ethereum OpenZeppelin, Bravo and Nouns style governors only; windows up to 200,000 blocks ending at least 64 blocks before the head. No subscription and no alerts.

Input. One governor and one block window per job. The window is at most 200,000 blocks (about 28 days) and ends at most 64 blocks before the chain head; without toBlock it ends there. Unknown fields are refused.

Refused (before any payment where the input shows it): governors on Arbitrum, Optimism or Base; Tornado-style, custom, GovernorAlpha-style, hash-only and Snapshot governors; Aave Governance v3 and other non-Governor DAOs; more than one governor per job; windows over 200,000 blocks or ending less than 64 blocks before the head; rankings, delegate scores, per-voter lists, predictions and voting advice; push alerts, subscriptions and schedules.

Example input (from the catalog):

{
  "chain": "ethereum",
  "governor": "0x408ED6354d4973f66138C91495F2f2FCbd8724C3",
  "fromBlock": "26100000",
  "toBlock": "26150000"
}

Multisig control profile: multisig-profileLive#

Who controls one Safe multisig on Ethereum, OP Mainnet, Arbitrum One or Base at a pinned block: version, singleton, threshold, nonce, each owner typed (account without code, EIP-7702 account, contract, nested Safe up to 3 hops, ERC-6551 token account; at most 15 typed), effective control as a plain count of signatures and distinct base keys, modules inspected (Zodiac Delay, Roles, the Safe Allowance module), guard and fallback handler, the configuration history since creation checked against the owners and threshold at the block, executions in the last 30 and 90 days, and the flags THRESHOLD_1, MODULE_OUTSIDE_OWNER_CONTROL and CONFIG_CHANGED_LAST_7_DAYS. Base shows the current configuration only. Facts only, written by code: no grade, no identities.

• Price: $0.50 in USDC on Base (500000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Live since 22 October 2026.
• Who runs it: Checked by holder workers once the swarm opens: 2 to 10 seats (fewer than 12 reads: at most 4), central-only below 2 workers online. Paid seats: once paid seats open, a worker pot of $0.3750, 75% of the price, split by work units among the matched seats.
• Uses AI: no. Everything in the result is written by code.
• Time limit: 150 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 20 per paying wallet a day, 300 for all wallets together a day, 2 at once.
• Kept: input 7 days; result 30 days, readable at its link for that long.

What comes back. Format kokomoji.multisig-profile/1: version, threshold, nonce, owners typed breadth first, effective control (signatures and distinct base keys required, owners that cannot sign on this chain), modules, guard and fallback handler, the configuration history checked against the state at the block, recent execution counts and the three flags.

Limits of the job. Base shows the current configuration only. A history longer than 110 log ranges is not read. Safe v1.0.0 is not supported.

Input. One Safe per job. Unknown fields are refused.

Refused (before any payment where the input shows it): more than one Safe, lists and batches; rankings and searches such as Safes with threshold 1; who the signers are (signer addresses are never linked to people or holders); how to compromise, attack or take over a multisig; questions such as whether a Safe can be trusted; pending (queued) transactions; non-Safe multisigs and addresses with no code (refused by the free check); configuration history on Base (the current configuration is shown); chains other than Ethereum, OP Mainnet, Arbitrum One and Base.

Example input (from the catalog):

{
  "chain": "ethereum",
  "safe": "0xb2492145ea92947C0b8dF138a398fcB22782a575"
}

Contract permissions map: permissions-mapLive#

For one verified Solidity contract on Ethereum, OP Mainnet, Arbitrum One or Base at a pinned block: proxy kind, implementation and upgrade path; owner, pending owner or renounced; every AccessControl role with its members (role events replayed from the deploy block when it is within 30,000,000 blocks of the pinned block on Ethereum, 1,000,000 on OP Mainnet and Arbitrum One and 20,000 (about 11 hours) on Base, and cross-checked with the enumerable members or hasRole at the block; for an older contract members come from the enumerable getters only, and the members of a non-enumerable role are not determined); the state-changing functions that carry a gate declared in the source, grouped by power class, with the modifier, its file and line; controllers resolved up to 3 hops (Safe m of n, timelock delay, account without code, EIP-7702 account); CONTROL_* flags; the metadata-bound source check; cast lines. Only declared gates are listed: functions without a listed gate are not claimed to be gated or ungated. Base only for contracts younger than about 14 days. Facts about declared access rules, written by code; not an audit.

• Price: $0.50 in USDC on Base (500000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Live since 22 October 2026.
• Who runs it: Checked by holder workers once the swarm opens: 2 to 12 seats (fewer than 12 reads: at most 4), central-only below 2 workers online. Paid seats: once paid seats open, a worker pot of $0.3750, 75% of the price, split by work units among the matched seats.
• Uses AI: no. Everything in the result is written by code.
• Time limit: 150 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 20 per paying wallet a day, 300 for all wallets together a day, 2 at once.
• Kept: input 7 days; result 30 days, readable at its link for that long.

What comes back. Format kokomoji.permissions-map/1: proxy and upgrade path, source and the metadata-bound check, every declared gate (modifier, file and line, holders at the block), owner and pending owner, roles with their members, controllers typed up to 3 hops, powers by class, CONTROL_* flags and cast lines, with the fixed note on what is not claimed.

Limits of the job. Functions without a listed gate are neither claimed gated nor ungated. Vyper and Yul sources are refused before payment. Timelock proposers and executors are not read.

Input. One contract per job. Unknown fields are refused.

Refused (before any payment where the input shows it): more than one address, lists and batches; searches such as find contracts where, rankings and filters; questions such as whether a contract is safe, audited or a rug; which functions are unprotected or callable by anyone; how a contract could be exploited or attacked; the cheapest way to take control of a contract; USD value at stake, balances and value locked; accounts without code and EIP-7702 accounts (refused by the free check); contracts without verified source, sources that are not Solidity and sources over about 160 KB or 40 files (refused by the free check); on Base, contracts older than about 14 days (refused by the free check); chains other than Ethereum, OP Mainnet, Arbitrum One and Base.

Example input (from the catalog):

{
  "chain": "ethereum",
  "address": "0xc18360217d8f7ab5e7c516566761ea12ce7f9d72"
}

Upgrade history and diff: upgrade-checkLive#

For one proxy on Ethereum, OP Mainnet, Arbitrum One or Base at a pinned block: the upgrade events found (Upgraded, AdminChanged, BeaconUpgraded, NewImplementation, ChangedMasterCopy, NewAdmin; the last 10 listed) with the transaction, its sender, what it ran through (Safe multisig, OpenZeppelin or Compound-style timelock, governor proposal) and the timelock's minimum delay at the block before. Event logs are read from the deploy block (Ethereum), or for the last 40 log ranges (OP Mainnet about 185 days, Arbitrum One about 11 days, Base 20,000 blocks or about 11 hours); earlier changes are found by slot probing, labelled as such (a change that was changed back between two probes is not seen). Per implementation: codehash, size, opcode capabilities, verified source, deploy block and creator as Sourcify states them, and the selector-level ABI difference of each executed upgrade. The upgrader chain at the block (admin slot, beacon, admin() or the declared UUPS gate, followed up to 3 hops), upgrades pending in the timelock queues of that chain, and a storage layout comparison ONLY for a newImplementation you supply or an upgrade pending in a timelock queue, never for an upgrade already executed. Layout differences only. Not a safety finding. Written by code, no AI.

• Price: $1.00 in USDC on Base (1000000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Live since 22 October 2026.
• Who runs it: Checked by holder workers once the swarm opens: 2 to 12 seats (fewer than 12 reads: at most 4), central-only below 2 workers online. Unpaid seats for now: its checks book no worker fees and the project keeps the whole price. Pays once workers run a signed release whose probe turns away archive providers that answer old-block reads with the latest value.
• Uses AI: no. Everything in the result is written by code.
• Time limit: 180 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 10 per paying wallet a day, 200 for all wallets together a day, 2 at once.
• Kept: input 7 days; result 30 days, readable at its link for that long.

What comes back. Format kokomoji.upgrade-check/1: the proxy family, deploy block, the history (event logs, slot probing, the first implementation), a timeline of the last 10 changes, up to 8 implementations with their facts, selector-level ABI differences, the upgrader chain, the pending queue, and layouts (compared or not compared, with the footer 'Layout differences only. Not a safety finding.').

Limits of the job. A layout is compared only for a newImplementation you supply or one pending in a timelock queue, at a block near the head, and only when the history shows it was never in place. A supplied implementation found in the executed history is refused with nothing charged.

Input. One proxy per job. Unknown fields are refused.

Refused (before any payment where the input shows it): more than one proxy, lists and batches; rankings or comparisons of proxies by upgrade risk; questions such as whether an upgrade is safe or whether there is a vulnerability; checks of uninitialized implementations and any initializer state; a storage layout comparison of an upgrade already executed; raw bytecode without an address; diamond proxies (EIP-2535) in this version (refused by the free check); accounts without code, contracts that are not proxies and proxies with an implementation fixed in their code (refused by the free check); a newImplementation without code, or one already in place (refused by the free check), or one the paid run finds in the executed history (refused, nothing charged); chains other than Ethereum, OP Mainnet, Arbitrum One and Base.

Example input (from the catalog):

{
  "chain": "ethereum",
  "proxy": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
}

Chain answer, recounted by Kokomojis: chain-answerLive#

One exact chain fact (a balance, a supply, an allowance, an owner, a storage slot, a code hash, receipt facts, or one count, sum or distinct count of event logs in a block window) read at a pinned block on Ethereum, Base, Arbitrum or OP Mainnet, with the recipe, its hash, the block hash and cast commands so anyone can re-run it. A recount at a block, not a signed attestation, not a price feed, not for settling contracts or bets. You send the recipe; no AI is used.

• Price: $0.25 in USDC on Base (250000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Live since 22 October 2026.
• Who runs it: Checked by holder workers once the swarm opens: 2 to 10 seats (fewer than 12 reads: at most 4), central-only below 2 workers online. Unpaid seats for now: its checks book no worker fees and the project keeps the whole price. Pays once workers run a signed release whose probe turns away log providers that answer known ranges short.
• Uses AI: no. Everything in the result is written by code.
• Time limit: 120 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 30 per paying wallet a day, 300 for all wallets together a day, 4 at once.
• Kept: input 30 days; result 90 days, readable at its link for that long.

What comes back. Format kokomoji.chain-answer/1: the pinned block and its hash, the normalised recipe and its hash, each value with its status (ok, reverted, unreadable, undecodable, absent) as exact decimal strings (raw, decimals, scaled), or for a window the count, sum or distinct count with per-range partials and a digest (never the list), cast lines to re-run it, and an answer line written by code.

Limits of the job. Windows end at least 64 blocks before the head: up to 100,000 blocks on Ethereum, Arbitrum One and OP Mainnet and 20,000 on Base, at most 20,000 logs. A read no endpoint answered is reported as unreadable, never as zero.

Input. One recipe per job. Unknown fields are refused. block is optional: the free check pins the latest block minus the chain's pin lag (2 blocks on Ethereum, about 2 minutes on the L2s). Questions in plain words go to chain-answer-question.

Form: recipe

recipe form: point

1 to 20 typed reads, at most 40 chain reads in all (token reads add one decimals read per token, proxySlots reads 3 slots), view reads on at most 5 contracts.

recipe form: window

One count, sum or distinct count over the logs of 1 to 5 contracts: preset transfers {token, from?, to?, aggregate: count | sum | distinctFrom | distinctTo}, or address, topics and aggregate {type: count} | {type: sum, value: {from: data, word} | {from: topic, index}} | {type: distinct, field: {from: emitter | tx | topicAddress, index}}. fromBlock and toBlock, or lastBlocks. Windows end at the pinned block and at least 64 blocks behind the head; up to 100,000 blocks on Ethereum, Arbitrum and OP Mainnet, 20,000 on Base, and 20,000 logs (more logs fail with nothing charged)

Refused (before any payment where the input shows it): prices, USD values, market figures and price feeds (price, rate and oracle view functions, and windows over swap, sync and oracle answer events, included); predictions, rankings and advice; who is behind a wallet or an address; anything that is not a chain fact at a block; signed attestations, and answers for settling contracts or bets; state-changing calls and anything that sends, signs or approves.

Example input (from the catalog):

{
  "chain": "ethereum",
  "recipe": {
    "kind": "point",
    "reads": [
      {
        "op": "ownerOf",
        "collection": "0x44eeb5a7bcf210ab9d2002c32c940d6f76da8d9b",
        "tokenId": "188"
      },
      {
        "op": "tokenSupply",
        "token": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
      }
    ]
  }
}

Chain answer from a question: chain-answer-questionNot live yet#

One exact chain fact (a balance, a supply, an allowance, an owner, a storage slot, a code hash, receipt facts, or one count, sum or distinct count of event logs in a block window) read at a pinned block on Ethereum, Base, Arbitrum or OP Mainnet, with the recipe, its hash, the block hash and cast commands so anyone can re-run it. A recount at a block, not a signed attestation, not a price feed, not for settling contracts or bets. You send a question of up to 500 characters: a model picks one recipe from the fixed menu and writes the answer from the read values only; the values are read and checked by code. A question that maps to no recipe fails with nothing charged.

• Price: $0.25 in USDC on Base (250000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Not live yet. Question mode opens later. Until then send a recipe to chain-answer.
• Who runs it: Central only: run by the Kokomoji service, never seated (a job with AI-written text cannot be re-run to the same answer). The project keeps the whole price.
• Uses AI: yes, at most $0.04 of AI per job, paid by the project. Models: Claude Sonnet 5.5 (anthropic/claude-sonnet-5.5), maps the question to one recipe and writes the answer line from the read values; Gemini 3.6 Flash (google/gemini-3.6-flash), fallback when the first model is unavailable. Called through BlockRun; the result names the model that wrote it.
• Time limit: 120 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 20 per paying wallet a day, 150 for all wallets together a day, 4 at once.
• Kept: input 30 days; result 90 days, readable at its link for that long.

What comes back. The same result as the chain answer, for the recipe the model picked. The answer line is AI-written and shown only when code finds every value in it exactly; otherwise the code-written line is shown.

Limits of the job. A question that maps to no recipe fails with nothing charged. The values are read by code; the model never reads the chain.

Input. One question per job (8 to 500 characters). block is optional and pinned by the free check.

Form: question

Refused (before any payment where the input shows it): prices, USD values, market figures and price feeds (price, rate and oracle view functions, and windows over swap, sync and oracle answer events, included); predictions, rankings and advice; who is behind a wallet or an address; anything that is not a chain fact at a block; signed attestations, and answers for settling contracts or bets; state-changing calls and anything that sends, signs or approves.

Example input (from the catalog):

{
  "chain": "ethereum",
  "question": "How many tokens does totalSupply() report for the Kokomoji contract 0x44eeb5a7bcf210ab9d2002c32c940d6f76da8d9b?"
}

Token fact sheet: token-factsLive#

Facts about one ERC-20 token at a pinned block: code and proxy, who upgrades it, owner or renounced, power functions found in the verified source ABI (or by selector) with their declared gates and getter values, supply, creator, Uniswap v2, v3 and v4 and Aerodrome pools with reserves, and on request holder concentration from Transfer logs (Ethereum: tokens deployed in the last 2,000,000 blocks, about 278 days; Base: tokens deployed in the last 20,000 blocks, about 11 hours). Facts only: no rating, no verdict and no advice. Written by code.

• Price: $0.25 in USDC on Base (250000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Live since 22 October 2026.
• Who runs it: Checked by holder workers once the swarm opens: 2 to 10 seats (fewer than 12 reads: at most 4), central-only below 2 workers online. Paid seats: once paid seats open, a worker pot of $0.1875, 75% of the price, split by work units among the matched seats.
• Uses AI: no. Everything in the result is written by code.
• Time limit: 180 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 30 per paying wallet a day, 300 for all wallets together a day, 4 at once.
• Kept: input 30 days; result 30 days, readable at its link for that long.

What comes back. Format kokomoji.token-facts/1: decimals and supply, code and proxy, upgrade control, owner or renounced (with the line that renounced does not mean no other power exists), power functions in 7 groups with their declared gates and getter values, creation, Base bridge facts, pools with raw reserves, and on request holder concentration as top 1, 10 and 50 shares (never addresses).

Limits of the job. Powers under other names are not listed (notChecked says so). Holder shares only for tokens deployed within 2,000,000 blocks on Ethereum or 20,000 on Base. Uniswap v4 is searched on Ethereum only.

Input. One token per job. Unknown fields are refused.

Refused (before any payment where the input shows it): buy or sell advice and price targets; verdicts about the token; sell or buy simulation; lists, rankings and comparisons; more than one token per job; EOAs and NFTs; who the holders are.

Example input (from the catalog):

{
  "chain": "ethereum",
  "token": "0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984",
  "holders": false
}

Token flow report: token-flowLive#

How much of one ERC-20 token moved over a block window you choose, from its Transfer events: transfer count, volume, minted and burned in token units, distinct senders and receivers (counts and digests, never lists), the share of the top 1, 5, 10 and 20 senders and receivers (addresses shown only for contracts), a supply cross-check, partial sums per block range and the flows of one focus address you name. Ethereum, Arbitrum One and OP Mainnet; windows up to 200,000 blocks and 400,000 transfers. No USD values and no labels. Written by code.

• Price: $0.50 in USDC on Base (500000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Live since 22 October 2026.
• Who runs it: Checked by holder workers once the swarm opens: 2 to 12 seats (fewer than 12 reads: at most 4), central-only below 2 workers online. Unpaid seats for now: its checks book no worker fees and the project keeps the whole price. Pays once workers run a signed release whose probe turns away log providers that answer known ranges short.
• Uses AI: no. Everything in the result is written by code.
• Time limit: 180 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 20 per paying wallet a day, 200 for all wallets together a day, 2 at once.
• Kept: input 30 days; result 30 days, readable at its link for that long.

What comes back. Format kokomoji.token-flow/1: transfer count, volume, minted, burned and net (raw and in token units), distinct senders and receivers as counts and digests, the supply check (match, differ, not checked), top 1, 5, 10 and 20 shares in parts per million, the focus address's flows and per-range partials with a re-run recipe.

Limits of the job. Only the token's Transfer events count (deposits, withdrawals and rebases do not, and the supply check shows it). Not on Base. Over 400,000 transfers fails with nothing charged.

Input. One ERC-20 token and one block window per job. The window is at most 200,000 blocks and ends at most 64 blocks before the chain head (480 on Arbitrum One); without toBlock it ends there. Unknown fields are refused.

Refused (before any payment where the input shows it): Base and other chains; ERC-721 and ERC-1155 tokens, EOAs and addresses with no code; more than one token, window or focus address per job (batches); windows over 200,000 blocks or ending too close to the head; windows with more than 400,000 Transfer events (found during the run; nothing is charged); ranking tokens, wallets or holders across tokens; following a wallet or a person across tokens or chains, and naming who is behind an address; smart-money, insider, whale and wash-trading labels; USD values, prices, advice and signals.

Example input (from the catalog):

{
  "chain": "ethereum",
  "token": "0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984",
  "fromBlock": "26230000",
  "toBlock": "26234999"
}

Sandwich check for a past swap (MEV exposure): sandwich-checkLive#

For one swap you already made (a transaction hash on Ethereum or Base, at least 64 blocks old on Ethereum or 300 on Base): the Uniswap v2, v3 and v4 pools it touched, every swap of each pool in the same block in block order, and whether an address traded in your direction right before your swap and the other way right after it in the same pool and block (addresses and roles only, with a fixed note that market makers and arbitrage traders do this too and that it is not proof of intent). For Uniswap v2 pools, an estimate of your output without the earlier trade from Sync reserves and constant-product maths under stated assumptions, in token units; v3 and v4 estimates are not computed. Every other venue is listed as not checked. No USD values, no advice, no intent claims. Written by code.

• Price: $0.25 in USDC on Base (250000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Live since 22 October 2026.
• Who runs it: Checked by holder workers once the swarm opens: 2 to 10 seats (fewer than 12 reads: at most 4), central-only below 2 workers online. Paid seats: once paid seats open, a worker pot of $0.1875, 75% of the price, split by work units among the matched seats.
• Uses AI: no. Everything in the result is written by code.
• Time limit: 120 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 20 per paying wallet a day, 300 for all wallets together a day, 2 at once.
• Kept: input 7 days; result 30 days, readable at its link for that long.

What comes back. Format kokomoji.sandwich-check/1: the transaction, each Uniswap v2, v3 or v4 pool in route order with its check, your swaps, every same-block swap of the pool (at most 40 rows), the pattern (found, not found, not found among the transactions read, not determined) with shared addresses and their roles, and for v2 an estimate under stated assumptions.

Limits of the job. Uniswap v2, v3 and v4 only; other venues are listed as not checked. No v3 or v4 estimate. The wording states what the chain shows and never claims intent or blame.

Input. One executed swap transaction per job. The free check pins a block (the head minus 64 on Ethereum; on Base the head minus 300, or the safe block when that is older) and refuses a transaction newer than it. Unknown fields are refused.

Refused (before any payment where the input shows it): chains other than Ethereum and Base; pending, dropped or unknown transactions, reverted transactions, and transactions in the last 64 blocks (Ethereum) or 300 blocks (Base); transactions without a Uniswap v2, v3 or v4 Swap event in a Uniswap pool, and routes through more than 6 Uniswap-schema pools; more than one transaction per job, bulk, batch and block-range requests, and address-based requests; rankings of traders, sandwichers, builders or anyone else; intent, blame, refund or legal wording, trading advice, live signals, predictions and prices.

Example input (from the catalog):

{
  "chain": "ethereum",
  "txHash": "0x561e4e61bd90b5eaff99fe954a454867749e97c2868751be056c3462e93f2cab"
}

Before-you-send address check: send-checkLive#

What one address is on Ethereum, Base, Arbitrum One and OP Mainnet, each at its own pinned block: code or not, kind (account without code, EIP-7702 delegation, Safe multisig with owners and threshold, ERC-6551 token account with its bound chain and NFT holder, proxy, token, burn or precompile address), nonce, ETH and USDC balance, first activity, the Chainalysis sanctions oracle answer per chain, cross-chain differences and, for a .eth name, the on-chain ENS resolver, owner and expiry. Facts only, written by code; no advice.

• Price: $0.20 in USDC on Base (200000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Live since 22 October 2026.
• Who runs it: Checked by holder workers once the swarm opens: 2 to 10 seats (fewer than 12 reads: at most 4), central-only below 2 workers online. Paid seats: once paid seats open, a worker pot of $0.1500, 75% of the price, split by work units among the matched seats.
• Uses AI: no. Everything in the result is written by code.
• Time limit: 120 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 100 per paying wallet a day, 2000 for all wallets together a day, 4 at once.
• Kept: input 7 days; result 30 days, readable at its link for that long.

What comes back. Format kokomoji.send-check/1: per chain at its own pinned block, code or not, the kind (account without code, EIP-7702 delegation, Safe with owners and threshold, ERC-6551 token account with its bound chain and NFT holder, proxy, contract), nonce, ETH and USDC balances, first activity, the sanctions oracle answer, cross-chain differences and, for a .eth name, the on-chain ENS facts. A Kokomoji token account gets the fixed line that it is bound to Ethereum and that funds sent to it on Base, Arbitrum One or OP Mainnet cannot be used by it.

Limits of the job. No code at an address on a chain does not mean it is an empty wallet. Off-chain and wildcard ENS resolvers are not followed. Never says send or do not send.

Input. One address per job, public mode. Unknown fields are refused.

Refused (before any payment where the input shows it): lists, batches and bulk screening (one address per job); questions such as whether an address is safe, who owns it or whether it is a known scammer; resolving an address to a person or an identity (no reverse ENS); the from address of the later lookalike and dust check; non-EVM addresses; chains other than Ethereum, Base, Arbitrum One and OP Mainnet; .eth names that do not resolve on-chain (off-chain and wildcard resolvers are not followed).

Example input (from the catalog):

{
  "to": "0x9d02ea2f7ba3554d8e71c0f3eb0671df3f268224",
  "chain": "base"
}

Open approvals check: approval-checkLive#

Every permission one owner still gives away at a pinned block: ERC-20 allowances above 0, ERC-721 and ERC-1155 operator permissions that are on, and Permit2 allowances (amount, expiration, nonce). Found from the owner's Approval, ApprovalForAll and Permit2 logs and confirmed by reads at the block. Each comes with the unsigned call that switches it off, wrapped for the account type: a plain call for a wallet, the ERC-6551 execute() call for a Kokomoji token account, a Safe transaction note for a Safe. Spenders are typed (code kind, label from fixed lists, verified source, age, who upgrades it). Facts only, written by code; no risk labels.

• Price: $0.25 in USDC on Base (250000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Live since 22 October 2026.
• Who runs it: Checked by holder workers once the swarm opens: 2 to 10 seats (fewer than 12 reads: at most 4), central-only below 2 workers online. Paid seats: once paid seats open, a worker pot of $0.1875, 75% of the price, split by work units among the matched seats.
• Uses AI: no. Everything in the result is written by code.
• Time limit: 120 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 30 per paying wallet a day, 1000 for all wallets together a day, 4 at once.
• Kept: input 7 days; result 30 days, readable at its link for that long.

What comes back. Format kokomoji.approval-check/1: ERC-20 allowances above 0, operators that are on, Permit2 allowances, up to 25 typed spenders, and for each one the unsigned call that switches it off, wrapped for the account (a plain call, the token account's execute(), a Safe transaction note). Nothing is signed or sent for you.

Limits of the job. Not on Base. OP Mainnet and Arbitrum One are searched from 4,000,000 blocks before the pinned block only. Single-token ERC-721 approvals are counted, not listed; allowances set without an event are not seen. Any unread range fails the job with nothing charged.

Input. One owner per job: {chain, owner} or {kokomoji}. Unknown fields are refused; the pinned block is set by the service.

Refused (before any payment where the input shows it): more than one owner, owner lists and batches; reverse lookup by spender or operator; rankings and lists of wallets; questions such as whether a spender is malicious, and any grade or score; signing, sending or executing a revoke (the calldata is unsigned); USD values and exposure totals; Base and every chain other than Ethereum, OP Mainnet and Arbitrum One; owners over the activity gate (more than 5,000 transactions, or more approval logs than one job reads).

Example input (from the catalog):

{
  "kokomoji": 188
}

EIP-7702 delegation check: delegation-checkLive#

Before or after a wallet signs an EIP-7702 delegation: what the delegate code is (code size and codehash, bytecode identity with a dated list of published wallet delegate releases, opcode capabilities, verified source with the metadata-bound check, creation block and age, a plain per-function listing with check bodies not analysed), what can change what the account runs (storage slots and zero-argument getters read at the account and at the delegate), the same code on the other three chains, and on which of Ethereum, Base, Arbitrum One and OP Mainnet the delegation is set at the pinned blocks. For an unsigned authorization tuple: its digest, chainId 0 flagged as valid on every chain, and its nonce against the account nonce. Facts only, written by code; no advice about signing.

• Price: $0.25 in USDC on Base (250000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Live since 22 October 2026.
• Who runs it: Checked by holder workers once the swarm opens: 2 to 10 seats (fewer than 12 reads: at most 4), central-only below 2 workers online. Paid seats: once paid seats open, a worker pot of $0.1875, 75% of the price, split by work units among the matched seats.
• Uses AI: no. Everything in the result is written by code.
• Time limit: 120 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 30 per paying wallet a day, 1000 for all wallets together a day, 4 at once.
• Kept: input 7 days; result 30 days, readable at its link for that long.

What comes back. Format kokomoji.delegation-check/1: per chain the account's status (delegated with the target, no code, contract code), the delegate's code facts against a dated list of published wallet delegate releases, storage slots and getters at the delegate and the account, verified source, creation, a plain per-function listing, and for an authorization tuple its digest, scope and nonce facts.

Limits of the job. Function bodies are not analysed. Creation facts come from Sourcify only. Pending authorizations and signatures are not read.

Input. Exactly one of {chain, delegate}, {chain, account} or {chain, account, authorization}. One item per job; never a signature or signed authorization bytes. Unknown fields are refused.

Refused (before any payment where the input shows it): lists and batches (one delegate, one account, or one account with one authorization per job); signatures and signed authorization bytes; recovering a signer; which accounts delegate to an address; ranking or comparing delegates; questions such as whether a delegate is safe, a sweeper or a scam, whether funds can be drained, or whether to sign; pending or unmined authorizations; chains other than Ethereum, Base, Arbitrum One and OP Mainnet, and an authorization chainId other than 0 or the chain's id; more than 5 distinct accounts or 10 distinct delegates per payer a day.

Example input (from the catalog):

{
  "chain": "ethereum",
  "account": "0x13fa86ce645655eab92b14a4e0fbbff3bec56974"
}

ERC-8004 agent dossier: agent-card-checkLive#

One ERC-8004 agent on Ethereum or Base at a pinned block: owner and its kind (account, Safe multisig, ERC-6551 token account, ERC-8217 adapter binding with the controlling NFT and its holder), agentURI scheme, the agent card's sha256 and registration-file checks (match, mismatch, not checked, unreachable), whether the card points back to the registration, agentWallet on chain against the card, metadata keys, registration block, and ReputationRegistry feedback counts, revocations, responses, reviewer shares and per-tag ranges. Endpoints are listed, never contacted. Facts written by code; no trust score.

• Price: $0.25 in USDC on Base (250000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Live since 22 October 2026.
• Who runs it: Checked by holder workers once the swarm opens: 2 to 10 seats (fewer than 12 reads: at most 4), central-only below 2 workers online. Paid seats: once paid seats open, a worker pot of $0.1875, 75% of the price, split by work units among the matched seats.
• Uses AI: no. Everything in the result is written by code.
• Time limit: 150 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 50 per paying wallet a day, 1000 for all wallets together a day, 2 at once.
• Kept: input 7 days; result 30 days, readable at its link for that long.

What comes back. Format kokomoji.agent-card-check/1: owner and kind, the ERC-8217 binding and NFT holder (and the Kokomoji behind the agent, if any), agentURI facts (scheme, length, sha256; never the URI itself), the card checks, agentWallet, registration block, feedback counts, revocations, responses and reviewer shares.

Limits of the job. Endpoints in the card are listed, never contacted. History covers 100,000 blocks on Ethereum and 20,000 on Base. Over 1,000 reviewers only counts are given.

Input. One agent per job. Unknown fields are refused; there is no URL or free-text input.

Refused (before any payment where the input shows it): listing, searching or ranking agents or reviewers (one agent per job); contacting an agent's endpoints; questions such as whether an agent is trustworthy, legit or fit to hire; chains other than Ethereum and Base; URL or free-text input (the card is the one the agent registered on chain); tracing who funds reviewers or agents; an agent id with no agent at the pinned block.

Example input (from the catalog):

{
  "chain": "ethereum",
  "agentId": "54304"
}

Check an x402 payment request before paying: x402-payee-checkLive#

Chain facts about one x402 exact payment requirement on Base or Ethereum before an agent pays it, at pinned blocks: whether the asset is the canonical USDC, its on-chain name, version, decimals and EIP-712 domain against the seller's extra, amount and timeout against common ranges, what payTo is on Ethereum and Base (account without code, EIP-7702, Safe, ERC-6551 token account with its bound chain, Kokomoji token account, contract), the Chainalysis sanctions oracle answer per chain, USDC paused() and isBlacklisted(payTo), USDC received by payTo over a stated block window (raw counts), the ERC-8004 agent wallet when an agentId is given, and the unsigned EIP-3009 authorization fields when given. Receipt mode: one past payment's transaction, field by field against what was expected (matches or does not match). Facts, not a promise that the seller delivers; written by code, no advice.

• Price: $0.20 in USDC on Base (200000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Live since 22 October 2026.
• Who runs it: Central only: run by the Kokomoji service, never seated, because its input is not stored (a private input never goes to holder machines). The project keeps the whole price.
• Uses AI: no. Everything in the result is written by code.
• Time limit: 120 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 100 per paying wallet a day, 2000 for all wallets together a day, 4 at once.
• Kept: input not stored (a keyed hash and its length only); result 7 days, readable at its link for that long.

What comes back. Format kokomoji.x402-payee-check/1: the requirement's facts (canonical USDC or not, domain against the seller's extra, amount and timeout against common ranges, payTo's kind on both chains in words, sanctions oracle, paused() and isBlacklisted, USDC received by payTo in a stated window), or in receipt mode each field of the past payment with matches or does not match. Footer: facts, not a promise that the seller delivers.

Limits of the job. One requirement per job. An unreadable sanctions answer on the payment chain fails the job with nothing charged. The Base window is about 5.5 hours.

Input. Either one x402 payment requirement (paymentRequirements, optional agentId, agentChain and authorization) or one past payment (chain, txHash, expect). Unknown fields at any level are refused; no field may hold a URL.

Refused (before any payment where the input shows it): a URL, a resource or a description in any field (nothing is fetched and the seller is never contacted); more than one payment requirement, or the whole 402 answer; schemes other than exact, and Permit2 payments; networks other than Base (eip155:8453) and Ethereum (eip155:1); questions such as whether a seller is reliable or will deliver; a payTo (or expected recipient) equal to the payer of the check, and an authorization whose from is the payTo; a signature; unknown transaction hashes, transactions less than 64 blocks below the head, transactions with more than 50 logs, batches and 'all payments to an address'.

Example input (from the catalog):

{
  "paymentRequirements": {
    "scheme": "exact",
    "network": "eip155:8453",
    "amount": "20000",
    "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    "payTo": "0x7284d41b5b852f2bd4c99bdf95043d84452d299c",
    "maxTimeoutSeconds": 60,
    "extra": {
      "name": "USD Coin",
      "version": "2"
    }
  }
}

Art critique: art-critiqueLive#

A short critique of one NFT's artwork: scores for colour harmony, composition, expression and synergy, a headline and a 2 to 3 sentence review. AI output from a vision model.

• Price: $0.10 in USDC on Base (100000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Live since 22 October 2026. Its one-time calibration passed on 22 October 2026.
• Who runs it: Central only: run by the Kokomoji service, never seated (a job with AI-written text cannot be re-run to the same answer). The project keeps the whole price.
• Uses AI: yes, at most $0.03 of AI per job, paid by the project. Models: Claude Sonnet 5.5 (anthropic/claude-sonnet-5.5), writes the critique; Gemini 3.6 Flash (google/gemini-3.6-flash), fallback when the first model is unavailable. Called through BlockRun; the result names the model that wrote it.
• Time limit: 150 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 20 per paying wallet a day, 100 for all wallets together a day, 2 at once.
• Kept: input 30 days; result 90 days, readable at its link for that long.
• Also at most 50 critiques of NFTs from one collection a UTC day, for all wallets together (429 limit_collection).

What comes back. Four scores from 1.0 to 10.0 (colour harmony, composition, expression, synergy), their mean as overall, a headline, a one-line take and a 2 to 3 sentence review, the image's sha256, the model that wrote it and the calibration version.

Limits of the job. Ethereum and Base NFTs only, by contract and token id (no image links). At most 50 critiques of one collection a UTC day for all wallets together.

Input. An NFT reference only: no image URLs, no free text.

Refused (before any payment where the input shows it): adult content; hate; gore; self harm; real people; text-heavy images; placeholders; images that are not artwork; image URLs (NFT references only).

Its input checks refuse with the art critique's own codes, always before any payment (see Errors and limits). An image the model declines during the paid job comes back as 422 job_refused with the reason, and nothing is charged.

Example input (from the catalog):

{
  "chain": "ethereum",
  "contract": "0x44Eeb5a7bCF210Ab9d2002C32c940D6f76DA8D9b",
  "tokenId": "188"
}

Royalty and transfer rules check: transfer-rules-checkLive#

One ERC-721 collection's royalty (ERC-2981 and the Royalty Registry and Royalty Engine settings marketplaces read) and its transfer validator rules at one pinned block: the validator in words, its lists, the number of frozen accounts, and a simulation matrix of which reference wallets and marketplace contracts the validator lets move the tokens. Facts only, written by code; no verdict.

• Price: $0.30 in USDC on Base (300000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Live since 22 October 2026.
• Who runs it: Checked by holder workers once the swarm opens: 2 to 10 seats (fewer than 12 reads: at most 4), central-only below 2 workers online. Paid seats: once paid seats open, a worker pot of $0.2250, 75% of the price, split by work units among the matched seats.
• Uses AI: no. Everything in the result is written by code.
• Time limit: 120 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 20 per paying wallet a day, 200 for all wallets together a day, 2 at once.
• Kept: input 30 days; result 30 days, readable at its link for that long.

What comes back. Format kokomoji.transfer-rules-check/1: collection facts, the royalty (ERC-2981 samples in basis points, the Royalty Registry and Royalty Engine settings, the receiver's kind on Ethereum and Base), the transfer validator and its policy in numbers and words, the frozen account count (never the addresses), operators against pinned code hashes, and the simulation matrix with cells allowed by the validator, blocked: <error> or not simulated: <reason>.

Limits of the job. It simulates the validator's transfer rules only. Validators without a simulation function read not simulated. Reference wallets are fixed example addresses and can change (reference changed).

Input. One ERC-721 collection per job. Unknown fields are refused.

Refused (before any payment where the input shows it): contracts that do not report the ERC-721 interface; more than one collection, scanning or comparing collections; more than 5 token ids or more than one wallet; marketplace recommendations or help getting around a collection's rules.

Example input (from the catalog):

{
  "chain": "ethereum",
  "contract": "0x44Eeb5a7bCF210Ab9d2002C32c940D6f76DA8D9b",
  "tokenIds": [
    "188"
  ]
}

NFT contract powers and drop settings: mint-contract-checkLive#

For one NFT contract at a pinned block: what its team can still change (mint more, the maximum supply, the base URI and metadata and whether they are frozen, the royalty, the transfer validator and account freezing, pause, blocklists, withdrawals and where proceeds go, burning others' tokens, upgrades, ownership and roles), each power with its holder and how the holder was resolved, plus the drop settings (SeaDrop public drop, creator payout address and whether it has code on Ethereum and Base, allowlist root, signers, payers, minted against max) and, with expect, match or differ per field. Facts only, written by code; not an audit.

• Price: $1.00 in USDC on Base (1000000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Live since 22 October 2026.
• Who runs it: Checked by holder workers once the swarm opens: 2 to 10 seats (fewer than 12 reads: at most 4), central-only below 2 workers online. Paid seats: once paid seats open, a worker pot of $0.7500, 75% of the price, split by work units among the matched seats.
• Uses AI: no. Everything in the result is written by code.
• Time limit: 150 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 20 per paying wallet a day, 200 for all wallets together a day, 2 at once.
• Kept: input 7 days; result 30 days, readable at its link for that long.

What comes back. Format kokomoji.mint-contract-check/1: the collection, upgrade path, source binding, declared gates, owner and roles, the powers with their holders and how each holder was resolved, the getters, royalty, transfer validator, SeaDrop drop settings with the phase at the block, the payout address typed on both chains, and expect answered match, differ, not read or not applicable.

Limits of the job. Only functions with a declared or known gate are listed. ERC1155SeaDrop, Zora, Manifold and thirdweb drops are not decoded. Not an audit.

Input. One NFT contract (ERC-721 or ERC-1155) per job. Unknown fields are refused.

Refused (before any payment where the input shows it): contracts that report neither the ERC-721 nor the ERC-1155 interface, and addresses without code; more than one contract, comparing contracts or scanning a creator's other contracts; questions such as whether the contract can be relied on, who can call a function, code review for bugs; valuation and prices of tokens; chains other than Ethereum and Base.

Example input (from the catalog):

{
  "chain": "ethereum",
  "contract": "0x44Eeb5a7bCF210Ab9d2002C32c940D6f76DA8D9b",
  "expect": {
    "payoutAddress": "0xb2492145ea92947C0b8dF138a398fcB22782a575",
    "royaltyBps": "500"
  }
}

NFT holder snapshot: holder-snapshotLive#

Who holds every token of one ERC-721 or ERC-721A collection at a block: a tokenId-to-owner CSV and JSON file (lowercase addresses, sorted by token id, ids with no owner at the block marked with a fixed code), the holder count, the top-1, top-10 and top-50 shares (aggregates only), owner types by code at the block (no code, EIP-7702, Safe, ERC-6551 account, Kokomoji token account address, other contract, burn address), an optional diff against an earlier block (counts only), an optional OpenSea Studio allowlist CSV, and the sha256 of every file and of every ownerOf batch. Ethereum and Base; up to 3,000 token ids; the 1,500 largest owners are typed, owners beyond them are not typed and excludeContracts does not apply to them. Addresses only: no ENS, labels or enrichment. A snapshot of one block, not an attestation of eligibility. Written by code.

• Price: $2.00 in USDC on Base (2000000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Live since 22 October 2026.
• Who runs it: Checked by holder workers once the swarm opens: 2 to 20 seats (fewer than 12 reads: at most 4), central-only below 2 workers online. Paid seats: once paid seats open, a worker pot of $1.5000, 75% of the price, split by work units among the matched seats.
• Uses AI: no. Everything in the result is written by code.
• Time limit: 240 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 10 per paying wallet a day, 80 for all wallets together a day, 1 at once.
• Kept: input 7 days; result 7 days, readable at its link for that long.

What comes back. Format kokomoji.holder-snapshot/1: token counts, holder count, top shares in parts per million, owner types, an optional compare with an earlier block (counts only), per-batch sha256 and their digest, and the files -owners.csv, -owners.json and, on request, an OpenSea allowlist CSV. The files go to the payer only: the public result page shows their hashes, not their content.

Limits of the job. ERC-721 and ERC-721A only, up to 3,000 token ids, one snapshot at a time. Owners beyond the 1,500 largest are not typed. A Kokomoji token-account address on Base is typed with the fixed warning.

Input. One ERC-721 or ERC-721A collection per job. Without a token id range, every token the collection has at the block is read (totalSupply() at most 3,000). block is at most the head minus 2 blocks on Ethereum (60 on Base); without it the free check pins that block. Unknown fields are refused.

Refused (before any payment where the input shows it): chains other than Ethereum and Base; ERC-1155 collections (later), contracts that do not report ERC-721 support, EOAs and addresses with no code; more than one collection per job, lists of token ids and 'find collections with property X'; more than 3,000 token ids (a range or totalSupply()); a range is needed when totalSupply() does not answer; linking addresses to people, ENS names or labels, clustering and enrichment; wallet-level movement tracking and per-holder rankings; statements that an address is eligible for any airdrop or sale; Merkle output (off in v1); blocks newer than the head minus the chain's pin lag.

Example input (from the catalog):

{
  "chain": "ethereum",
  "contract": "0x44eeB5A7bcF210Ab9d2002c32C940d6F76DA8D9b",
  "export": "opensea-allowlist"
}

Unknown NFT airdrop check: airdrop-checkLive#

Plain chain facts about one NFT you did not ask for, at a pinned block on Ethereum or Base: contract age from its deploy block, verified source and the metadata-bound check, standard conformance (ERC-721 or ERC-1155 interfaces), ownerOf against the last Transfer event of the token, bytecode capability counts, the approval-related functions present, the deployer as kind, nonce and first-activity age only, the delivering transaction's transfer and recipient counts, the collection's mint pattern as counts (a lower bound when capped at 20,000 logs), and the tokenURI decoded without fetching any link, with the domains it names. A list of points to check and what was not checked. Facts only, written by code: no verdict, and no list of which text rules matched.

• Price: $0.25 in USDC on Base (250000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Live since 22 October 2026.
• Who runs it: Checked by holder workers once the swarm opens: 2 to 10 seats (fewer than 12 reads: at most 4), central-only below 2 workers online. Paid seats: once paid seats open, a worker pot of $0.1875, 75% of the price, split by work units among the matched seats.
• Uses AI: no. Everything in the result is written by code.
• Time limit: 150 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 30 per paying wallet a day, 600 for all wallets together a day, 3 at once.
• Kept: input 7 days; result 7 days, readable at its link for that long.

What comes back. Format kokomoji.airdrop-check/1: contract code facts, standard conformance, the collection name and symbol quoted and defanged, creation and age, the deployer as kind and age only (never its address), source binding, approval-related functions, ownerOf against the last transfer, the delivering transaction's counts, the mint pattern, and points to check with the line that no points found is not an assurance.

Limits of the job. The tokenURI is decoded locally, never fetched. The collection scan covers 100,000 blocks on Ethereum and 20,000 on Base, at most 20,000 logs (counts are then lower bounds).

Input. One token per job. Unknown fields are refused.

Refused (before any payment where the input shows it): any verdict or grade, such as whether it is safe to claim or approve; checking a website, a claim link or a signature request (no link is fetched); wallet history, recipient lists and other contracts of the same deployer; advice on rewording an airdrop or its metadata so points disappear; batches: one token per job; addresses with no code and contracts that report neither ERC-721 nor ERC-1155 (refused by the free check); a txHash that is not on the chain or emitted no event from the contract (refused by the free check); collections with more than 100,000 transfer events (refused by the free check); chains other than Ethereum and Base.

Example input (from the catalog):

{
  "chain": "ethereum",
  "contract": "0x44eeb5a7bcf210ab9d2002c32c940d6f76da8d9b",
  "tokenId": "188"
}

Token provenance trail: provenance-trailLive#

One ERC-721 token's transfer trail from its mint to its owner at a pinned block, from chain data: the mint (minter, the mint transaction's sender and ETH value and the tokens minted in it, not a per-token price; whether the minter equals the contract deployer or its owner() at the mint block), every later transfer typed (sale with price and royalty for Seaport and Blur, 'transfer, marketplace not decoded', token-account move, escrow, burn or plain), holding periods from block timestamps, the owner at the block typed (EOA, contract, ERC-6551 token-bound account, known escrow), ERC-2309 ranges and ERC-4906 metadata events naming the token. Ethereum (any age) and Base (contracts deployed within 20,000 blocks); at most 200 transfers. Addresses only, no verdicts and no value estimates. Written by code.

• Price: $0.50 in USDC on Base (500000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Live since 22 October 2026.
• Who runs it: Checked by holder workers once the swarm opens: 2 to 10 seats (fewer than 12 reads: at most 4), central-only below 2 workers online. Paid seats: once paid seats open, a worker pot of $0.3750, 75% of the price, split by work units among the matched seats.
• Uses AI: no. Everything in the result is written by code.
• Time limit: 180 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 20 per paying wallet a day, 300 for all wallets together a day, 2 at once.
• Kept: input 30 days; result 30 days, readable at its link for that long.

What comes back. Format kokomoji.provenance-trail/1: the token and its owner at the block, the deploy block and creator, the mint, every event typed (mint, burn, sale with price and royalty for Seaport and Blur, token-account move, escrow, plain transfer), holding periods, ERC-4906 and ERC-2309 events, the ownerOf check and each party typed by code at the block.

Limits of the job. At most 200 transfers after the mint. Base contracts within 20,000 blocks only. Parties are typed at the pinned block, not at each transfer.

Input. One ERC-721 token per job. The trail is read at atBlock, or at the head minus 64 blocks on Ethereum (minus 300 on Base), pinned by the free check. Unknown fields are refused.

Refused (before any payment where the input shows it): chains other than Ethereum and Base; more than one token per job, lists and batches, and wallet-based queries ('all NFTs of wallet X'); ERC-1155 tokens, CryptoPunks, CryptoKitties and other pre-ERC-721 contracts, and contracts that do not answer true to supportsInterface(0x80ac58cd); tokens without an owner at the block (ownerOf reverts); tokens with more than 200 transfers (found during the run; nothing is charged, then refused before the 402 for an hour); Base contracts deployed more than 20,000 blocks before the block; verdicts on theft, fraud, authenticity or wash trading; price or value estimates, and naming who is behind an address.

Example input (from the catalog):

{
  "chain": "ethereum",
  "contract": "0x44eeb5a7bcf210ab9d2002c32c940d6f76da8d9b",
  "tokenId": "296"
}

Before you list or buy one NFT (step 1): listing-checkLive#

Facts about one ERC-721 token at a pinned block, before you buy or list it: first the state of its ERC-6551 token account (lock state, owner() against ownerOf, and the line 'contents can move until the sale settles; this is block B'), then the owner and its kind, the frozen flag, the transfer validator and its simulations, the royalty at your price, the open approvals that touch the token (getApproved, the OpenSea conduit and the other marketplace operators), the recent transfers with Seaport and Blur sales decoded, the tokenURI kind, and the token account on Ethereum and Base (deployed or not, token() binding against the chain shown: 'bound to chain X; not usable on chain Y', implementation, ETH, WETH and USDC balances). Ethereum and Base. Facts only, written by code; no buy, sell or hold advice and no verdict.

• Price: $0.35 in USDC on Base (350000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Live since 22 October 2026.
• Who runs it: Checked by holder workers once the swarm opens: 2 to 10 seats (fewer than 12 reads: at most 4), central-only below 2 workers online. Paid seats: once paid seats open, a worker pot of $0.2625, 75% of the price, split by work units among the matched seats.
• Uses AI: no. Everything in the result is written by code.
• Time limit: 150 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 20 per paying wallet a day, 300 for all wallets together a day, 2 at once.
• Kept: input 24 hours; result 24 hours, readable at its link for that long.

What comes back. Format kokomoji.listing-check/1: first the token account's lock state and owner() against ownerOf, then the token, its transfer rules (the royalty and transfer rules check run on the same blocks), approvals, the last 10 transfers with sales decoded, and the token account on Ethereum and Base. The result is not cacheable and is served with no-store.

Limits of the job. Recent windows: the last 1,000,000 blocks on Ethereum and 2,000 on Base. The tokenURI is not fetched. Lock views are decoded for the Kokomoji token account implementation only.

Input. One ERC-721 token per job: chain, contract and tokenId, or one marketplace link (OpenSea, Blur or Magic Eden item page) parsed to those three fields only and never fetched. The facts are read at atBlock on the token's chain, or at the head minus the pin lag, with the other chain pinned at the same time by the free check. Unknown fields are refused.

Refused (before any payment where the input shows it): buy, sell or hold advice, valuations, and ratings of sellers, buyers or collections; more than one token per job, lists and batches, wallet or collection scans, and listings of tokens; following or fetching links (a marketplace link is parsed to chain, contract and token id only); simulating a purchase or providing calldata; chains other than Ethereum and Base; contracts without code or without the ERC-721 interface at the block, and tokens without an owner at the block.

Example input (from the catalog):

{
  "chain": "ethereum",
  "contract": "0x44eeb5a7bcf210ab9d2002c32c940d6f76da8d9b",
  "tokenId": "188",
  "priceWei": "27000000000000000",
  "side": "buy"
}

Ethereum standard explainer: eip-explainerNot live yet#

One Ethereum standard (an EIP or ERC number) explained in plain English, read from its official text in ethereum/ERCs or ethereum/EIPs at a pinned commit (yours, or the daily snapshot of master). You get the status line first (with a MAY CHANGE line for a standard that is not Final), the header facts (type, category, created, required standards; no author names), a 300 to 600 word explanation, what it means in practice, a glossary of 5 to 10 terms that occur in the text, and 5 to 10 quotes copied from the text, found by code at their line numbers. The explanation is AI-written; the quotes are the specification's own lines. English only.

• Price: $0.15 in USDC on Base (150000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Not live yet. Its calibration ran again on 22 October 2026 and passed 15 of its 18 checks (it needs all of them), so it stays closed until a new calibration passes (503 not_calibrated before any payment).
• Who runs it: Central only: run by the Kokomoji service, never seated (a job with AI-written text cannot be re-run to the same answer). The project keeps the whole price.
• Uses AI: yes, at most $0.08 of AI per job, paid by the project. Models: Claude Sonnet 5.5 (anthropic/claude-sonnet-5.5), writes the explanation; Gemini 3.6 Flash (google/gemini-3.6-flash), fallback writer, and checks that each quote supports its paragraph. Called through BlockRun; the result names the model that wrote it.
• Time limit: 150 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 20 per paying wallet a day, 200 for all wallets together a day, 2 at once.
• Kept: input 30 days; result 90 days, readable at its link for that long.

What comes back. Format kokomoji.eip-explainer/1: the status line first (with MAY CHANGE unless Final or Withdrawn), header facts, the pinned source (repository, commit, path, sha256), a 300 to 600 word explanation citing quote ids, what it means in practice, a glossary, 5 to 10 quotes with their line numbers, the CC0 note, the answer hash and the AI disclosure.

Limits of the job. English only. A commit ahead of or diverged from master is refused. Specs written mostly as code may not reach 5 quotes. An answer that fails the code checks twice fails with nothing charged.

Input. One standard per job. Unknown fields are refused, and so are URLs, repositories, paths and free text. commit is optional: without it the job reads today's snapshot of master (the same commit for every request of the UTC day, so answers are cached).

Refused (before any payment where the input shows it): anything that is not an EIP or ERC number in ethereum/ERCs or ethereum/EIPs; a commit that is not in the history of master (a fork or an unmerged pull request), a short hash, a branch or a tag; a standard marked moved at the commit sent (send a commit of ethereum/ERCs, or none); URLs, repositories, paths and free text; implementation code, attack explanations and investment views; languages other than English.

Example input (from the catalog):

{
  "standard": "ERC-20",
  "level": "newcomer"
}

Claim check against pinned sources: claim-checkLive#

One factual claim (up to 300 characters) checked against version-pinned open sources: Wikipedia revisions by oldid, arXiv papers at a version, and Ethereum EIPs and ERCs at a commit. The job searches for and against the claim and answers supported, contradicted, mixed or not found in the checked sources, never true or false, with up to 5 quotes that code found verbatim in the fetched text (the source's own words at the given offsets), the pinned links, and whether both models agree. A first model proposes the status and quotes and a second model checks them. AI output. The claim itself goes only to BlockRun and the model providers and is not stored; search terms derived from it (written by a model, or up to 6 of its keywords when the model's plan is unreadable) are sent to the Wikipedia, arXiv and GitHub search and read APIs.

• Price: $0.10 in USDC on Base (100000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Live since 22 October 2026. Its one-time calibration passed on 22 October 2026.
• Who runs it: Central only: run by the Kokomoji service, never seated (a job with AI-written text cannot be re-run to the same answer). The project keeps the whole price.
• Uses AI: yes, at most $0.06 of AI per job, paid by the project. Models: Gemini 3.6 Flash (google/gemini-3.6-flash), first model: classifies the claim, plans the searches and proposes the status and quotes; Claude Sonnet 5.5 (anthropic/claude-sonnet-5.5), second model: checks the quotes and the status. Called through BlockRun; the result names the model that wrote it.
• Time limit: 120 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 20 per paying wallet a day, 200 for all wallets together a day, 2 at once.
• Kept: input not stored (a keyed hash and its length only); result 24 hours, readable at its link for that long.

What comes back. Format kokomoji.claim-check/1: status (supported, contradicted, mixed or not_found, never true or false) with its reason, whether both models agree, up to 5 quotes found verbatim with offsets, the pinned sources with sha256, the searches made, unreadable sources and the disclosure.

Limits of the job. Claims with allegation words, on-chain numbers (send those to chain-answer), prices, predictions and current elections are refused before payment. The Wikipedia pin is the revision current at the time of the job.

Input. One factual statement per job. No links, no questions, no lists. lang picks the Wikipedia edition (default en).

Refused (before any payment where the input shows it): claims about private individuals, and allegations about named people; prices, market figures and predictions; medical, legal, financial and other should I questions; on-chain facts and numbers (send them to chain-answer); finding a source for a conclusion you already hold; links (citation mode is not offered yet); claims about current or recent elections; secrets such as keys, tokens and seed phrases.

Example input (from the catalog):

{
  "claim": "The Eiffel Tower was completed in 1889.",
  "topic": "general"
}

Crypto message explainer: message-explainerLive#

A crypto message you received (an airdrop notice, a support DM, an announcement) explained calmly: what it asks you to do in plain words (AI-written, from a redacted copy; the AI paragraph is off until its checks pass, and until then the result is written by code only), facts read at a pinned block about every address in it on Ethereum or Base (contract or not, token facts, proxy, verified source name, deploy block; no balances, no reverse names, no owner lookups), and static notes on every domain in it (punycode decoded, lookalikes of a pinned list of well-known domains, near-miss spellings, shorteners, chat invites). Links are never opened, fetched or resolved. It never says whether a message is genuine or who sent it. The text is not stored: only a keyed hash and its length are kept, and the result is kept 24 hours.

• Price: $0.15 in USDC on Base (150000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Live since 22 October 2026. Its AI paragraph stays switched off until its injection tests and calibration pass; until then the result is written by code only.
• Who runs it: Central only: run by the Kokomoji service, never seated (a job with AI-written text cannot be re-run to the same answer). The project keeps the whole price.
• Uses AI: yes, at most $0.02 of AI per job, paid by the project. Models: Claude Sonnet 5.5 (anthropic/claude-sonnet-5.5), writes the plain paragraph on what the message asks, from a redacted copy; Gemini 3.6 Flash (google/gemini-3.6-flash), fallback when the first model is unavailable. Called through BlockRun; the result names the model that wrote it.
• Time limit: 90 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 20 per paying wallet a day, 300 for all wallets together a day, 2 at once.
• Kept: input not stored (a keyed hash and its length only); result 24 hours, readable at its link for that long.

What comes back. Format kokomoji.message-explainer/1: the chain and the text length only (never the text), what was found as counts, up to 6 addresses with their facts, up to 20 domains with notes shown defanged, 3 fixed sentences, a checklist, and the AI paragraph when it is switched on.

Limits of the job. The AI paragraph is off until its injection tests and its calibration pass; until then the result is written by code only. Links are never opened. Never says whether a message is genuine or who sent it.

Input. One pasted message per job. Unknown fields are refused. A text holding a recovery phrase, a private key, an extended private key or a keystore file is refused before any payment and is never stored or sent to a model.

Refused (before any payment where the input shows it): texts holding a seed phrase or a private key (refused before payment, not stored); images, files, screenshots and attachments; verdicts: whether a message is a scam, genuine or fine to act on, and whether to sign, click or reply; who sent a message, and finding, listing or ranking senders; texts over 3,000 characters; help rewording a message so it passes any check; chains other than Ethereum and Base.

Example input (from the catalog):

{
  "text": "Congratulations! Your wallet is eligible for the USDC loyalty airdrop. Connect your wallet at https://app.uniswap.org.claim-rewards.xyz/usdc and sign the claim. Token contract: 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48.",
  "chain": "ethereum"
}

Signature request preview: signature-previewLive#

Before you sign: one EIP-712 typed-data request or one personal_sign message on Ethereum, Base, Arbitrum One or OP Mainnet, decoded by code into what it lets someone take, how much, until when and who. EIP-3009 TransferWithAuthorization (the x402 payment signature), EIP-2612 and DAI permits, Permit2 allowances and transfers, Seaport 1.5 and 1.6 orders and Sign-In with Ethereum have their plain meaning; any other schema gets a generic decode marked 'schema not recognised'. You also get the EIP-712 digest and domain hash to compare with a hardware wallet, the domain against the contract's own separator at a pinned block, the kind of every counterparty at that block, the current allowance, nonce or counter, fixed points (unlimited amount, far or no deadline, a spender without published source, you receive 0) and a short paragraph written by an AI model from those facts only. Facts, never 'OK to sign'; nothing is signed or sent. The request is not stored and the result is kept 24 hours.

• Price: $0.10 in USDC on Base (100000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Live since 22 October 2026. Its one-time calibration passed on 22 October 2026.
• Who runs it: Central only: run by the Kokomoji service, never seated (a job with AI-written text cannot be re-run to the same answer). The project keeps the whole price.
• Uses AI: yes, at most $0.03 of AI per job, paid by the project. Models: Claude Sonnet 5.5 (anthropic/claude-sonnet-5.5), writes the optional plain paragraph from the decoded facts only; Gemini 3.6 Flash (google/gemini-3.6-flash), fallback when the first model is unavailable. Called through BlockRun; the result names the model that wrote it.
• Time limit: 90 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 50 per paying wallet a day, 1000 for all wallets together a day, 2 at once.
• Kept: input not stored (a keyed hash and its length only); result 24 hours, readable at its link for that long.

What comes back. Format kokomoji.signature-preview/1: the EIP-712 domain hash, struct hash and digest, the domain check against the contract, the decoded grant, signer and counterparty facts, token facts and the current allowance, fixed points (unlimited amount, far or passed deadline, nonce used, no published source, you receive 0, a Kokomoji token account named off Ethereum), the footer, and the optional 120 to 220 word paragraph.

Limits of the job. Raw eth_sign, bare hashes and Safe transactions are refused (send Safe transactions to the proposal explainer). One preview at a time per wallet. With paragraph: false no AI is used.

Input. One signature request per job: typedData or personalSign, never both. Unknown fields are refused, and so are raw eth_sign requests, bare 32-byte hashes, Safe transactions (SafeTx), signatures, keys and seed phrases, and questions such as 'should I sign'.

Refused (before any payment where the input shows it): raw eth_sign requests and bare 32-byte hashes; Safe transactions (SafeTx typed data; send them to proposal-explainer); questions and verdicts such as 'should I sign', 'is this a scam' or 'is this site legit'; links and site lookups; more than one request (a list, or typedData and personalSign together); typed data over 32 KB, personalSign over 2,000 characters, type graphs over the depth and node caps; requests that hold a seed phrase, a private key, an extended private key or a keystore (refused before payment and not stored); a signature, or a request to make or change one; chains other than Ethereum, Base, Arbitrum One and OP Mainnet.

Example input (from the catalog):

{
  "chain": "base",
  "signer": "0x4c1b034a2264863b6c87130793f818f7f5484261",
  "typedData": {
    "types": {
      "EIP712Domain": [
        {
          "name": "name",
          "type": "string"
        },
        {
          "name": "version",
          "type": "string"
        },
        {
          "name": "chainId",
          "type": "uint256"
        },
        {
          "name": "verifyingContract",
          "type": "address"
        }
      ],
      "TransferWithAuthorization": [
        {
          "name": "from",
          "type": "address"
        },
        {
          "name": "to",
          "type": "address"
        },
        {
          "name": "value",
          "type": "uint256"
        },
        {
          "name": "validAfter",
          "type": "uint256"
        },
        {
          "name": "validBefore",
          "type": "uint256"
        },
        {
          "name": "nonce",
          "type": "bytes32"
        }
      ]
    },
    "primaryType": "TransferWithAuthorization",
    "domain": {
      "name": "USD Coin",
      "version": "2",
      "chainId": 8453,
      "verifyingContract": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
    },
    "message": {
      "from": "0x4c1b034a2264863b6c87130793f818f7f5484261",
      "to": "0x9fb365e4e9385e2a39febad70368267e6f571d9a",
      "value": "10000",
      "validAfter": "1792548180",
      "validBefore": "1792552080",
      "nonce": "0xa3ec4a24300a14686f2233b0250f044712931abe71a73d0be15d4e595bb42631"
    }
  }
}

Agent card writer: agent-card-writerLive#

Clearer name and description text for one ERC-8004 agent card, from the card the agent registered on Ethereum or Base or from a draft registration JSON (16 KB). An AI model writes only the name (at most 60 characters), the description (at most 300) and per-skill description text; code copies every other byte of the card (services, endpoints, x402Support, supportedTrust, active, image, registrations, agentWallet), checks the copy, checks OASF v0.8.0 skill and domain labels against the pinned file, lists missing fields and claims not in the data, and shows a character diff of what the AI changed. AI-written draft, we publish nothing; listed endpoints are never contacted.

• Price: $0.10 in USDC on Base (100000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Live since 22 October 2026. Its one-time calibration passed on 22 October 2026.
• Who runs it: Central only: run by the Kokomoji service, never seated (a job with AI-written text cannot be re-run to the same answer). The project keeps the whole price.
• Uses AI: yes, at most $0.03 of AI per job, paid by the project. Models: Claude Sonnet 5.5 (anthropic/claude-sonnet-5.5), rewrites the name, description and skill descriptions; Gemini 3.6 Flash (google/gemini-3.6-flash), fallback when the first model is unavailable. Called through BlockRun; the result names the model that wrote it.
• Time limit: 120 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 20 per paying wallet a day, 300 for all wallets together a day, 2 at once.
• Kept: input not stored (a keyed hash and its length only); result 7 days, readable at its link for that long.

What comes back. Format kokomoji.agent-card-writer/1: agent facts, the registration checks, OASF label checks, lints, the revised card (only name, description and skill descriptions rewritten; every other byte copied and checked), a character diff and the label 'AI-written draft, we publish nothing'.

Limits of the job. Name up to 60 characters and description up to 300. Notes cannot change protected fields or add facts: a draft with new links, numbers, names or claims fails with nothing charged.

Input. One agent card per job: {chain, agentId} for a registered ERC-8004 agent (the service reads its card), or {draft} with the registration JSON. Unknown fields are refused; there is no link input.

Form: registered agent

Form: draft

Refused (before any payment where the input shows it): inventing capabilities, endpoints, reviews, ratings or trust claims, or any link not in the input; batches: one agent card per job; impersonation: naming a known organisation or person as operator when the card does not show it; cards or notes that promise returns; changing x402Support, supportedTrust, active, registrations, wallet, endpoint or image fields; chains other than Ethereum and Base; pasted secrets (private keys, seed phrases, API tokens); an agent id with no agent, an empty agentURI, or a card that cannot be fetched or is over 16 KB.

Example input (from the catalog):

{
  "chain": "ethereum",
  "agentId": "54304"
}

Research brief with checked quotes: research-briefSwitched off#

A short research report (600 to 1,500 words) on one question: the answer first, then key findings, where the sources disagree and open questions, with a source list. Sources are only those whose terms allow reuse: an AI model plans 2 or 3 searches that the Kokomoji server runs on English Wikipedia (each page read at a pinned revision) and arXiv (abstracts at a pinned version), Ethereum standards named in the question are read from the ethereum/EIPs and ethereum/ERCs repositories at a commit, and you may add up to 5 https links of your own (read by the server, robots.txt honoured). No web search engine is used. The model writes sentences that cite source ids with short quotes. Code checks every quote word for word in the source it cites and removes sentences whose quote is not found; a second model removes sentences their quotes do not support; the checks block is published. AI-written, not advice, not reviewed by a person. Nothing is charged when the checks fail or the run passes its 200 s internal deadline. Questions about private people, allegations about named people, financial, medical or legal instructions, weapons, malware, elections and impersonation are refused before payment.

• Price: $1.00 in USDC on Base (1000000 in USDC's 6-decimal units), charged only when the result is delivered.
• Status: Switched off. Built and tested, but not offered: it is not in the catalog the service serves, has no offer on the cards and is left out of the API description.
• Who runs it: Central only: run by the Kokomoji service, never seated (a job with AI-written text cannot be re-run to the same answer). The project keeps the whole price.
• Uses AI: yes, at most $0.30 of AI per job, paid by the project. Models: Gemini 3.6 Flash (google/gemini-3.6-flash), classifies the question and checks that quotes support each sentence; Claude Sonnet 5.5 (anthropic/claude-sonnet-5.5), plans the searches and writes the claims. Called through BlockRun; the result names the model that wrote it.
• Time limit: 240 seconds of work, and never past your payment window minus 30 seconds.
• Limits: 10 per paying wallet a day, 40 for all wallets together a day, 2 at once.
• Kept: input not stored (a keyed hash and its length only); result 90 days, readable at its link for that long.

What comes back. Format kokomoji.research-brief/2: claims with quotes found verbatim in sources the server read (offsets and sha256), findings, disagreements and open questions, the sources read and not read, the searches, the checks block and the brief as Markdown.

Limits of the job. Switched off until its paid calibration is approved; sources are English Wikipedia (by revision), arXiv abstracts, Ethereum EIPs/ERCs at a commit and up to 5 links you supply.

Input.

Refused (before any payment where the input shows it): links inside the question (links go in urls), more than 5 links, and links that are not https, carry a query string, name an IP address or need a login; private individuals, personal data and allegations about named people; financial advice, including should I buy or sell and price predictions; medical or legal instructions; weapons, malware and illegal goods; any sexual content involving minors; election manipulation; writing as, or impersonating, a real person or brand; text holding a wallet secret (a recovery phrase, a private key, an extended private key or a keystore).

Example input (from the catalog):

{
  "question": "What does EIP-4844 (proto-danksharding) change for Ethereum rollups, and how is blob data priced and stored?",
  "minSources": 3,
  "length": "standard",
  "urls": [
    "https://www.eip4844.com/"
  ]
}

GET /jobs/catalog.json#

Free. The whole catalog: every job with its price, its amount in USDC units, its input schema and example, its limits and refusals, and its current status (available, busy, paused, unavailable) with the reason. It also has the payment terms, the routing rule and where results live. Cached for up to 60 seconds.

curl -s https://jobs.kokomoji.art/jobs/catalog.json

{
  "format": 1,
  "version": "2026-10-22.1",
  "service": "Kokomoji jobs",
  "performedBy": "Kokomoji job service run by the Kokomoji team. The work is done by the project and paid to the project.",
  "disclosure": "Jobs addressed to a Kokomoji are done by the Kokomoji project and paid to the project. The Kokomoji a job is addressed to gets credit and reputation, not money. Worker fees for checking jobs are separate: they are recorded, and paid once payouts are switched on (https://kokomoji.art/docs/#swarm). Results can be wrong and ratings can be negative. See the terms.",
  "payment": {
    "x402Version": 2,
    "scheme": "exact",
    "network": "eip155:8453",
    "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    "assetName": "USDC",
    "transferMethod": "eip3009",
    "payTo": "0xb2492145ea92947C0b8dF138a398fcB22782a575",
    "maxTimeoutSeconds": 300,
    "minAuthorizationSeconds": 270,
    "charged": "only when the job is delivered: the payment is settled after the result is ready and the client is still connected",
    "clientNote": "The official @x402 clients refuse payments above $1 by default. For jobs priced above $1, raise the limit, for example client.setSpendControls({ maxAmountPerPayment: \"$2.50\" })."
  },
  "routing": {
    "endpoint": "https://jobs.kokomoji.art/jobs/k/{tokenId}/{job}",
    "rule": "Jobs are addressed to a Kokomoji registered as an ERC-8004 agent with its kokomoji.art profile. Unregistered Kokomojis refuse before any payment. The Kokomoji is credited with the job."
  },
  "results": {
    "byId": "https://jobs.kokomoji.art/jobs/r/{jobId}",
    "byKey": "https://jobs.kokomoji.art/jobs/key (send your X-Job-Key header)",
    "jobKey": "Send an X-Job-Key header (22 to 128 characters of A-Z, a-z, 0-9, _ or -, at least 8 different: 16 or more random bytes, base64url) with the paid request to fetch a delivered result again if the connection drops."
  },
  "reputation": {
    "onchainFeedback": "off",
    "deliveryStats": "https://jobs.kokomoji.art/jobs/status.json"
  },
  "terms": "https://jobs.kokomoji.art/jobs/terms",
  "jobs": [
    {
      "id": "send-check",
      "name": "Before-you-send address check",
      "price": "0.20",
      "amount": "200000",
      "description": "(the catalog description)",
      "endpoint": "https://jobs.kokomoji.art/jobs/k/{tokenId}/send-check",
      "check": "https://jobs.kokomoji.art/jobs/k/{tokenId}/send-check/check",
      "input": "(the full input schema)",
      "example": {
        "to": "0x9d02ea2f7ba3554d8e71c0f3eb0671df3f268224",
        "chain": "base"
      },
      "limits": {
        "perPayerPerDay": 100,
        "globalPerDay": 2000,
        "timeoutSeconds": 120
      },
      "refused": [
        "lists, batches and bulk screening (one address per job)",
        "questions such as whether an address is safe, who owns it or whether it is a known scammer",
        "..."
      ],
      "retention": {
        "input": "7 days",
        "result": "30 days"
      },
      "seats": {
        "offered": true,
        "typeCap": 10
      },
      "status": "available"
    }
  ]
}

Built from the catalog the docs were made from (version 2026-10-22.1), shortened to one job and without its input schema: the real answer lists all 29 jobs, each with its full input schema. seats says whether holder workers can check the job and up to how many; retention appears for a job that keeps its input or result for less than the service-wide window.

GET /jobs/k/:n/#

Free, always 200. Whether Kokomoji #n takes jobs, the agent ID it is credited as, its job links and its delivery record. A Kokomoji takes jobs when it is registered as an ERC-8004 agent whose card is its kokomoji.art card; with several such agents, the lowest agent ID is credited. No money per Kokomoji is ever shown. Cached for up to 30 seconds.

{
  "tokenId": 42,
  "takesJobs": true,
  "agentId": 12345,
  "creditedAs": "Kokomoji #42 (agentId 12345)",
  "signOff": "Kokomoji #42",
  "jobs": [
    {
      "id": "proposal-explainer",
      "name": "DAO proposal explainer",
      "endpoint": "https://jobs.kokomoji.art/jobs/k/42/proposal-explainer",
      "check": "https://jobs.kokomoji.art/jobs/k/42/proposal-explainer/check"
    },
    {
      "id": "proposal-simulation",
      "name": "DAO proposal explainer with fork simulation",
      "endpoint": "https://jobs.kokomoji.art/jobs/k/42/proposal-simulation",
      "check": "https://jobs.kokomoji.art/jobs/k/42/proposal-simulation/check"
    },
    {
      "id": "dao-health-check",
      "name": "DAO health check",
      "endpoint": "https://jobs.kokomoji.art/jobs/k/42/dao-health-check",
      "check": "https://jobs.kokomoji.art/jobs/k/42/dao-health-check/check"
    },
    {
      "id": "art-critique",
      "name": "Art critique",
      "endpoint": "https://jobs.kokomoji.art/jobs/k/42/art-critique",
      "check": "https://jobs.kokomoji.art/jobs/k/42/art-critique/check"
    }
  ],
  "record": {
    "jobsCredited": 3,
    "byJob": { "proposal-explainer": 1, "dao-health-check": 1, "art-critique": 1 },
    "last30d": { "delivered": 3, "failedOnOurSide": 0, "notCompleted": 0, "successRate": 1, "medianSeconds": 0.3 }
  },
  "history": "https://jobs.kokomoji.art/jobs/k/42/history.json",
  "catalog": "https://jobs.kokomoji.art/jobs/catalog.json",
  "terms": "https://jobs.kokomoji.art/jobs/terms",
  "disclosure": "Jobs addressed to a Kokomoji are done by the Kokomoji project and paid to the project. The Kokomoji gets credit and reputation, not money. Results can be wrong and ratings can be negative. See the terms."
}

From an offline test run made when the service had its first four jobs: the live answer lists all 29. jobs lists every job the service offers, with its paid and dry run links. For a Kokomoji that takes no jobs, takesJobs is false, jobs is empty and reason says why: "Kokomoji #5 is not registered as an agent with its kokomoji.art profile, so it doesn't take jobs. New registrations appear within about 5 minutes."

POST /jobs/k/:n/:job/check#

Free. Runs every check the paid request runs before its 402, then answers with the exact payment requirements. No model call, no large download, nothing charged, no job started. The body is the job's input as application/json, at most 160 KB.

curl -s -X POST https://jobs.kokomoji.art/jobs/k/42/proposal-explainer/check \
  -H 'Content-Type: application/json' \
  --data '{"kind":"governor-proposal","chain":"ethereum","governor":"0x323A76393544d5ecca80cd6ef2A560C6a395b7E3","proposalId":"107313977323541760723614084561841045035159333942448750767795024713131429640046"}'

{
  "ok": true,
  "wouldAccept": true,
  "job": "proposal-explainer",
  "tokenId": 42,
  "creditedTo": { "tokenId": 42, "agentId": 12345 },
  "price": "1.00",
  "accepts": [
    {
      "scheme": "exact",
      "network": "eip155:8453",
      "amount": "1000000",
      "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
      "payTo": "0xb2492145ea92947C0b8dF138a398fcB22782a575",
      "maxTimeoutSeconds": 300,
      "extra": { "name": "USD Coin", "version": "2" }
    }
  ],
  "estimatedSeconds": 30,
  "note": "Dry run: nothing was charged and no job was started. The paid request re-runs every check."
}

Refusals look like this, always before any payment:

{"error":"not_registered","message":"Kokomoji #5 is not registered as an agent with its kokomoji.art profile, so it doesn't take jobs. New registrations appear within about 5 minutes."}
{"error":"bad_input","message":"governor-proposal: unknown field \"ownAddresses\" (allowed: kind, chain, reviewAtBlock, descriptionCheck, governor, proposalId, flavor)"}
{"error":"bad_input","message":"dao must be one of compound, ens, gitcoin, uniswap; for another DAO send its governor address"}
{"error":"unknown_job","message":"This job type is not offered. See /jobs/catalog.json."}
{"error":"unsupported_media_type","message":"Send the input as application/json."}

POST /jobs/k/:n/:job#

Paid with x402. The same body as /check.

Without a payment: 402

HTTP/2 402
content-type: application/json; charset=utf-8
payment-required: eyJ4NDAyVmVyc2lvbiI6MiwiZXJyb3IiOiJQYXltZW50IHJlcXVpcmVkIiwicmVzb3VyY2UiOnsidXJsIjoiaHR0cHM6Ly9qb2Jz...
access-control-expose-headers: PAYMENT-REQUIRED, PAYMENT-RESPONSE, Retry-After
cache-control: no-store

{
  "x402Version": 2,
  "error": "payment_required",
  "resource": {
    "url": "https://jobs.kokomoji.art/jobs/k/42/proposal-explainer",
    "description": "DAO proposal explainer by Kokomoji #42 (Kokomoji job service)",
    "mimeType": "application/json"
  },
  "accepts": [
    {
      "scheme": "exact",
      "network": "eip155:8453",
      "amount": "1000000",
      "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
      "payTo": "0xb2492145ea92947C0b8dF138a398fcB22782a575",
      "maxTimeoutSeconds": 300,
      "extra": { "name": "USD Coin", "version": "2" }
    }
  ],
  "message": "Payment required"
}

The PAYMENT-REQUIRED header decodes to the same object, with "error": "Payment required" and without message. A refused payment gets the same 402 with the reason in error, for example authorization_window_too_short, x402_v2_only, no_matching_requirements, wrong_amount or wrong_recipient.

The paid retry

The same request, plus PAYMENT-SIGNATURE. Decoded, a payment from the official client looks like this:

{
  "x402Version": 2,
  "payload": {
    "authorization": {
      "from": "0x82A84ACD4Cd65d57a55A59189F3fc2dB04ea8407",
      "to": "0xb2492145ea92947C0b8dF138a398fcB22782a575",
      "value": "1000000",
      "validAfter": "0",
      "validBefore": "1792514934",
      "nonce": "0x7d24c725a05e9e43030ee0f4819bec41f0dc4565383dbca9d7df9e782c564e5f"
    },
    "signature": "0xe7820301d0036d91d4f05b42c78e944ef0fdcb3e6cc036a0db39db6a443ef54b20711905848eb4d5a340e87da2b353fe3400ef2e28738c5a752c7213d93f8c3b1b"
  },
  "resource": {
    "url": "https://jobs.kokomoji.art/jobs/k/42/proposal-explainer",
    "description": "DAO proposal explainer by Kokomoji #42 (Kokomoji job service)",
    "mimeType": "application/json"
  },
  "accepted": {
    "scheme": "exact",
    "network": "eip155:8453",
    "amount": "1000000",
    "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    "payTo": "0xb2492145ea92947C0b8dF138a398fcB22782a575",
    "maxTimeoutSeconds": 300,
    "extra": { "name": "USD Coin", "version": "2" }
  }
}

In order, before any work: the header must decode to an x402 v2 payload; accepted must match the requirements rebuilt from this request; the authorization must pay the Safe exactly the price with EIP-3009 inside the window; its (from, nonce) must be new; the wallet must be within its limits; the payment must verify; and the wallet must pass sanctions screening.

Delivered: 200

{
  "ok": true,
  "jobId": "e5cd5cdd1048fdae9bd3219b145f678b",
  "job": "proposal-explainer",
  "jobName": "DAO proposal explainer",
  "status": "delivered",
  "createdAt": "2026-10-20T16:43:54.580Z",
  "completedAt": "2026-10-20T16:43:54.857Z",
  "inputSha256": "602394ccd677462bcaa9de0b3b32c1336606b65e2dc2c8ff26d7d405357b6259",
  "result": {
    "format": "kokomoji.jobs.dao/1",
    "job": "proposal-explainer",
    "summary": {
      "flagCounts": { "review_first": 0, "worth_checking": 2, "info": 1 },
      "reviewFirstPointsToConfirm": 0,
      "simulated": false,
      "block": 24440000,
      "writtenBy": "code (no AI in this job)"
    },
    "report": { "schema": "kokomoji.dao.explainer/1" },
    "markdown": "# Proposal explainer: \"EP 6.32 Executable Transfer $2.5M USDC from Endowment to wallet .ensdao .eth\"",
    "evidence": { "reads": [] }
  },
  "creditedTo": { "tokenId": 42, "agentId": 12345, "label": "Kokomoji #42 (agentId 12345)" },
  "performedBy": "Kokomoji job service run by the Kokomoji team. The work is done by the project and paid to the project.",
  "price": "1.00",
  "settlement": {
    "network": "eip155:8453",
    "transaction": "0x212e6e14349e782f0056f0cdf58c1fd97c935b4146eac40583ba516f9e95bbde"
  },
  "terms": "https://jobs.kokomoji.art/jobs/terms",
  "resultUrl": "https://jobs.kokomoji.art/jobs/r/e5cd5cdd1048fdae9bd3219b145f678b"
}

Shortened: report, markdown and evidence hold the whole report (in this run 18,555, 7,346 and 50,729 characters). The PAYMENT-RESPONSE header decodes to:

{
  "success": true,
  "transaction": "0x212e6e14349e782f0056f0cdf58c1fd97c935b4146eac40583ba516f9e95bbde",
  "network": "eip155:8453",
  "payer": "0x82A84ACD4Cd65d57a55A59189F3fc2dB04ea8407"
}

A job that fails after the payment was accepted answers with the reason, the jobId and "charged": false, for example {"error":"job_failed","message":"The job failed on our side. Nothing was charged.","jobId":"...","charged":false}.

GET /jobs/r/:jobId#

Free. A delivered result, readable for as long as the job keeps it: 90 days by default, less for the jobs listed in What is kept. The answer is the stored result: the same fields as the 200 above without ok and resultUrl, and with "status": "settled". Unknown, unsettled and expired ids all answer the same 404, so nobody can probe for job ids. Cached privately for up to 5 minutes.

{"error":"not_found","message":"No such result."}

GET /jobs/key#

Free. Send the X-Job-Key header you used on the paid request. A delivered job returns the same answer as the paid 200, with "replay": false. Otherwise:

{ "ok": true, "status": "running", "result": null, "message": "Not finished yet. Ask again in a minute." }
{ "ok": true, "status": "settlement_pending", "result": null, "message": "Not finished yet. Ask again in a minute." }
{ "ok": true, "status": "not_charged", "result": null, "message": "This job was not delivered and nothing was charged." }

No header, or a malformed one: 400 bad_job_key. An unknown key, or one for a job whose result is no longer kept: 404 not_found.

GET /jobs/k/:n/history.json#

Free. The last 100 jobs credited to Kokomoji #n in the past 91 days, newest first. Inputs and payers are never listed. Cached for up to 30 seconds.

{
  "tokenId": 42,
  "jobs": [
    { "job": "art-critique", "at": "2026-10-20T16:43:55.660Z", "status": "delivered", "tx": "0x3613b15272fa15eaa20984305705bf5f65b64f552cec3f9d21a961ace4d9a956" },
    { "job": "dao-health-check", "at": "2026-10-20T16:43:55.178Z", "status": "delivered", "tx": "0xc48eb25a9617c876472e56faf25ebc20590fb5b23b6639429f735f727a82585e" },
    { "job": "proposal-explainer", "at": "2026-10-20T16:43:54.581Z", "status": "delivered", "tx": "0x212e6e14349e782f0056f0cdf58c1fd97c935b4146eac40583ba516f9e95bbde" }
  ],
  "note": "Job type, time, status and settlement transaction only. Inputs are never listed."
}

status is delivered, failed (on the service's side), not completed (on the payer's side: bad input, refused content, a disconnect, moved funds) or in progress. Only delivered jobs carry a tx.

GET /jobs/status.json#

Free. The state of the whole service; see Job service status for every field. Cached for up to 15 seconds.

GET /jobs/stats.json#

Free. The totals the dashboard shows, computed from the job journal at most once a minute (cached for up to 60 seconds); see Dashboard and public totals for every field. Totals and counts only: no payer addresses, no inputs, no job ids and no amounts per Kokomoji.

GET /jobs/terms and GET /jobs/healthz#

/jobs/terms is the terms page, HTML with no scripts (see Terms). /jobs/healthz answers {"ok": true} while the service runs.

What you need#

What your endpoints can do decides which seats you get: archive state and debug_traceTransaction on Ethereum get full re-run seats; a plain recent-state endpoint gets reader seats. The worker measures this itself at start and every hour (see what the probe measures).

Install the worker#

The Kokomoji worker is open source (MIT) with no npm dependencies. It has two parts:

• The agent runs on your machine as your own user (better: a dedicated user with its own home and nothing else in it), with Node 20 or later. It talks to the coordinator, holds your endpoint keys in its local gateway and enforces your budgets.
• The runner image runs the job code. The agent starts one container per lease from it and removes it afterwards, so the code that runs a job never shares your network, your files or the agent's keys.

Get the release from kokomoji.art/worker/: there is no public code repository or image registry yet, so the source and its signatures are published there. Check SHA256SUMS with 2 of the 3 release keys (see Releases and their signatures), then unpack it and install the engine's one dependency:

minisign -V -P RWRYi4LNZPFYITTsqqlwFRn7zvKx+w3YHqB7So2YP/JL1+MJ2XnrbCH1 -m SHA256SUMS -x SHA256SUMS.minisig.1
minisign -V -P RWQANEasqt5ovAsxLbt5OnhoEb+btp/6oKDf0Tgzi4iEuOv0/Gb+0V+Y -m SHA256SUMS -x SHA256SUMS.minisig.2
sha256sum -c SHA256SUMS
mkdir kokomoji-worker && tar -xzf kokomoji-worker-0.1.0.tar.gz -C kokomoji-worker && cd kokomoji-worker
(cd dao/engine && npm ci --omit=dev --ignore-scripts)

Then, in that folder (it holds worker/ and dao/engine/):

podman build -f worker/Containerfile -t localhost/kokomoji-worker:0.1.0 .   # the runner image
export KOKOWORKER_HOME=~/.kokoworker         # the worker home, never inside the worker or engine folders
node worker/bin/kokoworker.js verify         # the release check: 2 of the 3 release keys signed this tree
node worker/bin/kokoworker.js init           # device key and an example config.json in the worker home
$EDITOR ~/.kokoworker/config.json            # your RPC endpoints (the file stays mode 600)
node worker/bin/kokoworker.js doctor --online   # pass or fail for every check, and your endpoints' capabilities
node worker/bin/kokoworker.js pair           # a pairing code, a link to the pairing page and the device key's short id
node worker/bin/kokoworker.js start          # for example as a systemd --user service

The container runtime

• Rootless Podman is preferred, then rootless Docker. Set "runner": {"runtime": "docker"} in config.json (or KOKOWORKER_RUNTIME) to choose Docker. Job leases need a runtime: without one the worker takes practice tasks only.
• Rootful Docker fails doctor unless you set runner.allowRootful: a user in the docker group is root on that machine, and the agent holds your endpoint keys.
• Every runner container runs with --network=none (loopback only: no DNS, no route, no host port), a read-only root, a 256 MB work folder at /work (noexec, nosuid, nodev), every capability dropped, no-new-privileges, --ipc=none, your own non-root user (rootless Podman: --userns=keep-id), 1 GB of memory with no extra swap, 128 processes and 1 CPU.
• Its only mounts are read-only: a fresh folder for that lease (mode 0700) holding the gateway's unix socket, the runner's one way out, which the agent opens for that lease only and deletes when it ends; and the worker's and the engine's code, so it runs exactly the files the release check verified. A joiner gets no socket at all.
• Never mounted: the worker home (config.json with your keys, device.key, state.json), your home folder, wallet files and the container runtime's socket. doctor checks this by starting one runner container with every lease flag.
• A lease past its deadline or cancelled is removed with podman rm -f; containers left by a crash are removed at the next start.
• SELinux hosts (Fedora, RHEL): the read-only code mounts need a label. Run the runtime with --security-opt label=disable, or relabel the mounted folders yourself. This is not tested yet.
• config.json runner options, all optional: runtime, image (default localhost/kokomoji-worker:0.1.0), code (mount, the default, or image: the copies inside the image, checked at start), memoryMb (512 to 16384) and pids (32 to 4096).

Releases and their signatures

• A release is the worker plus the pinned engine. release/manifest.json lists every worker file with its sha256, the Node version, the runner image digest, the engine manifest hash, the coordinator's lease keys, a minimum version and an expiry. Its hash is the release hash the worker reports.
• 2 of 3. A release is valid only when 2 of the 3 published release keys signed it (release/manifest.json.minisig.1, .2 and .3, minisign). Keys are counted by their public key, so one key cannot count twice. The worker checks this at every start, doctor, pair and verify.
• kokoworker verify checks the tree you have and prints the key ids that signed it: compare them with the published ones. A tree without a signed manifest starts only with --dev, and the coordinator turns its release hash away.
• The release keys (minisign key ids, as minisign and kokoworker verify print them), also at kokomoji.art/worker/ and built into the worker: 2158F164CD828B58 (RWRYi4LNZPFYITTsqqlwFRn7zvKx+w3YHqB7So2YP/JL1+MJ2XnrbCH1), BC68DEAAAC463400 (RWQANEasqt5ovAsxLbt5OnhoEb+btp/6oKDf0Tgzi4iEuOv0/Gb+0V+Y) and 51B7C22E20E51207 (RWQHEuUgLsK3UWpARRhIhpEXUYyegCnL1x0neNuJy/YFFDNrkk9y8Vt0).
• Release 0.1.0 (22 October 2026): release hash 03484cd4c790ebb9b44f1d3cad6917a3c4277624d95b38ecd1a7d9f73c7dc5d8, signed by all 3 keys, expires on 20 January 2027. The project's runner image of it is sha256:7110feb6b6d5138015e24b987cda51032b591225ace11b2ea5855e4e3703fbe7; the image is not published, so build it yourself from the release (your build gets its own image ID).
• With "code": "image" the agent runs the image by its ID, never its tag, and checks that the code inside it has the signed manifest's hashes.
• What the signatures do not do. They let you check that what you run is what the release keys signed. The coordinator's list of allowed releases only checks the hash a worker reports about itself, so it turns away out-of-date honest workers but cannot stop a modified one. Wrong answers from a modified worker are caught by the checks in How results are checked.
• Updates are off by default. Below the coordinator's minimum version the worker stops taking leases.

Your endpoints, and what the probe measures

• Chains 1 (Ethereum), 10 (OP Mainnet), 8453 (Base) and 42161 (Arbitrum One), 1 to 4 endpoints each. The first one is the main one; the worker fails over to the next on a timeout or a rate limit.
• Each endpoint has a label and a provider family (short names). They are all the coordinator ever learns about your endpoints. The URL and any key in it stay in config.json and the agent's gateway, and logs mask it. Endpoints use https; plain http is allowed only to your own node on a private address.
• budgets.perDay caps what the worker may spend on your provider each UTC day, retries included; perLease caps one lease. paused: true declines every lease and keeps the worker online.

The worker measures each chain's capabilities at start and every hour, through the same endpoint order it serves leases with. The coordinator offers only the seats your capabilities allow.

• Providers not to list: pocket as a logs or wide-logs provider (it answered past eth_getLogs ranges short in the tests), and blockpi on OP Mainnet as an archive provider (it answered old-block reads with the latest value). The probe now refuses both capabilities on its pinned answers.
• Archive state and debug_traceTransaction on Ethereum get full re-run seats; a plain recent-state endpoint gets reader seats.

Network

• The agent calls only the coordinator (https://jobs.kokomoji.art) and your own endpoints, and refuses redirects. It opens no port to the network: its gateway listens on 127.0.0.1 and on the per-lease unix sockets.
• The gateway allows only the engine's read-only JSON-RPC methods. The runner never sees a URL or a key.
• For a network rule on top, allow egress from the agent's user only to DNS, the coordinator and your RPC hosts. The runner containers need no network at all.
• kokoworker start --bare runs without containers, for development: it takes practice tasks only and declines job leases, because its runner shares your machine's network.

Which jobs pay seats#

Every seated job was re-run on 5 to 10 independent provider families before paid seats were allowed for it. Once paid seats open, worker fees are booked only for the jobs that passed. The others still get seats in the shadow stage: their checks are counted and published, and they book no worker fees. Each job's section says which it is.

Changing which jobs pay is a new catalog release, announced in the catalog version.

Pair it at /agent/worker/#

Pairing ties one worker to one of your registered Kokomojis. It is one signature on kokomoji.art/agent/worker/: no gas, no approvals, no transaction.

1. On your machine, run kokoworker pair. It prints a pairing code, a link to the pairing page and the short id of the worker's device key. The code works once, for 5 minutes.
2. Open the link and connect the wallet that holds the Kokomoji. Pick a Kokomoji with an agent ID (one without is sent to the register page first).
3. Read the message. Copy its one line of JSON into the terminal where kokoworker pair waits. The worker checks it (this device key, the Kokomoji collection and coordinator, the Kokomoji's token account on Ethereum as the payout address, at most 90 days) and prints its typed-data hash.
4. Type the 16-character short id of the device key that your terminal shows. The page enables Sign only when it matches the device key in the message.
5. Sign only if the typed-data hash on the page is the same as in your terminal and the worker shows no problem.

• A pairing lasts 90 days; renew it by pairing again. One worker per Kokomoji and one Kokomoji per worker: a new pairing replaces the old one.
• Selling or transferring the Kokomoji ends the pairing. To stop yourself, revoke the pairing on the same page with your wallet.
• The page also shows your Kokomoji's worker fee statement, from a signed request, and offers it as CSV.
• A newly paired worker first takes practice tasks: it gets job seats after 20 matched practice runs over 7 days.

Roles#

The coordinator offers leases to the worker. A lease is one seat of one job, signed by the coordinator's lease key, with its pinned blocks, the reads to make and a deadline. The worker checks it and accepts or declines within 5 seconds. Every lease starts by checking the pinned block hash on your endpoint; a different hash (a reorg, a lagging node) ends it as block_mismatch, which is no fault of yours.

Reader and auditor leases also carry 1 or 2 hidden test reads whose answers are already confirmed, so copying another worker's answers is caught in most cases. Leases carry the reads to make, never the expected answers.

How a job splits across 2 to 20 seats#

Seats are elastic: a job gets as many seats as there are eligible workers online, up to the job's cap (10 for most jobs, 12 for three, 20 for the largest; each job's section says). The rule:

• Seats = the smallest of: eligible workers online, the job's cap, and 3 + 2 x the number of shards.
• Below 2 workers the job runs central-only on the service's own run, and the project keeps the whole price. The result says "not checked by holder-run workers" and why.
• Seats 1 and 2 are auditors, seat 3 is the joiner, then readers take one shard each, then cross-checkers add a second copy. A job with fewer than 12 reads is one shard and gets at most 4 seats.
• No seat goes to the paying wallet or to its token account. Per job: one seat per holder wallet and per network block, at most a third of the seats per main provider family and a quarter per hosting network, so one person cannot fill a job.

How results are checked#

• Every seat is compared with the service's run: an auditor by its result hash, its hidden reads and its recording read by read; the joiner by its replay; a reader by every answer and hidden read.
• A seat matches only when every part it ran matches. A seat that did not match, was late, stopped or skipped reads gets 0 work units.
• When seats differ from the service, the disputed reads are re-read at the pinned block on 2 endpoints independent of the service. If they show the service was wrong, the job is corrected: the customer gets a correction note and a full refund, and that job's worker fees are reversed (the seats keep their work units). If they side with the service, the differing seats are unmatched.
• A seat that may have been tampered with is held for a person to review; it books nothing until decided.
• The coordinator signs a receipt row for every seat every day. The receipts are public, so anyone can recount what was booked.

Worker fees#

Once paid seats open, each checked job of a type with paid seats (see Which jobs pay seats) that was paid for and had 2 or more seats has a worker pot of 75% of its price; the Kokomoji project keeps 25%. Jobs with unpaid seats book no worker fees. Jobs priced under $0.20 get no seats, so every pot is at least $0.15.

• Split by work units. The pot is shared among the matched seats in proportion to their work units (auditor 3, joiner 1, reader or cross-checker 1 per shard held, at most 3). Amounts are whole micro-USDC: each seat gets the rounded-down share, and the few micro-USDC left go out one at a time in a fixed order, so the whole pot is booked. If no seat matched, the project keeps the pot.
• Booked to the Kokomoji, not to you. Fees are booked to the Kokomoji's token number and owed to that Kokomoji's token account on Ethereum. They stay with the Kokomoji if it is sold.
• Corrections and tampering. A job proven wrong reverses its fees. A seat decided as tampering forfeits that worker's unpaid fees of that month. Fees already paid are never taken back.
• Small amounts. Per seat this is cents or less per job, and a few dollars a month for the whole program at today's volume, less than an always-on machine costs in electricity. Run a worker to help check jobs, not for the money.

An example: a job priced $0.50 with 2 auditors, 1 joiner and 4 readers holding one shard each. The pot is 375,000 micro-USDC over 3 + 3 + 1 + 4 = 11 work units: each auditor gets 102,272, the joiner and each reader 34,090, and the 6 micro-USDC left go to 6 of the seats, one each.

Monthly payouts#

• Where. In USDC, to the Kokomoji's ERC-6551 token account on Ethereum. Never to your wallet, and never on Base. The token account is usable only on Ethereum: never send funds to its address on Base.
• When. Each month closes on the 1st at 00:00 UTC. The payout batch for it is built from the 10th of the next month.
• Minimum. A Kokomoji is paid when its balance reaches the larger of $5 and 50 times the network fee of one payment (about $5 at today's gas, about $11 at 2 gwei). Smaller balances carry over to the next month.
• Gas. A batch goes out only while the Ethereum base fee is 2 gwei or less. At most 250 token accounts are paid per batch, largest balances first; the rest carry over.
• Checks per row. A row is held, and carries over, when the sanctions oracle or USDC's blacklist flags the account or its holder, or when its address has other contract code on Base.
• How. The month's USDC moves from the jobs Safe on Base to a separate payout Safe on Ethereum, then one batch pays every token account. Each payout Safe signer (at least one of them is not a worker) recomputes the whole batch from the signed receipts before signing it.
• Payouts are switched off until the project turns them on. Worker fees are recorded from the first paid job and paid once payouts are switched on.
• Your statement. On the pairing page, after a signed request: each month's opening balance, worker fees, reversals, payouts and closing balance per Kokomoji, as a table and a CSV. The public status shows each month's totals only, never an amount per Kokomoji.

Running it, privacy and limits#

• Keep it running. Run kokoworker start as a service (for example a systemd --user unit for the worker's own user); kokoworker status shows its state; kokoworker doctor --online re-checks your endpoints' capabilities. Below the coordinator's minimum release the worker stops taking leases until you update.
• Privacy. The coordinator keeps the pairing (Kokomoji number, holder wallet, device key, token account, dates) while it is active, to check that the signer still holds the Kokomoji and to book its worker fees. It never publishes wallets, IP addresses or money per Kokomoji. A Kokomoji's public record shows only whether its worker was active, its release and its match counts.
• What it cannot stop. One person can split Kokomojis across wallets and connections. The service's own run makes that useless for misleading customers; it can still take a share of worker fees, within the limits above. A misbehaving coordinator could misreport results or hold back fees, but it cannot touch your wallet or your machine beyond its leases, and the signed receipts and the signers' recompute make it visible.
• Your risk. You run the worker at your own risk, on your own provider plan. Read the worker terms on the pairing page before you pair.