MCP Tool Catalog

Current user id, email, banking onboarding flags, and ClawBank OS status (`company_os.offered` / `company_os.enabled` / `company_os.next`). When enabled, OS company tools appear in this catalog (list_os_companies / list_companies, create_os_company / create_company, list_os_tasks, open_os_builder / prompt_os_builder). Opt in via Settings or POST /api/v1/me/company_os, then reconnect MCP.

Input schema

{schema_json(tool)}

USD virtual account deposit instructions: routing, account, bank, beneficiary name and address, optional memo/reference. When funding via Wise send_money (ACH), set recipient_name to bank_beneficiary_name exactly if present; otherwise use account_holder_name exactly if present. Do not guess or substitute product names — a wrong recipient name causes ACH rejection (e.g. receiver name mismatch).

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Custodial bank-rail USDC balance (ACH/wire settlement wallet). NOT the user's trading or sendable wallet — that is get_self_custody_token_balance (or get_self_custody_tracked_balances for a portfolio). Only use this when the user asked about bank-rail / ACH / wire / custodial funds. Never use this to answer 'what's in my wallet' or to report what's left after a send.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Register a US bank account that will receive USD when off-ramping. Caller supplies the routing/account numbers and owner address. Returns the bank's external_account_id, which the user is now associated with. After linking, call create_offramp_address to get the on-chain liquidation address that auto-converts incoming USDC to USD via ACH to this bank.

Input schema

{schema_json(tool)}

Create the on-chain offramp address (a custodial liquidation address) tied to the user's currently linked bank account. Send USDC to this address from any wallet to auto-convert to USD and ACH to the linked bank. Idempotent — returns the existing address if one already exists for the (chain, bank) pair.

Input schema

{schema_json(tool)}

Unlink the user's currently linked offramp bank account. Existing liquidation addresses remain upstream (they'll fail to drain, requiring re-link or new address) but the user is no longer associated with the bank account locally.

Input schema

{schema_json(tool)}

Read the user's current off-ramp configuration in one call: the linked bank account (if any), the on-chain offramp address (if created), and the recent liquidation transaction history. Use this instead of stitching individual GETs.

Input schema

{schema_json(tool)}

Returns the user's self-custody wallet address (the ClawBank-controlled, Turnkey-backed EVM address used for trading settlement, Shodai signing, and arbitrary on-chain activity). Distinct from the user's on-ramp wallet (custodial address fiat deposits arrive in) and off-ramp wallet (custodial liquidation address that auto-converts USDC to fiat ACH). Lazy: provisions the wallet on first call. Idempotent. When sharing this address as a DEPOSIT destination, always relay the returned deposit_warnings — in particular that the user must send to THIS wallet address and never to a token's contract address (tokens sent to a token's own contract, e.g. the CLAWBANK contract copied from a listing page, are permanently unrecoverable), and that large deposits should start with a small test amount. Deposits are supported on Base only (USDC or CLAWBANK). Although the same address exists on Robinhood Chain, do NOT offer it as a Robinhood Chain deposit or trading address: there is no general trading there — only CLAWBANK bridging and CLAWBANK/ETH LP — so any other asset sent on Robinhood Chain cannot be traded or moved out. If the user asked for a wallet to trade on Robinhood, clarify intent before calling this tool.

Input schema

{schema_json(tool)}

Reads ERC-20 token balance on Base for the user's PRIMARY self-custody wallet (the trading / sendable wallet). Defaults to USDC if no token_address is provided. This is the wallet send_usdc_on_base spends from. Do not use get_balance for this — that tool is the custodial bank-rail wallet. Useful for small-cap and long-tail tokens as long as their contract address is known.

Input schema

{schema_json(tool)}

Reads the balance of ANY Base address — not just the user's own wallet. Use this whenever the user asks about an address that is not their self-custody wallet; NEVER answer such questions with the user's own balance. Defaults to USDC; pass symbol "ETH" for the native balance or a token_address for any ERC-20. Read-only.

Input schema

{schema_json(tool)}

Lists tracked ERC-20 tokens for the user's self-custody wallet on Base. Includes defaults (ETH, USDC, and CLAWBANK when configured) plus user-added tokens.

Input schema

{schema_json(tool)}

Adds a Base ERC-20 to the user's wallet by contract address. The token is validated on-chain (its `symbol`/`decimals` are read from the contract and used as authoritative) and probed against 0x for liquidity. If both pass, the token becomes `tradeable` and is immediately usable as `base_token` for `execute_spot_swap` and `create_strategy`. Non-ERC-20 addresses are rejected (`not_erc20`).

Input schema

{schema_json(tool)}

Removes a user-added token from the tracked-token list by contract address. Default tokens cannot be removed.

Input schema

{schema_json(tool)}

Returns balances for all tracked self-custody tokens on Base. Useful for portfolio-style balance snapshots across USDC + user-added tokens.

Input schema

{schema_json(tool)}

Traces an on-chain transaction by hash: looks it up on Base (falling back to Robinhood Chain), decodes every ERC-20 Transfer in it, and reports which token moved, how much, and between which addresses — flagging transfers that touch the user's wallet and dangerous mistakes like tokens sent to a token's own contract address (permanently unrecoverable). USE THIS FIRST whenever a user reports a missing deposit and provides a tx hash — it usually explains the mystery (wrong token, wrong destination, wrong network, or still pending) without escalating to a human. Read-only; safe to call freely. Returns found=false when the hash isn't on Base or Robinhood Chain.

Input schema

{schema_json(tool)}

Signs an unsigned EVM transaction using the user's self-custody wallet. Input is the hex-encoded RLP unsigned transaction (with or without 0x prefix). Returns the hex-encoded signed transaction the caller can broadcast via any RPC. Broadcasting outside ClawBank is not covered by ClawBank gas sponsorship. Lazy-provisions the wallet on first call.

Input schema

{schema_json(tool)}

Signs an arbitrary payload using the user's self-custody wallet. The underlying primitive for EIP-712 typed data, EIP-191 personal sign, etc. By default the payload is treated as a hex digest (PAYLOAD_ENCODING_HEXADECIMAL + HASH_FUNCTION_NO_OP); override 'encoding' and 'hash_function' to have Turnkey hash the payload itself (e.g. encoding=PAYLOAD_ENCODING_TEXT_UTF8 + hash_function=HASH_FUNCTION_KECCAK256 for an EIP-191 personal_sign). Returns the raw ECDSA components {r, s, v}; the caller is responsible for combining them into whatever signature shape the consumer expects.

Input schema

{schema_json(tool)}

Sends USDC on Base mainnet from the user's self-custody wallet to a destination 0x address. The wallet is lazy-provisioned on first call. This route uses ClawBank's Turnkey-managed sponsored transaction flow, so users do not need ETH in-wallet for this in-app transfer. Sponsorship applies only to transactions sent through ClawBank-managed flows. `amount` also accepts "all" (or "max") to send the wallet's entire USDC balance, read live at execution time. On success the result includes remaining_usdc on THIS self-custody wallet — report that number as what's left. Do not call get_balance (that is a different, custodial wallet). If remaining_usdc is absent, re-read with get_self_custody_token_balance only. IMPORTANT: after a sell/swap, NEVER size a send from the swap's quoted output — the settled amount is smaller once fees are skimmed and the send will revert. Use "all" to sweep it, or re-read the balance with get_self_custody_token_balance and send that exact amount.

Input schema

{schema_json(tool)}

Sends ANY ERC-20 token on Base mainnet from the user's self-custody wallet to a destination 0x address — the generalized sibling of send_usdc_on_base for arbitrary tokens (memecoins, long-tail tokens, anything the wallet holds). Does NOT send native ETH — the 0xeeee…eeee sentinel is refused (native_eth_not_supported); swap ETH→USDC first, then send_usdc_on_base. MOVES FUNDS OUT — always confirm the token, amount, and destination with the user first. The token's on-chain symbol and decimals are read fresh and used as authoritative: addresses that don't behave like an ERC-20 are refused (not_erc20), and sending to the token's OWN contract address is refused (tokens sent to a token contract are burned forever). Gas-sponsored via ClawBank's Turnkey flow, so the user needs no ETH. `amount` also accepts "all"/"max" to send the entire live balance — after a buy/swap, NEVER size the send from the swap's quoted output (less settles once fees are skimmed); use "all" or re-read the balance first. For USDC prefer send_usdc_on_base.

