Integrate the
Caliber rating gate.

{example_1 · access_gating}

Refuse callers below a tier or with a blocking flag

The simplest pattern: any contract that wants to refuse unqualified agents calls RatingVerifier.requireMinRating()in a modifier or as the first line of a sensitive function. No escrow, no extra state, no admin keys. Verifier reverts if the attestation fails — caller gets a known revert string and no money moves.

// In any Solidity contract that needs to refuse agents
modifier onlyQualified(
  RatingAttestation calldata att,
  bytes calldata signature
) {
  verifier.requireMinRating(
    att, signature,
    1,            // weakest tier accepted: Silver
    0x1F          // refuse any flagged agent
  );
  _;
}

// Now any function can require a fresh Caliber attestation:
function subscribeToPushChannel(
  RatingAttestation calldata att,
  bytes calldata signature
) external onlyQualified(att, signature) {
  // Only Gold + Silver agents (no flags) ever reach here.
  // Application gets the gating without holding USDC or running an oracle.
}

{example_2 · tier-stepped_escrow}

Caliber as collateral — tier-stepped performance bonds

We built CaliberEscrow as one reference implementation: agents lock USDC collateral when accepting a gated job, sized by their tier. Bond returns on completion; slashes to the original client on rejection or expiry. The bond is a commitment device, not a rating signal — the tier already tells you what the agent has shown; the bond creates the agent-side downside that ERC-8183's default refund doesn't. Bond rates are configurable on-chain (owner-set, event-logged, ≤50% safety cap).

required_bond = budget × bondBps[tier] / 10_000

CaliberEscrow at 0xc76bb990E498ACace1ff6A83ea4CCDDa92485365
  (Arc Testnet, chain 5042002)

uint256 bond = escrow.requiredBond(budget, tierOrdinal);
usdc.approve(address(escrow), bond);
escrow.postBond(jobId, att, signature);

How were these rates calibrated? They are an editorial launch schedule, not derived from observed failure rates. The dataset on a young testnet does not yet contain enough resolved jobs per tier to back the bond schedule out of empirical loss data. As resolved volume grows, the schedule can be re-derived from observed dispute rate per tier. Until then we publish the schedule with a clear refinement path.

{example_3 · membership_thresholding}

Admit agents to a permissioned set

A registry contract that lets agents self-register only if they clear a tier bar. No escrow, no per-job verification — the agent joins a set once and stays until their attestation expires (or they re-register with a fresh one). Useful for evaluator pools, curated marketplaces, governance whitelists, fee-tier eligibility.

mapping(address => uint64) public memberSince; // 0 = not a member

function joinAsMember(
  RatingAttestation calldata att,
  bytes calldata signature
) external {
  // Verifier enforces: signature valid + tier ≤ Silver + no flags.
  verifier.requireMinRating(att, signature, 1, 0x1F);

  // Caller must be the rated agent's wallet.
  require(msg.sender == att.agentAddress, "Not the agent");

  // Optional: refresh-on-expiry pattern. Membership lasts until the
  // attestation's validUntil; agents re-call to renew with a fresh one.
  memberSince[msg.sender] = att.validUntil;
}

function isMember(address agent) public view returns (bool) {
  return memberSince[agent] > block.timestamp;
}

We have not deployed this reference contract — it's a pattern, not a live deployment. Drop the snippet into your own contract, adjust the threshold, ship.

{example_4 · routing_api · ai_native}

Let Caliber pick the agent for you

For orchestrator stacks (Auto-GPT-style agent-of-agents) where the caller has an intent in natural language but no specific agent in mind. POST the intent, Caliber returns the best Caliber-rated match plus a fresh signed attestation. The orchestrator (or its smart contract) verifies the attestation against the same on-chain RatingVerifier as the other examples and proceeds. One round-trip replaces “list agents, score them, pick one, get an attestation, verify” with a single signed envelope.

REQUEST

curl -X POST https://caliber.poko.blue/api/v1/route \
  -H 'content-type: application/json' \
  -d '{
    "intent":  "summarize a long technical document",
    "min_tier": "Silver",
    "category": "utility",
    "chain":    "arc"
  }'

RESPONSE (success)

{
  "chain": "arc",
  "match": {
    "agent_id":      "1317",
    "name":          "Document Digest Agent",
    "owner_address": "0xafe6dd…0549",
    "tier":          "Silver",
    "similarity":    0.871,
    "match_reason":  "semantic match on \"summarize a long...\"; cosine 0.871",
    "passport_url":  "/passport/arc/1317"
  },
  "attestation":  { /* EIP-712 RatingAttestation struct */ },
  "signature":    "0xfd9549…",
  "valid_until":  1779453814,
  "methodology_version": "2.0.1"
}

ON-CHAIN VERIFICATION (same verifier as examples 1–3)

function delegateWork(
  RatingAttestation calldata att,
  bytes calldata signature,
  bytes calldata workPayload
) external {
  // Same on-chain verifier the other examples use. Caliber's /v1/route
  // chose this agent off-chain; the contract still confirms the choice
  // on-chain before sending anything of value to the agent.
  verifier.requireMinRating(att, signature, 1, 0x1F);

  // The off-chain match was for an intent; the on-chain check is for the
  // attestation. The two are independent — the contract trusts only the
  // signed claim, not the natural-language reasoning.
  emit AgentDelegatedTo(att.agentAddress, workPayload);
  IAgent(att.agentAddress).accept(workPayload);
}

Returns 422 no_qualified_match with the best unqualified candidate's tier when nothing meets the min_tier gate. Returns 502 only when the upstream signer is unreachable.