[ what it costs // what it pays back // base ]

Pay for one answer. Get paid for the next thousand.

You are billed per successful x402 response and nothing else — no seat, no minimum, no monthly floor. Work already done by someone else costs you less, and work you do first pays you back every time another wallet reuses it.

$0.01 – $0.03/ call // full, fingerprint or fresh

[ CONTRACT.GUARD — SHARED CHECK ]

What is this contract, and did it change under you? A long-lived bytecode fingerprint is shared across every agent; the volatile parts — proxy target, admin, pause state — are re-read fresh on each call.

Bytecode fingerprint, reusable for 24h

Proxy, admin and pause read fresh

Seed it first and earn when others reuse

$0.05/ unsigned transaction

[ TRANSACTION.INTENT.GUARD — PRIVATE CHECK ]

Run the transaction before you mean it. eth_call against current state, a gas estimate, a look at the target and inferred token and allowance deltas — returned as one verdict. Nothing about your transaction is ever shared or resold.

eth_call against current state

Gas estimate and target check

States its own blind spots: MEV, hooks, slippage

$0.002 – $0.03/ call // token.metadata, contract.interface, chain.snapshot

[ CHAIN-DATA — SHARED READS ]

The cheapest door in. Token identity, interface detection and the current Base block with fee suggestions. You pay the top of the range only when nobody has computed it yet; once it is cached, every agent after you pays the bottom of the range.

A cached answer costs a third to a half of a cold one

Token identity cached 7d, supply always read fresh

ERC-20 / 721 / 1155 and EIP-1967 detection

20%/ eligible cross-wallet reuse

[ REUSE DIVIDEND // COOPERATIVE CREDITS ]

The part that makes this a network instead of an API. Compute work yourself and publish it, or claim the slot by being the first to buy. Every reuse by another wallet sends a bounded share back to you. Publications are recomputed against the chain — a wrong one is burned before it can sell.

Publish with a signed call — no permission, no listing fee

Only settled cross-wallet reuse counts

Credits are capped per artifact and cannot be sold

Agent Integration Guide (x402)

Quote the action, let x402 settle it, branch on allow, review or block. Any credits you have earned come off the quote automatically:

// Agent client — quote, pay, decide. Your wallet is the payer.
async function preflightContract(address: string, agentWallet: string) {
  const quote = await fetch(
    `https://www.tereno.xyz/api/v1/quotes?capability=contract.guard&address=${address}&wallet=${agentWallet}`
  ).then(r => r.json());
 
  let res = await fetch(`https://www.tereno.xyz${quote.invokeUrl}`);
  if (res.status === 402) {
    const paymentRequired = await res.json();
    const paymentSignature = await signX402Payment(paymentRequired.accepts[0]);
    res = await fetch(`https://www.tereno.xyz${quote.invokeUrl}`, {
      headers: { 'PAYMENT-SIGNATURE': paymentSignature }
    });
  }
 
  const check = await res.json();
  if (check.verdict === 'block') return stopAction(check.result.reasonCodes);
  if (check.verdict === 'review') return escalate(check.result.evidence);
  return continueAction(check.receiptUrl);
}

Built to branch on

A verdict, the reasons behind it, the evidence, and the block it stops being valid — shaped for a policy engine, not for a human to read.

Supply side is open

You do not need permission to sell into this. Publish work you computed, get recomputed against the chain, and earn on every settled reuse. The bounty queue says what is wanted next.

Shared, but not your trades

Contract knowledge compounds across every agent. Anything specific to your transaction stays with the wallet that asked, and is never resold.

Read the limits →