Input schema

{schema_json(tool)}

Creates a secure link the user taps to add money (USD) to their self-custody wallet via Apple Pay guest checkout. IMPORTANT: requires Apple Pay with a DEBIT card in the wallet — credit cards are not accepted and there is no plain card-entry path; tell the user this up front, and route non-Apple-Pay users to a direct USDC deposit instead. The purchased USDC is delivered to the user's self-custody Base wallet. Text the returned 'url' to the user. Requires a verified email AND phone; if either is missing the tool returns success=false with a 'missing' list and instructions (e.g. the user can reply 'LINK EMAIL you@example.com' to add an email). Default amount is $20.

Input schema

{schema_json(tool)}

Buys a ClawBank inference-credit package: sends that amount of USDC on Base from the user's self-custody wallet to the ClawBank treasury (gas sponsored) and credits their inference balance 1:1. MOVES FUNDS OUT — always confirm the package amount with the user first. Only the fixed configured packages are sold; if the requested amount isn't one, the tool returns the valid options. The user's wallet must already hold enough USDC (offer create_topup_link or a direct deposit first if it doesn't).

Input schema

{schema_json(tool)}

Returns the user's native XRP Ledger (XRPL) self-custody wallet r-address. This is a second wallet alongside the Base/EVM self-custody wallet, in the same Turnkey sub-organization. Lazy-provisions the XRPL account on first call. Idempotent.

Input schema

{schema_json(tool)}

Returns the user's XRPL balances: XRP balance plus the reserve/spendable breakdown (XRPL locks a base reserve + an owner reserve per trust line, all read live from the ledger), and the RLUSD trust-line balance when one is set. For an unfunded account, returns activated=false.

Input schema

{schema_json(tool)}

Establishes an RLUSD trust line on the user's XRPL wallet so it can hold RLUSD. This locks an additional owner reserve (~0.2 XRP) on the ledger — confirm the user accepts that before calling. No-op semantics if a trust line already exists.

Input schema

{schema_json(tool)}

Sends XRP from the user's XRPL self-custody wallet to an external r-address. MOVES FUNDS OUT — confirm destination and amount with the user first. Note XRPL reserves: sending to an unactivated account requires at least the base reserve (~1 XRP) to activate it, and the sender's own reserve stays locked. Exchange deposit addresses usually also require a destination_tag.

Input schema

{schema_json(tool)}

Sends RLUSD from the user's XRPL self-custody wallet to an external r-address. MOVES FUNDS OUT — confirm destination and amount with the user first. The destination must be an activated XRPL account holding an RLUSD trust line; otherwise the send fails with destination_missing_trustline.

Input schema

{schema_json(tool)}

Bridges funds from the user's Base wallet to their XRPL wallet via Squid Router. The Base-side transaction is gas-sponsored by ClawBank; Squid's solver delivers XRP or RLUSD to the XRPL r-address. Returns a transfer id to poll with get_bridge_status. Requires Squid bridging to be enabled (integrator id configured).

Input schema

{schema_json(tool)}

Bridges funds from the user's XRPL wallet back to their Base wallet via Squid Router. Submits an XRPL payment to Squid's deposit address; the solver delivers the destination token (default USDC) on Base. Returns a transfer id to poll with get_bridge_status.

Input schema

{schema_json(tool)}

Returns the status of a bridge transfer by id, or the user's recent transfers when no id is given. Statuses: pending, source_submitted, settled, failed, refunded.

Input schema

{schema_json(tool)}

Swaps between XRP and RLUSD on the XRPL native DEX (single cross-currency payment). Requires an RLUSD trust line. Specify direction and the source amount plus a slippage floor for the destination.

Input schema

{schema_json(tool)}

Returns the user's ClawBank token balances on BOTH Base and Robinhood Chain, plus the live USD price (from the highest-liquidity DEX pair). The user's Robinhood address is the SAME address as their Base self-custody wallet — EVM addresses are chain-agnostic — so to receive ClawBank on Robinhood, share this address. ClawBank on Robinhood is the official LayerZero omnichain deployment: every token there is backed 1:1 by one locked on Base (no new token, supply unchanged). Lazy-provisions the wallet on first call.

Input schema

{schema_json(tool)}

Bridges ClawBank from the user's Base wallet to their own address on Robinhood Chain via the official LayerZero OFT bridge (locks on Base, mints on Robinhood — 1:1, no slippage: the amount sent is the amount received). ClawBank handles gas and fee funding automatically; total cost is ~$0.05. Minimum 10,000 ClawBank (amounts are tokens, not dollars — 10,000 ClawBank is a few tens of cents). Delivery typically takes 45–90 seconds — poll get_robinhood_bridge_status until status="delivered". IMPORTANT: only one bridge can be in flight at a time, and a slow bridge must NEVER be re-submitted (once the source transaction confirms, delivery is guaranteed; re-sending doubles the transfer).

Input schema

{schema_json(tool)}

Bridges ClawBank from the user's Robinhood Chain wallet back to their own address on Base via the official LayerZero OFT bridge (burns on Robinhood, unlocks on Base — 1:1, no slippage). ClawBank handles gas and fee funding automatically (~$0.05 total). Minimum 10,000 ClawBank. Delivery typically takes 45–90 seconds — poll get_robinhood_bridge_status until status="delivered". Same rules as the other direction: one bridge in flight at a time; never re-submit a slow bridge.

Input schema

{schema_json(tool)}

Returns the status of a ClawBank Base↔Robinhood bridge transfer by id, or the user's recent transfers when no id is given. To LIST the user's bridge transfers (e.g. "what are my bridge transfers?"), call this with NO arguments — do NOT guess a transfer_id; only pass one you got from a previous bridge or list call. Statuses: pending, source_submitted (in flight), delivered (success, terminal), failed (only possible before the source transaction confirmed). Each transfer includes a track_url (LayerZero Scan) you can share with the user. A transfer stuck in source_submitted is SAFE — delivery is guaranteed and completes when DVN verification does; keep polling, never re-send.

Input schema

{schema_json(tool)}

Sends ClawBank on Robinhood Chain from the user's wallet to any 0x address (a plain token transfer, not a bridge). MOVES FUNDS OUT — confirm destination and amount with the user first. ClawBank funds the (sub-cent) gas automatically; the user never needs ETH. To send ClawBank on Base instead, note that Base ClawBank and Robinhood ClawBank are the same asset on different chains — bridge first if the user's balance is on the wrong chain.

Input schema

{schema_json(tool)}

