agent-exec

Accountless pay-per-use code execution, storage, locks and x402 USDC utilities.

Should I use this

Quality & Safety

A
Description quality
96%
Schema completeness
88%
Naming quality
85%
Poisoning risk
100%
Permission match
90%
Protocol compliance
100%

Findings (1)

  • LOWTool 'check_url' suggests web access but openWorldHint=falsein check_url

Based on automated analysis of tool definitions and protocol compliance.

Context Cost

~9,999Tokens (tool definitions)
~2.2 KBTypical response size
Significant attention impact (7.81% of 128k context)

This is the approximate number of tokens consumed each time the server's tools are loaded into a model's context. Higher counts reduce the attention available for other tasks.

Install

One-Click Install

Add this to your `claude_desktop_config.json` file:

{
  "mcpServers": {
    "agent-exec": {
      "url": "https://agent-exec.448c.org/mcp"
    }
  }
}

Remote endpoints

https://agent-exec.448c.org/mcpstreamable-http

What it can do

Tool inventory

Tools (30)

🟢 Read-only🟡 Write🔴 Delete⚪ Unknown
🟢service_card

FREE: what agent-exec sells, each price, and how to pay (x402, USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer, no account). Moves no money. Feedback: POST /feedback (free). Read daily; no individual reply.

Input Schema