Quotes providing liquidity to the official ClawBank/ETH pool (Uniswap v4, Robinhood Chain) without executing anything. The user commits an amount of ClawBank; a "zap" sells roughly half for ETH and deposits both sides into a full-range LP position that earns a proportional share (position vs. whole pool) of the pool's 1% trade fee — never say the user earns 1% of trades. The quote returns the split, the estimated position, and the price impact of the balancing swap. ALWAYS quote before provide_liquidity: if requires_acceptance is true (impact ≥3%) the user must explicitly approve; if blocked is true (impact >10%) the zap will be refused — suggest a smaller amount. The user's ClawBank must already be on Robinhood Chain (bridge_clawbank_to_robinhood first if it's on Base).

Input schema

{schema_json(tool)}

Provides liquidity to the ClawBank/ETH pool (Uniswap v4, Robinhood Chain) in one action: sells the calculated portion of the user's ClawBank for ETH, then mints a full-range LP position NFT to the user's own wallet. USES FUNDS — quote first with quote_liquidity_zap and confirm with the user. Gas is funded automatically. The position earns its proportional share of the pool's 1% fee on every ClawBank/ETH trade (share = position size vs. whole pool); earnings and value are tracked with get_liquidity_positions and withdrawable anytime with withdraw_liquidity. Only one zap can be in flight at a time. If a zap fails partway, nothing is lost — retrying picks up where it left off without double-swapping.

Input schema

{schema_json(tool)}

Lists the user's ClawBank/ETH liquidity positions with live on-chain state: current token amounts, uncollected trading fees, and USD values, alongside what was originally deposited (so the user can see fees earned separately from price-driven value changes — impermanent loss transparency).

Input schema

{schema_json(tool)}

Withdraws liquidity from a position back to the user's wallet (both ClawBank and ETH, plus uncollected fees). MOVES FUNDS — confirm with the user first. Partial withdrawals leave the position open; 100% closes it.

Input schema

{schema_json(tool)}

Collects a position's uncollected trading fees to the user's wallet without touching the position's principal. Use get_liquidity_positions first to see what's claimable.

Input schema

{schema_json(tool)}

Quotes converting the user's leftover Robinhood-chain ETH back to ClawBank without executing anything. Withdrawing an LP position returns native ETH that has no bridge home (the bridge only carries ClawBank); this sweep sells everything above the gas reserve for ClawBank in one swap, after which bridge_clawbank_to_base covers the trip to Base. ALWAYS quote before sweep_robinhood_eth: if requires_acceptance is true (impact ≥3%) the user must explicitly approve; if blocked is true (impact >10%) the sweep will be refused. Returns nothing_to_sweep when the wallet holds only gas dust.

Input schema

{schema_json(tool)}

Converts the user's leftover Robinhood-chain ETH back to ClawBank in one swap (everything above the gas reserve). USES FUNDS — quote first with quote_eth_sweep and confirm with the user. The resulting ClawBank lands in the same wallet and can then be bridged to Base with bridge_clawbank_to_base. Alternatively, leftover ETH is folded into the user's next provide_liquidity automatically — sweep only when the user wants the value back as ClawBank rather than re-deposited.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Create a stored recipient. Types: iban, aba, sort_code (see Wise account requirements).

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Outbound transfer from Wise balance: quote, recipient, transfer, fund. Check structuredContent.success.

Input schema

{schema_json(tool)}

Returns the agent-oriented guide for the formation flow: tool order, payload shape, status enum, and how to handle RFIs. Call this once at the start of a session to avoid bloating every tool description.

Input schema

{schema_json(tool)}

Returns the exact `payload` shape for start_formation_checkout, plus an example payload, the allowed business-category strings, the allowed responsible-party types, and any test-pricing flags. Call this BEFORE start_formation_checkout — it is the single biggest unlock for completing a formation in one round-trip without guessing fields.

Input schema

{schema_json(tool)}

Diagnostic: returns the exact JSON body the server would POST for a given quote (after server-side enrichment — products, packageId, orderTotalPrice, and the responsiblePartyEmail default). Useful when a submission failed with `filing_partner_validation_failed` and you want to see the actual outbound shape without re-running the partner. responsiblePartySSN is redacted in the output.

Input schema

{schema_json(tool)}

Lists business formation orders for the authenticated user. Each order includes a normalized `state_machine_status` enum (one of `pending_filing | submitted | filed | rfi_signature_needed | rfi_data_needed | filing_rejected | submission_failed | on_hold | complete | canceled | unknown`) so you can branch without parsing the partner's vocabulary, plus `updated_at` for freshness.

Input schema

{schema_json(tool)}

Returns one formation order. When refresh is true (default), refreshes status from the formation service before reading the database.

Input schema

{schema_json(tool)}

Downloads a formation document (PDF or ZIP) as base64. Only for orders you own. Use document_type "formation" for articles of organization (default) or "ein" for the federal EIN confirmation letter. Large files are capped (4000000 bytes); use the ClawBank web app if this errors.

Input schema

{schema_json(tool)}

Uploads a signed PDF for Signature Needed RFI orders. Pass PDF as base64; same rules as the web uploader.

Input schema

{schema_json(tool)}

Summarizes US states/jurisdictions where business formation is offered (all 50 states). By default it returns compact coverage metadata only; set include_full_list=true only when you explicitly need every state code/name. Use this before list_formation_entity_types or list_formation_packages to discover the supported `state` argument.

Input schema

{schema_json(tool)}

Lists business entity types available for the given state. The catalog varies by state and is currently filtered to the types we are equipped to file in this launch window. Always call this first before assuming an entity type is offered.

Input schema

{schema_json(tool)}

Lists formation packages for a given state and entity type. The returned `id` is the `package_id` to pass to start_formation_checkout. `price_cents` is the underlying USD list price; `effective_price_cents` is the final quoted amount for checkout. For budget checks, use `effective_price_cents` rather than `price_cents`.

Input schema

{schema_json(tool)}

Creates a free formation checkout quote. The quote returns the USDC amount, the receiving wallet (`pay_to`), the network (Base / eip155:8453), and an `instructions` string. Payment comes from the user's ClawBank self-custody wallet by default — just ensure it holds enough USDC, then pay with `send_usdc_on_base(to_address: pay_to, amount)`. After sending, call `wait_for_formation_payment(quote_id)` to be notified when the on-chain transfer is detected and the order is created. BEFORE calling this, call `inspect_formation_payload_schema` to get the exact `payload` shape and an example. If you skip that step and the payload is incomplete, the response will include `missing` (a section→fields map) so you can fix the payload in one retry — do NOT loop and guess field names.

Input schema

{schema_json(tool)}

Returns the current status of a formation checkout quote. Status flips from `awaiting_payment` to `paid` once the matching USDC transfer is detected on-chain. After `paid`, the response includes the resulting order.

Input schema

{schema_json(tool)}

Long-polls a formation quote: blocks server-side until the quote leaves `awaiting_payment` (typically because the matching USDC transfer was detected) or until `timeout_s` seconds elapse. Returns the same shape as check_formation_quote_status. Default timeout 60s, max 300s.

Input schema

{schema_json(tool)}

Cancels a formation order owned by the authenticated user. Only useful while the order has not yet completed filing.

Input schema

{schema_json(tool)}

Lists the business entities (LLCs, etc.) filed by the authenticated user. Returns each business's legal name, entity type, state, status (`forming` | `active` | `cancelled` | `dissolved`), EIN and formed-on date when available, plus the linked `formation_order_guid` so a follow-up `get_formation_order` call can fetch filing-partner lifecycle details. Use this before referencing a business by id in any future tool.

Input schema

{schema_json(tool)}

Returns one business by id, scoped to the authenticated user. Same shape as a row from `list_my_businesses`. Returns `business_not_found` if the id doesn't exist or doesn't belong to the caller.

Input schema

{schema_json(tool)}

List the documents in a company's record book (the version-controlled repository of governance documents for a ClawBank-formed LLC), with the record book's provisioning status. Use the caller's business id from list_businesses / formation tools.

Input schema

{schema_json(tool)}

Read one document from a company's record book. Markdown documents are returned as Markdown text; company metadata is returned as JSON text. Get valid document ids from list_company_records.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Walkthrough for an LLM agent on how to use ClawBank's Contracts capability: entity-to-entity agreements signed via DocuSign, optionally with an embedded Shodai milestone agreement that pays USDC on-chain as milestones are approved. Call this FIRST before using any other clawbank_contracts_* tool.

Input schema

{schema_json(tool)}

Author and send a plain-text contract to another ClawBank user. The recipient must already have a ClawBank account (matched by email). Pick the From party: one of YOUR ClawBank-formed businesses via sender_business_id (look it up first with clawbank_contracts_my_businesses), OR the user's attested personal legal name via sender_party: "individual" (shown as individual_identity in clawbank_contracts_my_businesses). One of the two is required. Returns the new contract id, the underlying DocuSign envelope id, and the current status. Embedded signing URLs are minted later via clawbank_contracts_sign.

Input schema

{schema_json(tool)}

Stake your security deposit on a shodai_escrow contract (sponsored USDC push from your ClawBank wallet into the contract's 2-of-3 escrow Safe). Recipients must do this before clawbank_contracts_sign will bind the agreement. Check the deposit amount via the escrow slice on clawbank_contracts_read.

Input schema

{schema_json(tool)}

Withdraw whatever the escrow currently owes you: your deposit back after clean completion/termination or expiry, or your share of an executed arbitration ruling. Runs the 2-of-3 Safe ceremony (your wallet signature + the ClawBank platform signature). Returns the payout tx hash.

Input schema

{schema_json(tool)}

Raise a formal dispute over a shodai_escrow contract's deposits. Freezes all escrow payouts and opens a case for the independent arbiter. Only a contract party may file, and only while the escrow is fully funded (active or releasable). Include the full story in reason — it is the arbiter's primary evidence.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Read a single contract by id. Returns title, body_text, signers, current status, and the timeline of events. The caller must be either the sender or the recipient (by email).

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Counter-sign a contract on behalf of the calling user. ClawBank mints a fresh embedded signing URL and drives the DocuSign signing ceremony in a server-side headless browser. Blocks until DocuSign confirms `signing_complete` (typical wall time 20-30s) or the hard timeout. Returns the refreshed contract -- the calling user's signer will be `signed`, and the contract `status` will be `in_progress` (if the other party hasn't signed yet) or `completed`.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Client approves milestone (`milestoneApprove`). USDC payment is executed on-chain by the Shodai contract.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Terminate a Shodai agreement. Set role=client or role=provider to select input.

Input schema

{schema_json(tool)}

Submit post-completion or post-termination feedback (`clientFeedback` or `providerFeedback`). Your role and the counterparty's wallet address are derived automatically from the contract — usually you only need contract_id, feedback_text, and rating.

Input schema

{schema_json(tool)}

List the contracting parties you can pin as the 'From' party on a new contract: your ClawBank-formed businesses (via clawbank_contracts_create's sender_business_id) plus, when the user has attested a personal legal name in Settings, an individual_identity object (usable via sender_party: "individual"). Returns ONLY your own parties -- this is not a directory of other users' entities. Each business entry includes id, legal_name, entity_type, formation_state, formed_on (date or null), and status (forming|formed).

Input schema

{schema_json(tool)}

Walkthrough for an LLM agent on how to use ClawBank's trading capability: what a strategy is, how to create one, the strategies available, conflict warnings when two strategies trade the same token, and the safety rails (approved withdrawal address, heartbeat, etc.).

Input schema

{schema_json(tool)}

Returns the base tokens this user may trade against USDC: the operator-curated registry plus any Base ERC-20 the user has added to their wallet that passed on-chain + liquidity checks (`source` is `"registry"` or `"user"`). Each entry is `{symbol, pair, address, requires_approval, tradeable, source}`. ALWAYS pass the contract `address` as the `base_token` arg of `create_strategy` / `execute_spot_swap` (symbols are ambiguous across custom tokens; registry symbols still work). If `requires_approval` is true (every ERC-20), the user must call `approve_token_for_trading` with that `address` once before a strategy can sell it — approval is also done automatically on the first sell. Native ETH has `address: null` and needs no approval.

Input schema

{schema_json(tool)}

Executes a one-shot buy or sell of a base token against USDC via 0x. Does not create a recurring strategy — runs immediately with the user's Turnkey wallet. For recurring automation use `create_strategy` with dca, rebalancing, momentum, or conditional.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Lists trading strategies belonging to the calling user, newest first. By default terminal DESTROYED strategies are omitted (they can never be restarted); pass `status` to narrow further or `status="all"` to include destroyed. Each entry includes lifecycle + run telemetry (status, last_run_at, last_run_status) plus activity summaries `positions_count` and `last_trade_at` so you can tell at a glance whether a strategy has traded — no per-strategy follow-up call needed. `last_trade_at` is null only when it has never traded; a RUNNING strategy with last_run_status "hold" is evaluating normally (many strategies intentionally hold between trades).

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Creates a new trading strategy. Validates the config and activates it on ClawBank's in-app scheduler, which evaluates the strategy on each tick. For `dca`, pass only the strategy config (side, amount_usdc_per_buy, interval_minutes, total_budget_usdc, max_slippage_bps) — cadence is in minutes and heartbeat is derived automatically. Proceeds are withdrawable only to the user's own Turnkey self-custody wallet. If another active strategy on this account already trades the same token in a way that would fight the new one, this returns `{success: false, error: "conflict_detected", conflicts: [...]}` and creates nothing — pass `confirm_conflict: true` to create it anyway.

Input schema

{schema_json(tool)}

Resumes a stopped strategy and reseeds its tick schedule. Re-checks for conflicts with the user's other active strategies on the same token; pass `confirm_conflict: true` to start anyway.

Input schema

{schema_json(tool)}

Pauses a running strategy: halts evaluation. Capital stays in the user's wallet.

Input schema

{schema_json(tool)}

Resumes a paused strategy — flips PAUSED → RUNNING and reseeds the tick schedule. Re-checks for conflicts; pass `confirm_conflict: true` to resume anyway.

Input schema

{schema_json(tool)}

Stops a running strategy (evaluation halted). Capital stays in the user's wallet and remains withdrawable.

Input schema

{schema_json(tool)}

Tears down the strategy — TERMINAL. Allowed from any state except RUNNING (call stop_strategy first). Use this to abandon a freshly-CREATED or stuck-STARTING strategy, or to clean up FAILED / STOPPED ones.

Input schema

{schema_json(tool)}

Replaces the strategy's config. The strategy *type* is immutable — only the config map may change. The next scheduled tick picks up the new config.

Input schema

{schema_json(tool)}

Grants the 0x AllowanceHolder permission to spend the given ERC-20 token from the user's self-custody wallet — required before a strategy can sell that token. Sets an unlimited approval (max_uint256), so this is a one-time call per (user, token). Returns the broadcast tx hash; swaps that need this token work once it confirms (~2-4s on Base). Call once per non-USDC base_token the user wants to trade. Also refreshes the user's Turnkey trade-signing policy to include any new tokens the operator has added since the user's existing strategies were created, so existing strategies can immediately trade newly supported tokens after a single call to this tool.

Input schema

{schema_json(tool)}

Recent activity for a strategy: a chronological `events` list (the strategy's recorded trade, completion, and lifecycle entries from ClawBank's audit log, newest first) plus `last_tick` (ran_at / status / error / next_run_at) summarizing the most recent evaluation. Per-tick `hold` decisions are not stored individually — `last_tick.status` reflects the latest one. Optional `lines` caps the number of events (default 50, max 200).

Input schema

{schema_json(tool)}

Read-only USDC-denominated price history for a tradeable token — candles from Alchemy's Prices API. Use this to inspect where a token has traded WITHOUT executing a swap (a dry `execute_spot_swap` also returns a live quote). Returns `points` ({timestamp, price_usdc}, oldest→newest) and `latest_price_usdc`.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Realized + unrealized PnL summary (USDC). Realized is summed across confirmed trades; unrealized comes from the most recent positions snapshot.

Input schema

{schema_json(tool)}

Account-wide P&L + volume rollup across all of the user's strategies: realized, unrealized, and net P&L (realized + unrealized), traded volume, fees, trade count, and win/loss counts — per strategy and in total. Realized is closed sells only; unrealized is the current open-position mark (last fill). Prefer net_pnl_usdc for overall book performance.

Input schema

{schema_json(tool)}

Computes the account-wide P&L report and emails it to the user. Callable on demand; point a scheduler at it for periodic digests.

Input schema

{schema_json(tool)}

Walkthrough for an LLM agent on ClawBank's Trade to Earn program: deploy CLAWBANK into the trading vault, accrue score while deployed, and split each epoch's fixed CLAWBANK reward pot by time-deployed capital. Covers the epoch/score/reward mechanics, the REST mirror, and the safety facts (funds never leave the user's wallet; no lock).

Input schema

{schema_json(tool)}

Everything about the calling user's Trade to Earn state in one call: the current epoch (number, pot, close time), their active deployment and its live USD value, leaderboard standing (rank, share, projected payout — projected, never final until epoch close), reward thaw state (frozen vs claimable CLAWBANK), the user's Base CLAWBANK and USDC balances (`balance_clawbank` / `balance_usdc`; null means the balance could not be read or no wallet exists yet), the FREE portion of those balances (`free_clawbank` / `free_usdc` — wallet balance minus what the active deployment already counts), and the minimum deployment at the live price. When the user asks how much they can top up, trade, send, or bridge, relay `free_clawbank` / `free_usdc` VERBATIM — never compute availability yourself. `current_value_usd`, `current_clawbank_inventory`, and `current_usdc_inventory` are the live position, clamped to what the wallet actually holds on-chain — report those (plus the free balances) as the vault position. Deposit-history totals are NOT exposed here: never present any deposit figure next to `current_value_usd` as profit or loss. If the user asks how much they have put in over time, say deposit-history accounting isn't available through this tool and offer the current value instead; for trading results, use `vault_stats.realized_pnl_usd`.

Input schema

{schema_json(tool)}

The current epoch's Trade to Earn leaderboard: ranked wallets (truncated addresses) with share of pot and projected payout. Standings are projections — the final leaderboard at epoch close IS the distribution.

Input schema

{schema_json(tool)}

Deploys capital from the user's self-custody wallet into the Trade to Earn vault. Deposit either CLAWBANK (roughly half is swapped to USDC) or USDC (roughly half is swapped to CLAWBANK — the deposit's first market action is a buy) so the vault's grid strategy can trade both sides — THIS EXECUTES A REAL SWAP of the user's funds (they stay in the user's own wallet, but value then moves with the market). BEFORE confirming an amount or quoting a dollar value to the user, call get_trade_to_earn_status and check that `balance_clawbank` (or `balance_usdc`) actually covers the amount — a null or insufficient balance means the funds are not in the user's ClawBank wallet and must be deposited or bought first. A missing wallet is auto-provisioned on deploy. Provide exactly one of amount_clawbank or amount_usdc. Minimum $100 worth at the live price; one active deployment per user. Deployed capital accrues score (USD-hours) toward the epoch pot while it trades.

Input schema

{schema_json(tool)}

Adds capital to the user's ACTIVE Trade to Earn deployment — same deposit options as deploy_trade_to_earn (exactly one of amount_clawbank or amount_usdc), but only the new capital is swapped ~50/50; the existing position is untouched and score history is kept. THIS EXECUTES A REAL SWAP. Minimum $25 per top-up. A top-up must be funded by FREE wallet balance — the wallet also holds the active deployment's inventory, and funds already counted in the deployment cannot be re-added (errors with insufficient_free_balance). Errors with no_active_deployment if there is nothing to top up (use deploy_trade_to_earn instead).

Input schema

{schema_json(tool)}

Stops the user's active vault deployment: the vault strategy halts, score accrual ends, and all funds simply stay in the user's wallet (there is nothing to withdraw — NOTHING is transferred on stop, so no amount will 'appear' in the wallet afterwards). Report `current_value_usd` and the live wallet balances to the user as the final position. Accrued score is kept — a stopped wallet still ranks and still collects its share at epoch close.

Input schema

{schema_json(tool)}

Claims (withdraws) every thawed CLAWBANK reward to the user's own wallet. Rewards from a closed epoch thaw linearly over the epoch's vesting window (typically 3 months); this moves the thawed portion. Destination is locked to the user's own wallet; no gas needed. Check `get_trade_to_earn_status` first — claiming with nothing thawed is a harmless no-op.

Input schema

{schema_json(tool)}

Walkthrough for an LLM agent on ClawBank's Base LP management: provide liquidity into any registered Uniswap v4 pool on Base from a single token (auto-balancing zap), track positions with USD PnL, add, withdraw, and claim fees. Covers pool discovery, the CLAWBANK holder gate, error codes, and the REST mirror.

Input schema

{schema_json(tool)}

Pools available for LP on Base. Without arguments: the registered pool list (curated first). With a `token` address: also runs live discovery for that token's Uniswap v4 pools (paired against WETH or USDC, deepest first, with liquidity/volume context) so the agent can answer "can I LP $FOO?" — pass the returned pool_id to lp_quote_provide / lp_provide. The clawbank_gate object reports how much CLAWBANK the user must hold for non-free-tier pools.

Input schema

{schema_json(tool)}

Curated LP starting points for "where should I provide liquidity?" — two lanes: clawbank (CLAWBANK pools, free for everyone) and ecosystem (Bankr-ecosystem tokens with a qualifying Base pool, sorted by 24h turnover). Each pool is a transparent card: liquidity, volume, turnover, est. fee APR (null for dynamic-fee pools — report as unknown), price change, age, and a risk tag (steady/active/speculative). Full-range LP profit is fees earned minus impermanent loss — high-volume trending tokens pay more fees but big price moves eat them, so present risk tags honestly and ask whether the user wants steady or speculative. Never promise profit.

Input schema

{schema_json(tool)}

Non-committal preview of an LP deposit: how much of the input gets swapped to the other pool token, the estimated deposit split, balancing-swap price impact, and whether the caller currently passes the holder gate (`entitled`). Call this and confirm with the user before lp_provide.

Input schema

{schema_json(tool)}

Provides liquidity on Base: swaps ~half of the input token for the pool's other token (0x, real swap), then mints a full-range Uniswap v4 position. THIS MOVES REAL FUNDS — always lp_quote_provide and confirm the amount with the user first. Funds stay in the user's own self-custody wallet (the position is an NFT they own); gas is sponsored. CLAWBANK-paired pools are free for everyone; other pools require holding CLAWBANK (error lp_holding_requirement_not_met reports the threshold). One LP operation in flight per user.

Input schema

{schema_json(tool)}

Adds liquidity to one of the user's EXISTING Base LP positions (from lp_get_positions) — same auto-balancing zap as lp_provide, but increases the position NFT instead of minting a new one. THIS MOVES REAL FUNDS — confirm with the user first.

Input schema

{schema_json(tool)}

The user's Base LP positions with live on-chain state and the PnL block: current value, uncollected fees, deposited vs returned USD, and net PnL (USD and %). USD figures are null when a price mark was unavailable — report those as "—", never invent a number. Also reports any in-flight LP operation.

Input schema

{schema_json(tool)}

Withdraws a percentage (1–100) of a Base LP position back to the user's wallet; 100 closes the position. Uncollected fees come back with the withdrawal. Never gated — always available. Confirm the percent with the user first.

Input schema

{schema_json(tool)}

Collects a Base LP position's uncollected trading fees to the user's wallet without touching the principal. Never gated. Check lp_get_positions first — claiming with ~zero fees wastes a transaction.

Input schema

{schema_json(tool)}

Walkthrough for an LLM agent on ClawBank's prediction markets (Limitless Exchange on Base): searching markets by topic, browsing what's active, and quoting live odds from the order book. Covers how to read prices as probabilities, market types, error codes, and the REST mirror.

Input schema

{schema_json(tool)}

Semantic search over active prediction markets — topical queries work ("fed rate cut", "premier league", "AI stocks"), no exact keywords needed. Returns market cards with YES/NO prices (= implied probabilities), volume, expiry, the minimum order (shares + estimated USDC cost per outcome — often $10+, check before promising a bet size), and the slug to pass to market_odds. Free for everyone, no funds involved.

Input schema

{schema_json(tool)}

Browse active prediction markets (volume-sorted). Use for "what can I bet on?" — for anything topical prefer search_prediction_markets. Paged; short-dated crypto/equity up-or-down markets dominate the first pages by design. The response's `categories` list carries the thematic filter ids (politics, sports, economy, …) with live market counts — pass one back as category_id to browse a theme.

Input schema

{schema_json(tool)}

Live odds for one market: YES/NO prices (implied probabilities), the order book's best bid/ask, midpoint, spread, last trade, and the minimum order — min_order_size_shares plus min_cost_usdc (live per-outcome dollar minimums). Always quote from this — never from a stale search result — before discussing a trade. Prices move; say when a book is empty or a market is closed rather than inventing numbers.

Input schema

{schema_json(tool)}

Places a real-money prediction-market order on Limitless (Base) from the user's own self-custody wallet. THIS MOVES REAL FUNDS when it matches — always call market_odds first and confirm the market, outcome, price, and total cost with the user before placing. BUY cost = price x shares USDC (e.g. 100 YES at 0.40 = 40 USDC); a winning share pays $1. Orders fill only against resting book size: check the market_odds level sizes — if the size at your price is smaller than the order, expect a PARTIAL fill. The response's filled_shares is what actually matched; always relay it, never the requested size. Every market has a minimum order size — check market_odds min_cost_usdc first or the venue rejects the order. BUY orders are rejected when price x shares plus other live bids exceeds the wallet's USDC (the venue does not escrow resting orders). The first order auto-registers the wallet with the venue and approves USDC (gas sponsored; the wallet only needs the USDC).

Input schema

{schema_json(tool)}

Cancels one of the user's open prediction orders by order_id (from place_prediction / my_predictions). Filled amounts cannot be un-filled; cancel only pulls what still rests on the book.

Input schema

{schema_json(tool)}

The user's prediction orders, newest first: market, outcome (YES/NO), side, price, shares, filled_shares (what actually matched at placement, net of fees), position_shares (the wallet's live on-chain share balance for that outcome — the source of truth for "what do I hold?" before resolution; absent = not checked, not zero), status (live / matched / cancelled / expired), and the order_id for cancel_prediction. "expired" = the market settled without the order filling: it is fully closed, no funds ever moved for it, nothing is locked or in limbo — do not flag it as a ledger problem. A "live" order is simply still resting on the book of an open market. For wins and payouts use check_winnings — never promise a payout from this list alone.

Input schema

{schema_json(tool)}

The user's claimable prediction-market winnings: for every resolved market they traded, the winning shares actually held in their wallet (checked on-chain) and the USDC each claim pays. Winnings normally auto-pay within minutes of resolution (the user is texted) — anything showing here is still pending and claim_winnings pays it now. This is the source of truth for "did I win?" — order statuses in my_predictions are not.

Input schema

{schema_json(tool)}

Redeems ALL the user's claimable winnings for USDC, paid directly into their own wallet (gas sponsored — no ETH needed; typically lands in under a minute). Winnings also auto-pay within minutes of resolution, so this is for "pay me now" — run check_winnings first and confirm the total. Safe to re-run: claimed positions are simply empty.

Input schema

{schema_json(tool)}

Create a token deal: escrow N tokens of any Base ERC-20 and get back a one-time claim code + link the recipient redeems to receive them — the way to send tokens to someone who may not be on ClawBank yet (for a plain transfer to an address, use send_token instead). Pass vest_days to make it a VESTED deal: at claim, a non-transferable Sablier stream is minted to the claimer's wallet and the tokens vest linearly — the recipient can never dump the position. cancelable: true keeps a cancel lever for the sender (claw back only the unvested remainder); default is non-cancelable (trustless once claimed). Pass kpi_market_cap_usd + kpi_deadline_days to make it a KPI deal: the tokens only unlock if a market cap holds at or above the threshold (sustained kpi_sustained_hours, default 24h) before the deadline — otherwise they return to the sender. The watched market cap is the deal token's own by default; pass kpi_token_address to watch a different token ("$100 USDC that unlocks if CLAWBANK hits $1.2M"); combine with vest_days for a vest that starts at the unlock moment. Every deal is a BEARER claim, split across two credentials: the LINK previews the deal (a read-only card that's safe to share, screenshot, or let messengers unfurl — it can never claim), and the CODE is the deal — whoever redeems it first gets the tokens. The sender hands both to anyone over any channel (text, email, Telegram, in person); for high-value deals suggest sending the code through a second channel. Never ask who it's for or request any recipient identity; remind the sender to guard the code like cash. Unclaimed deals auto-return to the sender after the claim window (default 7 days). The code is returned ONCE and cannot be recovered — deliver it to the sender immediately. This moves funds out of the wallet and requires the user's explicit YES confirmation.

Input schema

{schema_json(tool)}

Redeem a deal code (e.g. "FART-7K2M-9QXP") for the current account. On success the escrowed tokens are released to this account's self-custody wallet (delivery takes a few seconds; deal_status shows the release transaction). Deal codes are bearer: whoever redeems first gets it. Code entry is rate-limited.

Input schema

{schema_json(tool)}

Status of one deal: claimed or still open, the clocks (claim window), amounts, and transaction hashes. Look up by deal_id (for deals you sent or received) or by code (rate-limited).

Input schema

{schema_json(tool)}

All deals for the current account: sent (open, claimed, expiring, reclaimed) and received. Deal codes are never included — they are shown once at creation only.

Input schema

{schema_json(tool)}

Pull back one of your own open (unclaimed) deals early: the escrowed tokens return to your wallet and the code stops working. Expired deals also reclaim automatically via the daily sweep.

Input schema

{schema_json(tool)}

Cancel the live vesting stream of a claimed vested deal you created (only possible when the deal was created with cancelable: true). The unvested remainder returns straight to your wallet — everything already vested stays with the recipient and can never be taken back. Irreversible for the stream; requires the user's explicit YES confirmation. For unclaimed deals use reclaim_deal instead.

Input schema

{schema_json(tool)}

Withdraw everything currently vested in a vested deal you received — moves the already-vested tokens from the Sablier stream into this account's wallet. Gas is sponsored; withdrawing costs nothing. deal_status shows how much is withdrawable right now.

Input schema

{schema_json(tool)}

Walkthrough for an LLM agent on ClawBank's x402 capability: how discovery works, how to call a pay-per-request resource, how payments settle (Base USDC / XRPL XRP+RLUSD), how budgets work, and what happens when a call exceeds a cap. Includes the user's current budget. Read this before the first x402 call of a session.

Input schema

{schema_json(tool)}

Searches the live x402 catalogs (CDP Bazaar + the XRPL AI Hub directory) for pay-per-request services: data feeds, AI inference, search, social, crypto market data, and more. Each result includes the resource URL, price, category, and 'pay_with' labels (USDC / XRP). 'payable' indicates whether this account's wallets can pay for it. Use call_x402_resource to actually fetch one.

Input schema

{schema_json(tool)}

Fetches an x402 pay-per-request resource, automatically paying the HTTP 402 challenge from the user's own self-custody wallet (per their payment preference) and returning the content. Many agent-tool endpoints — especially XRPL-native ones like Heurist Mesh — are POST-only and take their inputs as a JSON body: use method POST with json_body (e.g. {"wallet_address": "0x…"}); a 404/405 on GET usually means exactly that. Spending is bounded by the user's x402 budget (per-call and daily USD caps) — a call above the caps fails with the limit details instead of paying; the user can adjust limits via set_x402_budget. Tell the user what was paid (see the 'payment' field) after a successful paid call. Set dry_run to preview the price, payment details, and budget verdict without executing or paying.

Input schema

{schema_json(tool)}

The user's curated x402 service marks: favorites (pinned to the top of their Resources list) and archived services (hidden from their default view). Marks are endpoint-scoped (one resource URL) or provider-scoped (a host, covering every endpoint that provider publishes). Use this to respect the user's curation when picking a resource.

Input schema

{schema_json(tool)}

Marks an x402 service for the user: 'favorite' pins it to the top of their Resources list, 'archived' hides it from their default view. Target exactly one of `url` (a single endpoint) or `provider` (a host — marks every endpoint that provider publishes; per-endpoint marks override it). A target holds at most one mark — setting one replaces the other. Use unmark_x402_service to clear.

Input schema

{schema_json(tool)}

Clears the user's mark (favorite or archived) on an x402 endpoint (`url`) or provider (`provider`). Idempotent.

Input schema

{schema_json(tool)}

The user's x402 payment history: what was bought, when, on which network, and for how much. Includes today's spend against the daily budget.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Updates the user's x402 spend limits and payment preference. Only call this when the user explicitly asks to change their settings — never raise limits on your own initiative to make a payment go through. Caps are in USD and cannot exceed $100.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Claim this user's permanent Coms handle (required before any communication). Claiming sets up the <handle>@wiretap.lol email inbox and, when the IM network is available, the IM identity. Handles are permanent and cannot be changed once a non-legacy handle is claimed.

Input schema

{schema_json(tool)}

CURRENTLY UNAVAILABLE — the IM network is down and this tool returns im_unavailable. Use the coms email tools (send_coms_email etc.) for agent-to-agent communication instead. Re-queue provisioning (repair) for this user's existing Wiretap inbox. Unclaimed users must call set_coms_handle instead.

Input schema

{schema_json(tool)}

CURRENTLY UNAVAILABLE — the IM network is down and this tool returns im_unavailable. Use the coms email tools (send_coms_email etc.) for agent-to-agent communication instead. Search discoverable Wiretap IM users.

Input schema

{schema_json(tool)}

CURRENTLY UNAVAILABLE — the IM network is down and this tool returns im_unavailable. Use the coms email tools (send_coms_email etc.) for agent-to-agent communication instead. List accepted and pending IM contacts for this user.

Input schema

{schema_json(tool)}

CURRENTLY UNAVAILABLE — the IM network is down and this tool returns im_unavailable. Use the coms email tools (send_coms_email etc.) for agent-to-agent communication instead. Send an IM contact request to a recipient username. When the recipient is another ClawBank user with auto-accept enabled, the response includes connected: true and you can message immediately.

Input schema

{schema_json(tool)}

CURRENTLY UNAVAILABLE — the IM network is down and this tool returns im_unavailable. Use the coms email tools (send_coms_email etc.) for agent-to-agent communication instead. Accept an inbound IM contact request from a requester username.

Input schema

{schema_json(tool)}

CURRENTLY UNAVAILABLE — the IM network is down and this tool returns im_unavailable. Use the coms email tools (send_coms_email etc.) for agent-to-agent communication instead. List this user's IM conversations (including new inbound ones). Each entry includes conversation_id (pass it to list_coms_messages), counterparty_username, last_message_preview, and last_message_at. Call this first to discover conversations you don't know about yet.

Input schema

{schema_json(tool)}

CURRENTLY UNAVAILABLE — the IM network is down and this tool returns im_unavailable. Use the coms email tools (send_coms_email etc.) for agent-to-agent communication instead. List IM messages for one conversation (get conversation_id from list_coms_threads). Each message includes from_username and to_username so senders are identifiable.

Input schema

{schema_json(tool)}

CURRENTLY UNAVAILABLE — the IM network is down and this tool returns im_unavailable. Use the coms email tools (send_coms_email etc.) for agent-to-agent communication instead. Send an IM message to a recipient. Recipient must be in accepted contacts first.

Input schema

{schema_json(tool)}

Send an email from this user's inbox. Defaults to <handle>@wiretap.lol; pass inbox to send from a provisioned company address (get_coms_status.email.inboxes). No prior contact is needed (unlike IM). Sends to recipients outside @wiretap.lol are capped per day; check remaining quota in get_coms_status.email.quota.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

List this user's email threads (newest first). Each entry includes a thread_id to pass to list_coms_email_messages.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Register this user on MoltBook (the social network for AI agents) using their claimed Coms handle. Returns a claim_url + verification_code the human must complete (verify email, then tweet) before the agent is active. Idempotent: re-calling returns the existing registration. Requires a claimed (non-legacy) handle first.

Input schema

{schema_json(tool)}

Check whether this user's MoltBook agent has been claimed by their human yet (pending_claim vs claimed). Call after the human completes the claim/tweet flow at the claim_url. If MoltBook no longer recognizes the agent (deleted upstream), the stale linkage is cleared (status `unlinked`) and register_coms_moltbook_agent can be called again.

Input schema

{schema_json(tool)}

Fetch this user's MoltBook profile (name, karma, follower/post counts, claim state). Requires a prior register_coms_moltbook_agent.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

[SIGNS TX] Approve token via an integrated third-party Fight Club service. Agent signs and broadcasts locally using self-custody wallet keys. Use inspect_fightclub_payload_schema when you need full proposal-envelope field details.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

[SIGNS TX] Cancel via an integrated third-party Fight Club service. Agent signs and broadcasts locally using self-custody wallet keys. Use inspect_fightclub_payload_schema when you need full proposal-envelope field details.

Input schema

{schema_json(tool)}

[READ] List Fight Club capabilities and limits via an integrated third-party Fight Club service. Start with fightclub_list_daos for discovery.

Input schema

{schema_json(tool)}

[SIGNS TX] Custom proposal via an integrated third-party Fight Club service. Agent signs and broadcasts locally using self-custody wallet keys. Use inspect_fightclub_payload_schema when you need full proposal-envelope field details.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

[SIGNS TX] Dao meta via an integrated third-party Fight Club service. Agent signs and broadcasts locally using self-custody wallet keys. Use inspect_fightclub_payload_schema when you need full proposal-envelope field details.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

[SIGNS TX] Gov settings via an integrated third-party Fight Club service. Agent signs and broadcasts locally using self-custody wallet keys. Use inspect_fightclub_payload_schema when you need full proposal-envelope field details.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

[SIGNS TX] Join dao via an integrated third-party Fight Club service. Agent signs and broadcasts locally using self-custody wallet keys. Use inspect_fightclub_payload_schema when you need full proposal-envelope field details.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

[SIGNS TX] Post Fight Club memory content (supports proposal-linked notes, threaded discussion, and draft/workspace metadata fields). via an integrated third-party Fight Club service. Agent signs and broadcasts locally using self-custody wallet keys. Use inspect_fightclub_payload_schema when you need full proposal-envelope field details.

Input schema

{schema_json(tool)}

[SIGNS TX] Mint loot via an integrated third-party Fight Club service. Agent signs and broadcasts locally using self-custody wallet keys. Use inspect_fightclub_payload_schema when you need full proposal-envelope field details.

Input schema

{schema_json(tool)}

[SIGNS TX] Mint shares via an integrated third-party Fight Club service. Agent signs and broadcasts locally using self-custody wallet keys. Use inspect_fightclub_payload_schema when you need full proposal-envelope field details.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

[SIGNS TX] Payment via an integrated third-party Fight Club service. Agent signs and broadcasts locally using self-custody wallet keys. Use inspect_fightclub_payload_schema when you need full proposal-envelope field details.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

[SIGNS TX] Process via an integrated third-party Fight Club service. Agent signs and broadcasts locally using self-custody wallet keys. Use inspect_fightclub_payload_schema when you need full proposal-envelope field details.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

[SIGNS TX] Ragequit via an integrated third-party Fight Club service. Agent signs and broadcasts locally using self-custody wallet keys. Use inspect_fightclub_payload_schema when you need full proposal-envelope field details.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

[SIGNS TX] Signal via an integrated third-party Fight Club service. Agent signs and broadcasts locally using self-custody wallet keys. Use inspect_fightclub_payload_schema when you need full proposal-envelope field details.

Input schema

{schema_json(tool)}

[SIGNS TX] Sponsor via an integrated third-party Fight Club service. Agent signs and broadcasts locally using self-custody wallet keys. Use inspect_fightclub_payload_schema when you need full proposal-envelope field details.

Input schema

{schema_json(tool)}

[SIGNS TX] Summon via an integrated third-party Fight Club service. Agent signs and broadcasts locally using self-custody wallet keys. Use inspect_fightclub_payload_schema when you need full proposal-envelope field details.

Input schema

{schema_json(tool)}

[SIGNS TX] Submit a treasury swap proposal for DAO governance (this signs and broadcasts a transaction). via an integrated third-party Fight Club service. Agent signs and broadcasts locally using self-custody wallet keys. Use inspect_fightclub_payload_schema when you need full proposal-envelope field details.

Input schema

{schema_json(tool)}

[SIGNS TX] Token settings via an integrated third-party Fight Club service. Agent signs and broadcasts locally using self-custody wallet keys. Use inspect_fightclub_payload_schema when you need full proposal-envelope field details.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

[SIGNS TX] Tribute via an integrated third-party Fight Club service. Agent signs and broadcasts locally using self-custody wallet keys. Use inspect_fightclub_payload_schema when you need full proposal-envelope field details.

Input schema

{schema_json(tool)}

[SIGNS TX] Vote via an integrated third-party Fight Club service. Agent signs and broadcasts locally using self-custody wallet keys. Use inspect_fightclub_payload_schema when you need full proposal-envelope field details.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

[SIGNS TX] Wrap ETH into WETH in the agent's self-custody signer wallet (not a DAO treasury action). via an integrated third-party Fight Club service. Agent signs and broadcasts locally using self-custody wallet keys. Use inspect_fightclub_payload_schema when you need full proposal-envelope field details.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

File a ClawBank bug or improvement — this is the ticket API. Alias: file_ticket. After filing, poll get_feedback / get_ticket (or GET /api/v1/tickets/:id) for status (open/approved/done/wontfix). Required: title, what_i_did, what_happened. Optional: what_i_expected, surface (HQ/Builder/Settings/API/Console/SMS/other), company_id (os-… or showcase), blocker, kind (bug/improvement/question). Do not file known gaps from the OS docs unless the UI claimed they worked.

Input schema

{schema_json(tool)}

List feedback / tickets you can see (your own; admins see everyone's). Alias: list_tickets. Optional status filter: open, approved, done, wontfix.

Input schema

{schema_json(tool)}

Read one feedback / ticket by id (fb-… from file_feedback / file_ticket). Alias: get_ticket. Status is open, approved, done, or wontfix.

Input schema

{schema_json(tool)}

Alias of file_feedback. Files a ticket on the operator queue. Poll get_ticket / GET /api/v1/tickets/:id for status.

Input schema

{schema_json(tool)}

Alias of list_feedback. List tickets you can see.

Input schema

{schema_json(tool)}

Alias of get_feedback. Read one ticket by id (fb-…) and its status.

Input schema

{schema_json(tool)}

Mint a narrower child API key from this token — no email login code. Child scopes must be a subset of this key. Optional company_id binds the child to one OS company. Caps cannot exceed this key. The plain token is returned once.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Walkthrough for ClawBank OS company tools: create/import a company, buy or attach a domain, mint company email, look up a token, start Stripe payments, and provision a house-owned Meta ad account. Call this first. Not Formation or Company Records.

Input schema

{schema_json(tool)}

List this account's ClawBank OS companies in the current environment. Alias: list_companies. Use company_id from each row on the other OS tools.

Input schema

{schema_json(tool)}

Read one OS company you own (domain, email, token, payments, ads, preview_url / website_deploy_url). Alias: get_company.

Input schema

{schema_json(tool)}

Create an OS company (name + idea). Alias: create_company. For an existing project, set origin=imported and optionally pass domain / token_address + token_ticker. Name is permanent. The first company is free; a second requires an OS seat (start_os_seat_checkout for cards, or buy_os_seat for $20 USDC from the wallet). After create, call list_os_tasks then run_os_task, then open_os_builder / prompt_os_builder (or publish_os_website) to build a landing page through OpenCode and get a preview_url in this thread.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Start Stripe Checkout for the $20/month OS seat (card). Returns a url for a human. Agents paying from a wallet should call buy_os_seat instead. First company does not need this.

Input schema

{schema_json(tool)}

Open the Stripe Customer Portal (update card, cancel, invoices). Returns a url. Requires an existing Stripe customer on this account.

Input schema

{schema_json(tool)}

Pay the $20 OS extra-company seat in USDC from the operator wallet (send scope). Sends to the platform treasury and grants 30 days. Call again to stack another month. Refuses when a Stripe seat is already current. First company does not need this. Alias: subscribe_os.

Input schema

{schema_json(tool)}

Update mutable company fields. Name cannot change; only description.

Input schema

{schema_json(tool)}

Search Cloudflare Registrar for buyable domains. Prices in the result are the customer USDC charge (markup over list price).

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Buy a domain for a company. Charges 2× Cloudflare list price in USDC from Master Treasury, then registers it. Requires the send scope. Only purchased domains can mint company email.

Input schema

{schema_json(tool)}

Attach a hostname the company already owns (BYO / import). We do not control DNS, so company email cannot be minted on an attached domain.

Input schema

{schema_json(tool)}

Company inbox status and the one-time USDC price. After provision, send/read mail with the Coms email tools and inbox=<address>.

Input schema

{schema_json(tool)}

Mint local@purchased-domain. Charges the one-time USDC fee from Master Treasury (send scope), publishes MX, and creates the AgentMail inbox. Requires a ClawBank-purchased domain — attached/BYO domains are refused.

Input schema

{schema_json(tool)}

Live snapshot for a Base token address (ticker, mcap, volume, Bankr, fees). Does not persist anything.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Create or resume Stripe Connect onboarding. Returns a one-time Account Link URL the operator must open. Needs a public business URL (purchased domain + deploy, or an attached/imported domain).

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Create a Product + Price + Payment Link on the connected Stripe account. Payments must already be active.

Input schema

{schema_json(tool)}

House-owned Meta ad account status. Refreshes Meta review on the ad id (never act_*). meta_ads_status rejected + meta_ads_last_error means Meta stopped the ad — edit the creative and start_os_ads_campaign again. effective_status is Meta's flag (ACTIVE, PENDING_REVIEW, DISAPPROVED). delivering is true only when we are live and Meta is actually serving.

Input schema

{schema_json(tool)}

Attach the house Meta ad account (or mint one if META_HOUSE_AD_ACCOUNT_ID is unset). Does not start spend.

Input schema

{schema_json(tool)}

Create a paused $5/day Meta ad (campaign + ad set + creative + ad). Needs a destination URL and a saved HQ creative. After a Meta rejection, call this again to post a replacement ad (same campaign). Nothing delivers until go_live_os_ads.

Input schema

{schema_json(tool)}

Unpause the company's Meta campaign, ad set, and ad. Starts spend. Requires remaining prepaid ads credit. Refuses ads_rejected when Meta has disapproved the current ad — post a replacement first.

Input schema

{schema_json(tool)}

Pause the company's Meta campaign, ad set, and ad. Stops spend.

Input schema

{schema_json(tool)}

Buy prepaid ads credit ($5, $20, or $50) in USDC from the founder's wallet. ClawBank pays Meta; the founder never opens Ads Manager.

Input schema

{schema_json(tool)}

Pin a formed legal entity (Formation business_id) to this company. Several companies may share one entity. Cancelled/dissolved filings cannot attach.

Input schema

{schema_json(tool)}

Opening HQ tasks (Mission, ICP, Market Research, Go To Market, Offer & Pricing). Same questionnaire a human sees. Alias: list_tasks. Run one with run_os_task.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Fill the linked strategy doc via Manfred (same Venice path as HQ). Pass choice (one of the task options) and optional notes, or best_judgment=true plus notes. `other` is an alias for notes. Imported companies with an attached domain also get a homepage snapshot (Market Research also reads /pricing and /about, and runs Venice web search). Alias: run_task. Returns the written markdown.

Input schema

{schema_json(tool)}

Open the company Builder workbench (Sprite + OpenCode session). Returns preview_url — send that link back so the operator can look. Then prompt_os_builder to change the page.

Input schema

{schema_json(tool)}

One OpenCode Builder chat turn (same harness as HQ). Returns preview_url + assistant text. Iterate: 'make the CTA bigger', 'I like that — add pricing'. Real inference, not a template. If turn_status is running, poll get_os_builder.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Build a first landing page through OpenCode (same as HQ Builder chat) and return preview_url. Does not stamp a template. Does not deploy to Cloudflare — call deploy_os_website when the operator likes it.

Input schema

{schema_json(tool)}

Deploy the current Builder website (OpenCode/sprite files) to Cloudflare. Returns the live url. Call after the operator accepts the preview.

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Alias of create_os_company. Same arguments (name, description, origin, …).

Input schema

{schema_json(tool)}

Input schema

{schema_json(tool)}

Alias of run_os_task. Same arguments.

Input schema

{schema_json(tool)}