{
  "type": "object",
  "properties": {},
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Output Schema

{
  "type": "object",
  "properties": {
    "service": {
      "type": "string"
    },
    "description": {
      "type": "string"
    },
    "network": {
      "type": "string"
    },
    "execute": {
      "type": "object",
      "properties": {
        "endpoint": {
          "type": "string"
        },
        "method": {
          "type": "string"
        },
        "priceUsd": {
          "type": "number"
        },
        "note": {
          "type": "string"
        }
      },
      "required": [
        "endpoint",
        "method",
        "priceUsd",
        "note"
      ],
      "additionalProperties": false
    },
    "quote": {
      "type": "object",
      "properties": {
        "endpoint": {
          "type": "string"
        },
        "method": {
          "type": "string"
        },
        "free": {
          "type": "boolean"
        }
      },
      "required": [
        "endpoint",
        "method",
        "free"
      ],
      "additionalProperties": false
    },
    "directory": {
      "type": "object",
      "properties": {
        "listEndpoint": {
          "type": "string"
        },
        "listingIsFree": {
          "type": "boolean"
        },
        "paidPlacement": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "duration": {
                "type": "string"
              },
              "priceUsd": {
                "type": "number"
              }
            },
            "required": [
              "duration",
              "priceUsd"
            ],
            "additionalProperties": false
          }
        },
        "promoteEndpoint": {
          "type": "string"
        }
      },
      "required": [
        "listEndpoint",
        "listingIsFree",
        "paidPlacement",
        "promoteEndpoint"
      ],
      "additionalProperties": false
    },
    "resources": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "resource": {
            "type": "string"
          },
          "method": {
            "type": "string"
          },
          "free": {
            "type": "boolean"
          },
          "price": {
            "type": [
              "string",
              "null"
            ]
          },
          "description": {
            "type": "string"
          },
          "pricing": {}
        },
        "required": [
          "resource",
          "method",
          "free",
          "price",
          "description"
        ],
        "additionalProperties": false
      }
    },
    "payment": {
      "type": "object",
      "properties": {
        "protocol": {
          "type": "string"
        },
        "transport": {
          "type": "string"
        },
        "manifest": {
          "type": "string"
        },
        "howToPay": {
          "type": "string"
        },
        "rule": {
          "type": "string"
        },
        "identity": {
          "type": "string"
        }
      },
      "required": [
        "protocol",
        "transport",
        "manifest",
        "howToPay",
        "rule",
        "identity"
      ],
      "additionalProperties": false
    },
    "openapi": {
      "type": "string"
    },
    "llmsTxt": {
      "type": "string"
    },
    "feedback": {
      "type": "string"
    }
  },
  "required": [
    "service",
    "description",
    "network",
    "execute",
    "quote",
    "directory",
    "resources",
    "payment",
    "openapi",
    "llmsTxt",
    "feedback"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟡execute(runtime, source, stdin, limits, files)

PAID: run Python or JavaScript code (python3, node) in an isolated, network-less sandbox; returns stdout, stderr and exit code. Price scales with limits. Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply.

Input Schema

{
  "type": "object",
  "properties": {
    "runtime": {
      "type": "string",
      "description": "One of python3, node."
    },
    "source": {
      "type": "string",
      "description": "The program to run."
    },
    "stdin": {
      "type": "string",
      "description": "Optional standard input."
    },
    "limits": {
      "type": "object",
      "additionalProperties": {},
      "description": "Optional limits (timeoutMs, memoryMb, ...); they set the price."
    },
    "files": {
      "type": "array",
      "items": {},
      "description": "Optional extra files, as POST /execute takes them."
    }
  },
  "required": [
    "runtime",
    "source"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟢weather_forecast(lat, lon)

PAID: current conditions plus the next 12 hourly steps for one point, for $0.0100. Coordinates only, no place names; data from MET Norway (api.met.no), attribution rides in the answer. Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply.

Input Schema

{
  "type": "object",
  "properties": {
    "lat": {
      "type": "number",
      "description": "Latitude in decimal degrees, -90..90, e.g. 59.9127."
    },
    "lon": {
      "type": "number",
      "description": "Longitude in decimal degrees, -180..180, e.g. 10.7461."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟡settle_payment(paymentPayload, paymentRequirements)

PAID: send the {paymentPayload, paymentRequirements} pair our free POST /verify takes and we broadcast the USDC transfer your payer signed to YOUR payTo out of our gas float, for $0.0200 a call whatever the amount settled. Scheme exact, USDC on Base, Base Sepolia and Solana. No facilitator or gas of your own. No transfer, no sale: the fee is held as one prepaid call. Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply.

Input Schema

{
  "type": "object",
  "properties": {
    "paymentPayload": {
      "type": "object",
      "additionalProperties": {},
      "description": "The signed x402 payload your payer produced, decoded, as it would ride in their X-PAYMENT header."
    },
    "paymentRequirements": {
      "type": "object",
      "additionalProperties": {},
      "description": "The requirements it was signed against: scheme, network, maxAmountRequired, payTo, asset, each a string."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟢scrape_page(url, maxChars)

PAID: scrape a web page: readable text, title, links and meta for $0.0100. We fetch it (public URLs, up to 2000000 bytes). Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply.

Input Schema

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "description": "The absolute http(s) URL of the page, e.g. https://example.com/."
    },
    "maxChars": {
      "type": "integer",
      "description": "Lower the text cap: 1..40000. Omitted means 40000."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟢doc_text(url, maxPages)

PAID: extract text from a PDF, page by page (up to 20 pages), for $0.0100. We fetch it; no OCR. Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply.

Input Schema

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "description": "The absolute http(s) URL of the PDF, e.g. https://arxiv.org/pdf/1706.03762v7."
    },
    "maxPages": {
      "type": "integer",
      "description": "Return at most this many pages: 1..20. Omitted means 20."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟡infer_chat(model, messages, max_tokens, temperature)

PAID: LLM chat completion for $0.0100, no account or model key: send messages, get {model, content, finish_reason, usage}. Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply.

Input Schema

{
  "type": "object",
  "properties": {
    "model": {
      "type": "string",
      "description": "The tier to buy: fast. Omitted means fast."
    },
    "messages": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "role": {
            "type": "string",
            "enum": [
              "system",
              "user",
              "assistant"
            ]
          },
          "content": {
            "type": "string"
          }
        },
        "required": [
          "role",
          "content"
        ],
        "additionalProperties": false
      },
      "description": "1..32 chat messages summing to at most 8000 chars, e.g. [{\"role\":\"system\",\"content\":\"You are terse. Answer in one sentence.\"},{\"role\":\"user\",\"content\":\"What is the capital of Japan?\"}]."
    },
    "max_tokens": {
      "type": "integer",
      "description": "Ceiling on the answer, 1..2048. Omitted means 1024."
    },
    "temperature": {
      "type": "number",
      "description": "Sampling temperature, 0..2. Omitted means 1."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟡storage_buy(plan, contentBase64, label)

PAID: store a file (bytes as base64) for the plan term; the paying wallet owns it. Returns its id and expiry. Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply. Price: from $0.0100 USDC.

Input Schema

{
  "type": "object",
  "properties": {
    "plan": {
      "type": "string",
      "enum": [
        "small",
        "medium",
        "large"
      ],
      "description": "Storage plan; it sets both the size limit and the price. See GET /pricing or the service_card tool for the live table."
    },
    "contentBase64": {
      "type": "string",
      "description": "The bytes to store, base64-encoded. Decoded size must fit the plan."
    },
    "label": {
      "type": "string",
      "description": "Optional caller-chosen label, up to 256 characters, no control characters."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟡storage_renew(id, plan)

PAID: extend a stored file you own by another plan term; same id, contents untouched. Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply. Price: from $0.0100 USDC.

Input Schema

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "description": "The object id returned when it was bought."
    },
    "plan": {
      "type": "string",
      "enum": [
        "small",
        "medium",
        "large"
      ],
      "description": "Storage plan; it sets both the size limit and the price. See GET /pricing or the service_card tool for the live table."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🔴storage_replace(id, plan, contentBase64, label)

PAID: replace the contents of a stored file you own, keeping its id, with a fresh plan term. Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply. Price: from $0.0100 USDC.

Input Schema

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "description": "The object id returned when it was bought."
    },
    "plan": {
      "type": "string",
      "enum": [
        "small",
        "medium",
        "large"
      ],
      "description": "Storage plan; it sets both the size limit and the price. See GET /pricing or the service_card tool for the live table."
    },
    "contentBase64": {
      "type": "string",
      "description": "The replacement bytes, base64-encoded. Decoded size must fit the plan."
    },
    "label": {
      "type": "string",
      "description": "Optional caller-chosen label, up to 256 characters, no control characters."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟡create_inbox(id)

PAID: disposable email inbox for 24 h, receive only, for verification mail; codes and links are extracted. Pay again with its id to extend. Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply. Price: $0.0200 USDC.

Input Schema

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "description": "An inbox id this same wallet already owns: extends it 24 h from its current expiry instead of issuing a new address. Omit for a new address."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟡dns_rent(label, records, dryRun)

PAID: rent a DNS name, <label>.448c.net, for a year with A/AAAA/CNAME/TXT records; the paying wallet owns it. Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply. Price: $0.5000 USDC.

Input Schema

{
  "type": "object",
  "properties": {
    "label": {
      "type": "string",
      "description": "The label to rent, without the zone: it becomes <label>.448c.net. Lowercase letters, digits and hyphens; some labels are ours and refused."
    },
    "records": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "type": {
            "type": "string",
            "description": "A, AAAA, CNAME or TXT. TXT is how you pass a DNS-01 certificate challenge."
          },
          "value": {
            "type": "string",
            "description": "The record value: an address, a hostname, or the TXT string."
          },
          "ttl": {
            "type": "integer",
            "description": "Seconds, within the range the route states in details.expected."
          }
        },
        "required": [
          "type",
          "value",
          "ttl"
        ],
        "additionalProperties": false
      },
      "description": "What the name resolves to. The route states the record and TTL limits in details.expected on any refusal."
    },
    "dryRun": {
      "type": "boolean",
      "description": "Optional. true: a dry run -- nothing is sent or changed, and the 200 answer (served:true, dryRun:true) says what this call would do with the rest of your body, or which fields are missing. A dry run is a paid call at this price. false or absent: the call runs."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟡dns_renew(name)

PAID: extend a DNS name you own by a year. Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply. Price: $0.5000 USDC.

Input Schema

{
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "description": "The full rented name, as returned when it was rented, e.g. example.448c.net."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟡check_address(address, chain)

PAID: check a wallet address (EVM) against public risk feeds (OFAC, darklists, on-chain age): verdict, score, reasons. Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply. Price: $0.0100 USDC.

Input Schema

{
  "type": "object",
  "properties": {
    "address": {
      "type": "string",
      "minLength": 1,
      "maxLength": 256,
      "description": "An EVM 0x... address."
    },
    "chain": {
      "type": "string",
      "minLength": 1,
      "maxLength": 64,
      "description": "\"base\" or \"ethereum\", default \"base\"."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟡check_url(url)

PAID: check a URL against public risk feeds (phishing lists, domain age, lexical signals): verdict, score, reasons. Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply. Price: $0.0100 USDC.

Input Schema

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "minLength": 1,
      "maxLength": 2048,
      "description": "An http(s) URL or bare domain, at most 2048 UTF-8 bytes."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟡check_counterparty(quote, claim)

PAID: check an x402 quote before you pay it: payee, resource, network, asset and price graded against what you expected. Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply. Price: $0.0100 USDC.

Input Schema

{
  "type": "object",
  "properties": {
    "quote": {
      "type": "object",
      "properties": {
        "scheme": {
          "type": "string",
          "maxLength": 2048
        },
        "network": {
          "type": "string",
          "maxLength": 2048
        },
        "payTo": {
          "type": "string",
          "maxLength": 2048
        },
        "asset": {
          "type": "string",
          "maxLength": 2048
        },
        "maxAmountRequired": {
          "type": "string",
          "maxLength": 2048
        },
        "resource": {
          "type": "string",
          "maxLength": 2048
        }
      },
      "additionalProperties": false,
      "description": "One accepts[] entry out of the 402 you received, verbatim. Every field optional: an absent one is a finding."
    },
    "claim": {
      "type": "object",
      "properties": {
        "requestedUrl": {
          "type": "string",
          "minLength": 1,
          "maxLength": 2048
        },
        "expectedPayTo": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128
        },
        "expectedNetwork": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128
        },
        "expectedAsset": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128
        },
        "maxAmountAtomic": {
          "type": "string",
          "minLength": 1,
          "maxLength": 128
        },
        "payToReputation": {
          "type": "object",
          "additionalProperties": {}
        }
      },
      "required": [
        "requestedUrl"
      ],
      "additionalProperties": false,
      "description": "What you believed before you asked: the URL you requested, and optionally the payee, network, asset and ceiling you agreed to."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟡rpc_call(chain, method, params, id)

PAID: one blockchain JSON-RPC call on base, base-sepolia, ethereum, solana for $0.0100, no provider account: you name chain and method, we pick the node. Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply.

Input Schema

{
  "type": "object",
  "properties": {
    "chain": {
      "type": "string",
      "description": "Which chain to ask: one of base, base-sepolia, ethereum, solana. You never name a URL -- we pick the endpoint, e.g. base."
    },
    "method": {
      "type": "string",
      "description": "The JSON-RPC method, e.g. eth_blockNumber. Reads, fee queries and raw-transaction broadcast only: 19 EVM methods, 14 Solana. Anything else is refused."
    },
    "params": {
      "type": "array",
      "items": {},
      "description": "The method's params, as the node takes them; at most 8192 serialized bytes. Omit for a method that takes none."
    },
    "id": {
      "description": "Your own call id, echoed back: a string of at most 64 chars or a safe integer. Omitted means we supply one."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟡relay_usdc(from, to, value, validAfter, validBefore, ...)

PAID: send USDC without gas: you sign an EIP-3009 transfer, we broadcast it on Base with our ETH. $0.0200 an order, at most $100. Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply.

Input Schema

{
  "type": "object",
  "properties": {
    "from": {
      "type": "string",
      "description": "The USDC holder who signed. The signature must recover to exactly this address, e.g. 0x2222222222222222222222222222222222222222."
    },
    "to": {
      "type": "string",
      "description": "Recipient of the USDC. Must differ from `from`."
    },
    "value": {
      "type": "string",
      "description": "Atomic USDC (6 decimals) as a decimal string, 1..100000000 ($100 ceiling an order)."
    },
    "validAfter": {
      "type": "string",
      "description": "Unix seconds, as a string; must already have passed."
    },
    "validBefore": {
      "type": "string",
      "description": "Unix seconds, as a string; at least 30s out, so the broadcast lands inside your window."
    },
    "nonce": {
      "type": "string",
      "description": "32 bytes of hex, unused before: USDC itself rejects a reused one, so each order needs its own."
    },
    "signature": {
      "type": "string",
      "description": "Your EIP-712 TransferWithAuthorization signature over chainId 8453, verifyingContract 0x833589fcd6edb6e08f4c7c32d4f71b54bda02913 (Base USDC). A refusal returns details.expected with the exact struct and domain."
    },
    "dryRun": {
      "type": "boolean",
      "description": "Optional. true: a dry run -- nothing is sent or changed, and the 200 answer (served:true, dryRun:true) says what this call would do with the rest of your body, or which fields are missing. A dry run is a paid call at this price. false or absent: the call runs."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟡relay_permit(owner, spender, value, nonce, deadline, ...)

PAID: approve a USDC spender without gas: you sign an EIP-2612 Permit, we broadcast it on Base. $0.0200 an approval, at most $100. Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply.

Input Schema

{
  "type": "object",
  "properties": {
    "owner": {
      "type": "string",
      "description": "The USDC holder who signed, e.g. 0x2222222222222222222222222222222222222222. Needs no ETH."
    },
    "spender": {
      "type": "string",
      "description": "The contract or wallet approved to pull USDC. Must differ from owner."
    },
    "value": {
      "type": "string",
      "description": "Atomic USDC (6 decimals) as a decimal string, 0..100000000 ($100 ceiling). 0 revokes."
    },
    "nonce": {
      "type": "string",
      "description": "The owner's current USDC nonces(owner), as a decimal string."
    },
    "deadline": {
      "type": "string",
      "description": "Unix seconds, as a string; at least 30s out."
    },
    "signature": {
      "type": "string",
      "description": "Your EIP-712 Permit signature over chainId 8453, verifyingContract 0x833589fcd6edb6e08f4c7c32d4f71b54bda02913 (Base USDC)."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟢flights_lookup(ident)

PAID: look up a flight: where an aircraft is now (position, altitude, speed, track) by callsign, ICAO24 hex or tail number, $0.0100. Data: adsb.lol community ADS-B feed, ODbL 1.0. Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply.

Input Schema

{
  "type": "object",
  "properties": {
    "ident": {
      "type": "string",
      "minLength": 1,
      "maxLength": 32,
      "description": "One aircraft identifier: a callsign (UAL1), a 6-hex ICAO24 address (a0b1c2) or a registration (N12345, D-ABCD). Prefix cs:, hex: or reg: to say which kind it is -- unprefixed, a 6-hex-looking string is read as a CALLSIGN. Lowercase is fine."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟡listing_promote(id, duration, dryRun)

PAID: promote a directory listing you own above free rows for the plan term; paying again extends. Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply. Price: from $0.0667 USDC.

Input Schema

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "minLength": 1,
      "maxLength": 256,
      "description": "The listing to promote. It must already exist and be owned by the paying wallet -- create it free with POST /listings."
    },
    "duration": {
      "type": "string",
      "enum": [
        "day",
        "week",
        "month"
      ],
      "description": "Which placement plan to buy; it sets both the placement window and the price. See GET /pricing or the service_card tool for the live table."
    },
    "dryRun": {
      "type": "boolean",
      "description": "Optional. true: a dry run -- nothing is sent or changed, and the 200 answer (served:true, dryRun:true) says what this call would do with the rest of your body, or which fields are missing. A dry run is a paid call at this price. false or absent: the call runs."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟡drift_check(venue)

PAID: detect API drift: we re-fetch a venue we snapshot and diff it against our baseline (fields added, removed, moved). Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply. Price: $0.0100 USDC.

Input Schema

{
  "type": "object",
  "properties": {
    "venue": {
      "type": "string",
      "minLength": 1,
      "maxLength": 256,
      "description": "A venue id we hold a baseline snapshot for; list them free with drift_venues. A venue we have never snapshotted is refused (404)."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟡watch_register(url, intervalSeconds, ttlSeconds, predicate, storageKey)

PAID: watch a URL until a condition fires (status, body text, JSON path, any change) or the TTL ends; priced by interval x TTL. Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply. Price: $0.0100 USDC.

Input Schema

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "minLength": 1,
      "maxLength": 2048,
      "description": "Absolute http:// or https:// URL, at most 2048 UTF-8 bytes. We GET it; the body is never returned to you, only the verdict."
    },
    "intervalSeconds": {
      "type": "integer",
      "description": "Seconds between polls, 60..86400. Shorter costs more."
    },
    "ttlSeconds": {
      "type": "integer",
      "description": "How long to keep watching, 60..604800. Must exceed intervalSeconds, or the watch expires before a second sample exists."
    },
    "predicate": {
      "type": "object",
      "properties": {
        "type": {
          "type": "string",
          "enum": [
            "statusChanged",
            "statusEquals",
            "bodyContains",
            "bodyNotContains",
            "jsonPathEquals",
            "jsonPathNotEquals",
            "changedFromNow"
          ],
          "description": "What counts as a match. The remaining fields are the ones this type needs; the route refuses, naming any that is missing."
        },
        "status": {
          "type": "integer",
          "minimum": 100,
          "maximum": 599,
          "description": "statusEquals: the HTTP status that fires the watch."
        },
        "value": {
          "type": [
            "string",
            "number",
            "boolean",
            "null"
          ],
          "description": "bodyContains/bodyNotContains: a substring of at most 500 characters. jsonPathEquals/jsonPathNotEquals: the scalar the path must (not) equal."
        },
        "path": {
          "type": "string",
          "description": "jsonPathEquals/jsonPathNotEquals (required) and changedFromNow (optional): a dotted path into the JSON body, e.g. \"data.price\"."
        }
      },
      "required": [
        "type"
      ],
      "additionalProperties": false,
      "description": "The condition that ends the watch."
    },
    "storageKey": {
      "type": "string",
      "description": "Optional: on a match, the result is also written to /storage under this key for the paying wallet, so a successor process can collect it without knowing the watch id."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟡claim_acquire(key, holder, plan)

PAID: lock a key for your own fleet (accountless compare-and-set lease). outcome "acquired": yours; "held": taken, held.mine says if by you. Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply. Price: from $0.0100 USDC.

Input Schema

{
  "type": "object",
  "properties": {
    "key": {
      "type": "string",
      "minLength": 1,
      "maxLength": 256,
      "description": "1..256 UTF-8 bytes, no '/' character -- the name you want to hold, scoped to your own wallet."
    },
    "holder": {
      "type": "string",
      "minLength": 1,
      "maxLength": 256,
      "description": "1..256 UTF-8 bytes -- an id identifying which of your own processes is acting. It is not signed; the signature proves the wallet, not the process."
    },
    "plan": {
      "type": "string",
      "enum": [
        "hour",
        "day",
        "week"
      ],
      "description": "Which plan to buy; it sets both the hold duration and the price. See GET /pricing or the service_card tool for the live table."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟡claim_renew(key, holder, plan)

PAID: extend a key lock you hold, keeping it. Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply. Price: from $0.0100 USDC.

Input Schema

{
  "type": "object",
  "properties": {
    "key": {
      "type": "string",
      "minLength": 1,
      "maxLength": 256,
      "description": "1..256 UTF-8 bytes, no '/' character -- the name you want to hold, scoped to your own wallet."
    },
    "holder": {
      "type": "string",
      "minLength": 1,
      "maxLength": 256,
      "description": "1..256 UTF-8 bytes -- an id identifying which of your own processes is acting. It is not signed; the signature proves the wallet, not the process."
    },
    "plan": {
      "type": "string",
      "enum": [
        "hour",
        "day",
        "week"
      ],
      "description": "Which plan to buy; it sets both the hold duration and the price. See GET /pricing or the service_card tool for the live table."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟡attest_create(url)

PAID: attest a URL: we fetch it and sign what we saw (hash, status, headers, never the body), timestamped. A failed fetch is still an observation. Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply. Price: $0.0100 USDC.

Input Schema

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "minLength": 1,
      "maxLength": 2048,
      "description": "An absolute http:// or https:// URL, at most 2048 UTF-8 bytes. The body is never returned to you."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟡handoff_deposit(done, notDone, inFlight, pickUpFirst)

PAID: hand off context to a successor process: a typed briefing (done with evidence, not done, in flight, next). Anyone with the id reads it; kept 3 days. Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply. Price: $0.0100 USDC.

Input Schema

{
  "type": "object",
  "properties": {
    "done": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "text": {
            "type": "string",
            "minLength": 1,
            "maxLength": 1000,
            "description": "The claim itself, one statement."
          },
          "confidence": {
            "type": "string",
            "enum": [
              "measured",
              "unverified"
            ],
            "description": "'measured' means you verified it and evidence says how; 'unverified' means you did not, and evidence MUST then be null."
          },
          "evidence": {
            "anyOf": [
              {
                "type": "string",
                "maxLength": 1000
              },
              {
                "type": "null"
              }
            ],
            "description": "How it was verified -- a command, a probe result, a file read; the evidence itself, not a restatement of text. Non-null exactly when confidence is measured."
          }
        },
        "required": [
          "text",
          "confidence",
          "evidence"
        ],
        "additionalProperties": false,
        "description": "One claim: what, how sure, and the proof."
      },
      "maxItems": 100,
      "description": "What is DONE. EVERY entry must have confidence 'measured' with non-null evidence; otherwise this is refused, free, as HANDOFF_DONE_REQUIRES_MEASURED."
    },
    "notDone": {
      "type": "array",
      "items": {
        "$ref": "#/properties/done/items"
      },
      "maxItems": 100,
      "description": "What is NOT done. May be measured or unverified."
    },
    "inFlight": {
      "type": "array",
      "items": {
        "$ref": "#/properties/done/items"
      },
      "maxItems": 100,
      "description": "What was IN FLIGHT at the cut -- neither finished nor abandoned."
    },
    "pickUpFirst": {
      "type": "string",
      "minLength": 1,
      "maxLength": 2000,
      "description": "What the successor should do FIRST. Mandatory and non-empty: a briefing with no next action is not a handoff."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟡deadman_register(description, leaseSeconds, probe)

PAID: dead-man switch for an irreversible action: register the intent, a lease and a probe; confirm in time or we run the probe and publish the verdict. Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply. Price: $0.0100 USDC.

Input Schema

{
  "type": "object",
  "properties": {
    "description": {
      "type": "string",
      "minLength": 1,
      "maxLength": 500,
      "description": "What you are about to do."
    },
    "leaseSeconds": {
      "type": "number",
      "minimum": 1,
      "maximum": 604800,
      "description": "How long before an unconfirmed entry's probe runs. 1..604800 seconds."
    },
    "probe": {
      "type": "object",
      "properties": {
        "url": {
          "type": "string",
          "maxLength": 2048,
          "description": "Absolute http:// or https:// URL, GETted from OUR vantage point once the lease expires."
        },
        "expectedBodyContains": {
          "type": "string",
          "minLength": 1,
          "maxLength": 500,
          "description": "The response body must contain this substring for the verdict to be confirmed-by-probe."
        },
        "expectedStatus": {
          "type": "integer",
          "minimum": 100,
          "maximum": 599,
          "description": "The response status must equal this for the verdict to be confirmed-by-probe."
        }
      },
      "required": [
        "url"
      ],
      "additionalProperties": false,
      "description": "At least one of expectedBodyContains / expectedStatus is required."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟡pay_send(sellerUrl, method, headers, body, authorization, ...)

PAID: deliver an x402 payment you signed to a seller exactly once, verify it on chain, and get a receipt of what the seller answered. Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply. Price: $0.0200 USDC.

Input Schema

{
  "type": "object",
  "properties": {
    "sellerUrl": {
      "type": "string",
      "minLength": 1,
      "maxLength": 2048,
      "description": "The seller endpoint to deliver the authorization to, an absolute http:// or https:// URL."
    },
    "method": {
      "type": "string",
      "minLength": 1,
      "maxLength": 16,
      "description": "GET, POST, PUT, PATCH or DELETE."
    },
    "headers": {
      "type": "object",
      "additionalProperties": {
        "type": "string"
      },
      "description": "Optional request headers for the seller, at most 20."
    },
    "body": {
      "type": "string",
      "description": "Optional request body for the seller."
    },
    "authorization": {
      "type": "object",
      "properties": {
        "headerName": {
          "type": "string",
          "enum": [
            "X-PAYMENT",
            "PAYMENT-SIGNATURE"
          ],
          "description": "X-PAYMENT for a v1 challenge, PAYMENT-SIGNATURE for a v2 one."
        },
        "header": {
          "type": "string",
          "minLength": 1,
          "description": "Base64 of the signed x402 PaymentPayload YOU produced for the seller."
        },
        "asset": {
          "type": "string",
          "minLength": 1,
          "description": "The token contract address that authorization was signed against."
        }
      },
      "required": [
        "headerName",
        "header",
        "asset"
      ],
      "additionalProperties": false,
      "description": "The authorization you already signed for the seller. This is NOT the payment that pays us -- that one goes in _meta."
    },
    "dryRun": {
      "type": "boolean",
      "description": "Optional. true: a dry run -- nothing is sent or changed, and the 200 answer (served:true, dryRun:true) says what this call would do with the rest of your body, or which fields are missing. A dry run is a paid call at this price. false or absent: the call runs."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
🟡placement_order(url, id, dryRun)

PAID: list your service on agent venues: we submit it to each venue we have a submitter for (17 of 33 today) and prove each entry landed, weekly for 90 days. Unpaid, it returns the price; pay with x402 (USDC on Base, Solana, Polygon, Arbitrum, Avalanche, Sei or X Layer) in _meta['x402/payment'] and call again. Feedback: POST /feedback (free). Read daily; no individual reply. Price: $0.2500 USDC.

Input Schema

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "description": "The absolute http(s) URL of YOUR service -- the one a venue should list. It must be publicly reachable: a loopback or private address is one no venue can verify."
    },
    "id": {
      "type": "string",
      "description": "The order id, as returned when it was paid for."
    },
    "dryRun": {
      "type": "boolean",
      "description": "Optional. true: a dry run -- nothing is sent or changed, and the 200 answer (served:true, dryRun:true) says what this call would do with the rest of your body, or which fields are missing. A dry run is a paid call at this price. false or absent: the call runs."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Community

Rate this Server

Evidence

Recent observations

verifiedversion not recorded30 tools