← The evidence ledger
Evidence row 515472
Observed , by probe.mcp/1.
- Kind
- mcp.tools
- About
- endpoint f7557db7-0551-44cc-a336-639524773953
- Recorded
- Previous row
- None: the first of its kind about this subject
- Body SHA-256
- 9f30b152fbc5e5a962713d9bb783ae93c2ca8f12861f285cb8160c093b6038ba
- Leaf
- 0x0e9a51998bf21ffb524a492cff735e900a1ce1151e7d59aa1cac2755d6bb5fbe
What was observed
{
"count": 34,
"tools": [
{
"description": "Every fix from your Audit's drive, in order: what it is, why, how, its effort and team, the level the fixes up to it reach, its state (open, fixed, as_is or doesnt_apply with your reason) and what the drives found (result done or still_there; new_since for a fix a later drive found). It comes with the Audit's report. Also the Audit's drives (its first drive and each new drive after fixes, with the level it reached and its report) and redrive (whether one can start now and why not, until when). The list is yours to work through: it never moves your level; a new drive does (followup_drive).",
"inputSchema": {
"properties": {
"order_id": {
"description": "Your Audit's order id, from my_orders",
"type": "string"
}
},
"required": [
"order_id"
],
"type": "object"
},
"name": "audit_fixes"
},
{
"description": "Your prepaid credit for paid calls (top_up): the balance, the calls it pays, when it expires, each top-up with its receipt, and the history (calls by day, refunds, expiry). Needs your API key.",
"inputSchema": {
"properties": {},
"type": "object"
},
"name": "balance"
},
{
"description": "A support case's state: open, waiting (an answer is on its way), answered (with the answer) or closed; the next step; a dispute's re-drive (queued, running, done). The key of the case's account, or the case_token support_ask gave without a key.",
"inputSchema": {
"properties": {
"case_id": {
"description": "The case's id, from support_ask or dispute_result",
"type": "string"
},
"case_token": {
"description": "Without a key: the token support_ask returned with the case",
"type": "string"
}
},
"required": [
"case_id"
],
"type": "object"
},
"name": "case_status"
},
{
"description": "Step 1 of 3 (claim, verify, order): adds your product's domain. An account email on the domain (or a subdomain or parent of it) verifies it at once, unless the domain is one where anyone can get an address (a mailbox provider's, or ours: agentdrives.com) and queues its free check (private); pending then says why your address didn't. Otherwise it returns the ways to prove it: a code mailed to any address at the domain, a DNS TXT record, a meta tag on the home page or a file at /.well-known/agentdrive-verify.txt (the code: send_claim_code).",
"inputSchema": {
"properties": {
"domain": {
"description": "Your product's domain, e.g. acme.com",
"type": "string"
},
"tool": {
"description": "Directory slug, if listed",
"type": "string"
}
},
"required": [
"domain"
],
"type": "object"
},
"name": "claim_domain"
},
{
"description": "Your product's place in our directory while its Audit runs (a verified claim): listed true shows it as In Audit, false keeps it private until it is Audited. The answer's directory says where it stands: audited, in_audit, hidden, lapsed or none. whoami shows each claim's directory.",
"inputSchema": {
"properties": {
"claim_id": {
"description": "The claim's id, from whoami",
"type": "string"
},
"listed": {
"description": "true: show it as In Audit; false: keep it private until it is Audited",
"type": "boolean"
}
},
"required": [
"claim_id",
"listed"
],
"type": "object"
},
"name": "directory_listing"
},
{
"description": "Disputes the published result of your own product (an API key with a verified claim on its domain; else 403 claim_not_verified), at one checkpoint (docs, signup, verify, credentials, first_call, first_action, pay, cancel, delete), with what is true. A case opens; while no dispute re-drive of the product ran in the last 30 days, a confirm re-drive of the agent's path is queued at once (its result shows on the listing once reviewed). Returns case_id, the re-drive's state and the next step. The answer comes in writing, in case_status.",
"inputSchema": {
"properties": {
"checkpoint": {
"enum": [
"docs",
"signup",
"verify",
"credentials",
"first_call",
"first_action",
"pay",
"cancel",
"delete"
]
},
"claim": {
"description": "What is true, in plain words (up to 2,000 characters)",
"type": "string"
},
"evidence_url": {
"description": "Optional: a public page that shows it (kept on the case; we never fetch it automatically)",
"type": "string"
},
"product": {
"description": "Your product's domain or directory slug",
"type": "string"
}
},
"required": [
"product",
"checkpoint",
"claim"
],
"type": "object"
},
"name": "dispute_result"
},
{
"description": "Your own product's latest drive in full: every attempt with its time on the drive's clock, route, result and evidence, the fixes, and the record's parts (bot checks, ways in, pay, plan, terms, errors, times). For the product's verified owner only (a verified claim on its domain, then your API key): with an Audit of that drive, the full detail; without one, the counts and how to order it. Anyone else gets 403 owner_only and the public listing (get_tool).",
"inputSchema": {
"properties": {
"slug": {
"description": "The product's directory slug, from search_tools (e.g. 'attio')",
"type": "string"
}
},
"required": [
"slug"
],
"type": "object"
},
"name": "drive_detail"
},
{
"description": "Stops our drives of your own product (a verified claim), or lets them start again: stop true or false. Published results stay, with their date. Your own orders still run while it is stopped. Without stop: whether our drives of it are stopped now.",
"inputSchema": {
"properties": {
"claim_id": {
"description": "The claim's id, from whoami",
"type": "string"
},
"stop": {
"description": "true: stop our drives; false: let them start again; leave out to read",
"type": "boolean"
}
},
"required": [
"claim_id"
],
"type": "object"
},
"name": "drive_stop"
},
{
"description": "Ranks the products AgentDrives has test-driven for a task given in plain words (e.g. 'send an invoice'). Each result: the agent level (0-5: 0 Read-only, 1 Needs a person, 2 Gets in, 3 Does the work, 4 Runs on its own, 5 Autonomous); gets_in_alone (our agent signed up and got a key without a person); task: the closest task in the product's capability map and what happened when our agent tried it (result: done, partial, plan_gated, failed, blocked, not_tried, unknown; via: the route, e.g. api, mcp, cli, browser); match (strong or partial); can_do (up to three things our agent did there); stop (where it stopped, and why); work_done (share of the core tasks done, 0-100); the drive date; origin (editorial, or owner with disclosure \"Owner is an AgentDrives customer\"); and the page URL. Order: strong matches first, then the ones where our agent did the task, then level, then work done. A task that names a capability in full (e.g. 'send a transactional email') also brings the products where our agent did that capability (capability: the one it came by). self_signup: true keeps only products our agent got into on its own. Up to limit results (default 10, at most 25). Or by capability instead of task, by its id (cap_ and 8 characters; AgentDrives's GET /api/capabilities lists them by domain) or its name; the answer lists every product whose latest drive has a task of it (match: capability; tasks: the product's own tasks behind it; evidence: the page section that shows it), done first, then level. Words that fit several capabilities are an error that lists them. Send task or capability. get_tool returns one product in full. Every field: https://agentdrives.com/openapi.json.",
"inputSchema": {
"properties": {
"capability": {
"description": "A capability of the shared vocabulary instead of task: its id (e.g. from GET /api/capabilities) or its name, e.g. 'Send a transactional email'",
"type": "string"
},
"category": {
"description": "Only this category: an id or name from list_categories (e.g. 'invoicing')",
"type": "string"
},
"limit": {
"default": 10,
"description": "the most results to return",
"maximum": 25,
"minimum": 1,
"type": "integer"
},
"min_level": {
"description": "only products at this agent level or higher (0-5)",
"maximum": 5,
"minimum": 0,
"type": "integer"
},
"self_signup": {
"description": "true: only products our agent signed up for and got a key on its own",
"type": "boolean"
},
"task": {
"description": "The task in plain words, e.g. 'send an invoice' or 'create a contact'. Send this or capability",
"type": "string"
}
},
"type": "object"
},
"name": "find_tools_for_task"
},
{
"description": "Follow a tool from the directory by its slug (search_tools gives it): you hear by mail when its level changes. Free accounts follow up to 3 tools (the answer says how many you follow and the limit; a fourth answers limit, with the fix); Builder and Team follow any number. Following one you follow already changes nothing. Needs your API key.",
"inputSchema": {
"properties": {
"tool": {
"description": "The tool's slug, e.g. linear",
"type": "string"
}
},
"required": [
"tool"
],
"type": "object"
},
"name": "follow_tool"
},
{
"description": "A new drive after your fixes, with an Audit: one at a time, at most one a day, within its Audit year, 12 months from its report. Our agent signs up again like a new customer and checks your fixes. my_orders shows followup_available.",
"inputSchema": {
"properties": {
"order_id": {
"description": "Your Audit's order id, from my_orders",
"type": "string"
}
},
"required": [
"order_id"
],
"type": "object"
},
"name": "followup_drive"
},
{
"description": "Returns any product we drove: its full test-drive result (13 to 35 KB, usually about 19 KB; brief: true gives the headline in 2.5 to 5 KB, usually about 3 KB): how far an agent gets with it and where it stops. slug: its directory slug from search_tools, or its name or domain; an unknown one is an error that names the closest. The full result: the agent level, the five outcomes (find, shown as Learn; access, use, pay, leave, by any way in the product offers; stages: the four that decide the level, under their older keys), how an agent gets in (access, with the core tasks done on each way), the part scores, the nine checkpoints from docs to delete, what an agent can and cannot do, tips for agents, pay_options (the ways to pay it offers an agent, the payment our side proved with its transaction, and what the owner could add), the bot check that stopped our agent on a way in (agent_check: vendor, step, type network or challenge, the owner's fix), after_wall and works_assisted (what it did once a person helped: data only, not counted), robots (a robots.txt rule on the way in; held: the level is from the last drive past it), same_level_drives, confirmation (do the drives agree), the level history with why each move happened (product; agent: our agent or its drive changed; rules; noise), rules_date (the rules the level was set by), audited: its certificate, if any. Since 12 Oct 2026 also routes (every way in and what happened on each), checkout (how far the walk to the last click went), docs (read and judged) and claims (the documented ways to do the core work, tried once each: held, broken, worked but undocumented). newer_drives (drives after the listed one, not listed yet); attempts_count; the attempt log with its evidence is detail.url, for the product's verified owner. Every field: https://agentdrives.com/openapi.json (Tool).",
"inputSchema": {
"properties": {
"brief": {
"description": "true: only the headline: level, where it stopped (with its evidence), the main wall it met, the five outcomes, how an agent gets in, what it can and can't do, tips for agents, the level's history, its confirmation, the vendor it stopped at, fix counts by size, the evidence hash, first driven, licence and the page",
"type": "boolean"
},
"slug": {
"description": "The product's directory slug from search_tools (e.g. 'attio'), or its name or domain",
"type": "string"
}
},
"required": [
"slug"
],
"type": "object"
},
"name": "get_tool"
},
{
"description": "Lists every category in the directory: its id (for search_tools' category filter), its name, the number of products listed in it and the best agent level in it (0-5).",
"inputSchema": {
"properties": {},
"type": "object"
},
"name": "list_categories"
},
{
"description": "Set one fix's state: fixed when you made it, as_is to leave it as it is (with a one-line reason, shown on your certificate), doesnt_apply when our finding is wrong or not for you (with a one-line reason; a person answers within 2 working days), open to undo. Then ask for a new drive (followup_drive) to check your fixes.",
"inputSchema": {
"properties": {
"n": {
"description": "The fix's number on the list (audit_fixes)",
"minimum": 1,
"type": "integer"
},
"order_id": {
"description": "Your Audit's order id",
"type": "string"
},
"reason": {
"description": "as_is and doesnt_apply: why, in one line",
"maxLength": 200,
"type": "string"
},
"state": {
"enum": [
"fixed",
"as_is",
"doesnt_apply",
"open"
]
}
},
"required": [
"order_id",
"n",
"state"
],
"type": "object"
},
"name": "mark_fix"
},
{
"description": "The tools you follow, each with the day you started, your plan and its limit (free: 3 tools; Builder and Team: any number), and your webhook URL if you set one. You hear by mail when a followed tool's level changes (Builder and Team also by a signed webhook). Needs your API key.",
"inputSchema": {
"properties": {},
"type": "object"
},
"name": "my_follows"
},
{
"description": "Your orders and their status (requested, paid, queued, running, done, past_due when a renewal failed, cancelled), followup_available, an Audit's goal (target_level) and its renewal (renewal: price_cents, opens, closes, open), and a free check's check_state (failed: it didn't finish; retrying: our side stopped it and it runs again by itself; late: it waits longer than usual) with check_reason, why in plain words and what to do, and check_eta, when a check that waits or runs should be done. A done order's report: order_report.",
"inputSchema": {
"properties": {},
"type": "object"
},
"name": "my_orders"
},
{
"description": "For your own product: the Free check, and once claim_domain and verify_claim proved it is yours, the Audit or a Payment proof. For anyone: a Tool comparison or a data plan. Prices and limits: https://agentdrives.com/pricing.json. Prices are before VAT. Any VAT is added at checkout, by card and over HTTP 402 alike. free, the Free check ($0): what an agent sees of your product; private; one per domain every 90 days. audit, the Audit ($499): our agent signs up like a new customer (send no access) and checks every documented API route, MCP tool and CLI command against your docs; a security review; your fix list within 48 hours; a new drive after your fixes within the Audit year (followup_drive). When the drives find an agent uses the product fully with no person (L5), it ends in a certificate. target (1 to 5) is your goal, never a promise. renewal, the Audit renewal ($199 a year), from 11 months after your audit. proof, a Payment proof (at cost, see processor). One real purchase in your checkout with your discount code. When it goes through, your listing shows Pays on its own for 90 days. Send pay kind code and authorise: true. stack3 or stack, a Tool comparison ($490 for 3 tools, $650 for 5): send urls and use_case. builder, a data plan ($49 a month: follow any number of products, a signed webhook), or team ($290 a month: that and every listing in one file, GET /api/export). A paid order needs business: true (we sell to businesses only). It answers payment.url, the card checkout, and payment.agent, to pay over HTTP 402 with no person (pay_order). The same order again while it waits for payment returns that order (reused). Paid over HTTP 402, a data plan runs one month and doesn't renew by itself: pay again before it ends and the next month follows on. We email you 3 days before it ends. Ordering accepts the terms (https://agentdrives.com/legal/terms). An error comes with its fix.",
"inputSchema": {
"properties": {
"access": {
"description": "A Tool comparison or a Payment proof: a login, key or coupon our agent may use past a sign-up wall. Not on an Audit or its renewal (400 access_not_needed: we sign up ourselves; if your plans are paid, give a discount code with pay)",
"type": "string"
},
"authorise": {
"description": "With pay kind code, required: true is your go-ahead, \"Our agent may buy and cancel my paid plan with this code.\" (else 400 authorise_required)",
"type": "boolean"
},
"business": {
"description": "Optional: true when you buy for your business. Anyone can buy (https://agentdrives.com/legal/terms#business). Stripe's checkout asks the billing address, and a business name and VAT ID for the invoice when you buy for a business",
"type": "boolean"
},
"buyer": {
"description": "Optional, for an order paid over HTTP 402 (pay_order): your business on our invoice. An EU VAT ID that VIES confirms gets the invoice at once, and outside the Netherlands no VAT.",
"properties": {
"address": {
"description": "Postal address for the invoice, one line",
"type": "string"
},
"company": {
"description": "Business name for the invoice",
"type": "string"
},
"country": {
"description": "Two-letter code of your business's country, e.g. US",
"type": "string"
},
"vat_id": {
"description": "EU VAT ID with its country prefix, e.g. DE123456789",
"type": "string"
}
},
"type": "object"
},
"code": {
"description": "Optional: a promotion code of ours. Its discount comes off this order, at the card checkout and over HTTP 402 (400 invalid_code when it is unknown, expired or used up)",
"type": "string"
},
"email": {
"description": "An agent's own account, a Tool comparison or a data plan: the address for the receipt and our mails about the order (the comparison ready, the plan's end). Optional",
"type": "string"
},
"idempotency_key": {
"description": "Optional: any unique value, e.g. a UUID. Sending the order again with the same one returns the order it made, never a second one (24 hours); the same one with other fields is refused (idempotency_key_reused)",
"type": "string"
},
"listed": {
"default": true,
"description": "false: the drive stays private, never in the directory",
"type": "boolean"
},
"no_offers": {
"default": false,
"description": "Paid orders: true and we send you no offers for our other products",
"type": "boolean"
},
"note": {
"description": "Optional: anything our agent should know",
"type": "string"
},
"offers_ok": {
"default": false,
"description": "free: true only if you want the monthly agent access report and offers",
"type": "boolean"
},
"pay": {
"description": "Optional on an Audit, required on a Payment proof (proof): let our agent buy your plan at your own checkout. kind code: your discount code (value) that leaves $0.50 a purchase (on an Audit it works for every drive until 365 days after the report, its purchase inside the price; on a Payment proof our card pays it at cost); send authorise: true with it; sandbox: a login to your checkout's test mode or sandbox (value), for the free checkout test only (an Audit answers 400 access_not_needed: we sign up ourselves); seat: no value, we email you the address our agent signed up with, you upgrade it. Sealed, never shown back.",
"properties": {
"kind": {
"enum": [
"code",
"sandbox",
"seat"
]
},
"value": {
"description": "code: 6 to 64 letters, digits, dots, dashes or underscores; sandbox: the login (up to 2,000 characters)",
"type": "string"
}
},
"required": [
"kind"
],
"type": "object"
},
"plan": {
"description": "The Audit only: your paid plan. The drive buys it, uses one paid feature, cancels it and asks for the refund your product's own way. choice include: at cost as its own line on this order, the unused part refunded after the drive; self_refund: you refund the drive's purchase, at most $50 a month (above it: plan_needs_person, choose include or write to us); none. name and price_cents (a month, US cents; whoami's claims[].plan_hint suggests one). Above $50 a month add confirm: true; above $500 by arrangement",
"properties": {
"choice": {
"enum": [
"include",
"self_refund",
"none"
]
},
"confirm": {
"type": "boolean"
},
"name": {
"type": "string"
},
"price_cents": {
"type": "integer"
},
"source": {
"enum": [
"pricing",
"owner"
]
}
},
"required": [
"choice"
],
"type": "object"
},
"processor": {
"description": "With pay kind code: your checkout. card: Stripe, Lemon Squeezy, Shopify or another checkout, your code leaves $0.50 and a Payment proof costs $0.87; paddle: Paddle, your code leaves $0.70 and a Payment proof costs $1.09. Default card",
"enum": [
"card",
"paddle"
]
},
"product": {
"description": "free: Free check · audit: Audit · renewal: Audit renewal · proof: Payment proof · stack3/stack: Tool comparison · builder/team: data plan",
"enum": [
"free",
"audit",
"renewal",
"proof",
"stack",
"stack3",
"builder",
"team"
]
},
"target": {
"description": "audit or renewal: the level you aim for. It is your goal, shown on your dashboard, never a promise: the level is the one the drives find",
"maximum": 5,
"minimum": 1,
"type": "integer"
},
"tool": {
"description": "Your product's directory slug, if listed",
"type": "string"
},
"url": {
"description": "Your product's address, e.g. https://acme.com",
"type": "string"
},
"urls": {
"description": "Tool comparison: the tools to drive",
"items": {
"type": "string"
},
"type": "array"
},
"use_case": {
"description": "Tool comparison: what your agents should do with them",
"type": "string"
},
"waiver": {
"description": "Paid orders: true is the buyer's tick on \"Start right away. I lose my 14-day right to cancel once it's delivered.\" (https://agentdrives.com/legal/terms#withdrawal); without it, Stripe's checkout asks it before payment",
"type": "boolean"
}
},
"required": [
"product"
],
"type": "object"
},
"name": "order"
},
{
"description": "An order's report as Markdown (report), when ready is true: a free check's (with next: where an agent would probably stop, how many things to fix, whether it can be listed, whether an Audit fits, and the driven products in its category), or an Audit's drive's for a verified owner of the domain, with payment_map when the drive paid. Not ready yet: ready false, state (queued, running, late, retrying, failed or final_check), why in plain words and when to ask again (check_eta). A free check of a domain you proved opens too, whoever ran it. An unpaid order answers not_paid with where to pay; a data plan has no report.",
"inputSchema": {
"properties": {
"order_id": {
"description": "The order's id, from order or my_orders",
"type": "string"
}
},
"required": [
"order_id"
],
"type": "object"
},
"name": "order_report"
},
{
"description": "Test your checkout: Add a 100% off code and our agent buys your plan with it. A short private drive of your product's pay step: our agent signs up, buys your plan with your 100% off code (or in your checkout's test mode), uses one paid feature, cancels and deletes the account; the report comes by email. Free for a product you've proved yours (verify_claim); a product you've added but not proved counts with the free checks. One at a time, 2 per domain (its subdomains included) every 30 days.",
"inputSchema": {
"properties": {
"kind": {
"description": "code: a one-use 100% off code; sandbox: a login to your checkout's test mode or sandbox (only for a product you've proved yours)",
"enum": [
"code",
"sandbox"
]
},
"tool": {
"description": "Your product's directory slug, if listed",
"type": "string"
},
"url": {
"description": "Your product's address, e.g. https://acme.com (or tool)",
"type": "string"
},
"value": {
"description": "The code (6 to 64 letters, digits, dots, dashes or underscores) or the login",
"type": "string"
}
},
"required": [
"kind",
"value"
],
"type": "object"
},
"name": "pay_check"
},
{
"description": "Let our agent buy your plan, on an order you placed (an Audit, a Payment proof or a checkout test): add or replace a discount code, a seat on our account (an upgrade when we ask), or, for a checkout test only, a test-mode login; remove: true deletes it. It's sealed, never shown back (whoami and my_orders show its kind, last two characters and status). On an Audit a code serves every drive until 365 days after the report; otherwise it goes after the drive that used it.",
"inputSchema": {
"properties": {
"kind": {
"enum": [
"code",
"sandbox",
"seat"
]
},
"order_id": {
"description": "The order's id, from my_orders",
"type": "string"
},
"remove": {
"description": "true: delete the code or login on this order now",
"type": "boolean"
},
"value": {
"description": "code: 6 to 64 letters, digits, dots, dashes or underscores; sandbox: the login (up to 2,000 characters)",
"type": "string"
}
},
"required": [
"order_id"
],
"type": "object"
},
"name": "pay_code"
},
{
"description": "How an agent pays an order that waits for payment, over HTTP 402: an Audit (audit) or its renewal, a Payment proof (proof), a Tool comparison (stack3, stack) or a data plan (builder, team). It gives the payment URL, the price and the rails on now (protocols; MPP: a card through a Stripe Shared Payment Token, or USDC on Tempo or Base; x402: USDC on Base). A POST to the URL with no credential answers 402 with the challenges (WWW-Authenticate for MPP, PAYMENT-REQUIRED for x402). The same request with a credential from an MPP client or x402 wallet answers with the receipt and starts the order (a data plan: your key has it at once). The price is the listed price, less a promotion code of ours given with the order; an Audit adds, at cost, your paid plan if you included it and its purchase with your code. Prices are before VAT. Any VAT is added at checkout, by card and over HTTP 402 alike. Every payment has a receipt. buyer {vat_id, country, company, address}, as the JSON body of both requests or with the order, puts your business on our invoice. Paid over HTTP 402, a data plan runs one month and doesn't renew by itself: pay again before it ends and the next month follows on. We email you 3 days before it ends. On a person's account the card checkout works too (payment.url from order). An agent's own account pays only over HTTP 402 until a person claims it. test_mode: true means Stripe's test mode: no real money moves.",
"inputSchema": {
"properties": {
"order_id": {
"description": "The order's id, from order or my_orders",
"type": "string"
}
},
"required": [
"order_id"
],
"type": "object"
},
"name": "pay_order"
},
{
"description": "A free re-check of your listed product (a verified claim) after you fixed what stopped our agent: our agent drives it again, at most 2 times in 12 months. Without confirm: whether a free re-check is open now and when the next one opens. An Audit (order audit) drives it again after your fixes, within its Audit year.",
"inputSchema": {
"properties": {
"claim_id": {
"description": "The claim's id, from whoami",
"type": "string"
},
"confirm": {
"description": "true: ask for the re-check now; leave out to read",
"type": "boolean"
},
"note": {
"description": "What you fixed, in a line",
"maxLength": 500,
"type": "string"
}
},
"required": [
"claim_id"
],
"type": "object"
},
"name": "recheck_after_fix"
},
{
"description": "Tell us how far your own agent got in a product: the furthest checkpoint it reached, the wall that stopped it (if one did) and the day it tried. Kept with other agents' reports on that product, apart from our drives: a report never sets or changes a level. One report per key, product and day (a second one that day replaces the first); at most 10 an hour and 30 a day per key. Needs your API key.",
"inputSchema": {
"properties": {
"checkpoint": {
"description": "The furthest checkpoint your agent reached, in the drive's order",
"enum": [
"docs",
"signup",
"verify",
"credentials",
"first_call",
"first_action",
"pay",
"cancel",
"delete"
],
"type": "string"
},
"date": {
"description": "The day it tried, YYYY-MM-DD (UTC), within the last 30 days",
"format": "date",
"type": "string"
},
"note": {
"description": "Optional: what happened, in a sentence. Never published",
"maxLength": 500,
"type": "string"
},
"product": {
"description": "The product's slug, e.g. linear (search_tools gives it)",
"type": "string"
},
"wall": {
"description": "What stopped it: none when nothing did (the default)",
"enum": [
"none",
"network",
"challenge",
"robots",
"phone",
"card",
"idp",
"terms_browser",
"consent_needs_account",
"manual_review",
"domain_refused"
],
"type": "string"
}
},
"required": [
"product",
"checkpoint",
"date"
],
"type": "object"
},
"name": "report_attempt"
},
{
"description": "Searches AgentDrives' tested products by name, domain or what they do. Filters: category, minimum agent level (0-5: 0 Read-only, 1 Needs a person, 2 Gets in, 3 Does the work, 4 Runs on its own, 5 Autonomous), how an agent gets in (access: pay per call, no key, a key by API, its own sign-up…), agent-native payment (proven, or the rails it offers) and whether an agent leaves on its own. Returns the level and its name, how an agent gets in (access) and the five outcomes (find, shown as Learn; access, use, pay, leave: each yes, part (partway: pay part means it reached the checkout but couldn't finish paying; access part, it got in on some drives only), no, unreached (it never got that far) or na), the part scores (holds_up, docs_match: 0-100, null = not measured), where it stopped, the agent-native ways to pay it (pays_with) and whether we made a real payment over one (paid), the bot check that stopped our agent on a way in and its wall_type (network: It judged where our agent connected from and its browser, not a person. Our agent, working on its own from a data center, didn't get through; the owner can let signed agents in. How agents in a person's own browser fare isn't measured yet. challenge: It asks every visitor to prove they are human. Our agent doesn't solve these, and its signature didn't change that: a person does this step, or the owner opens it for agents.), who paid for the drive (origin: editorial, or owner with disclosure \"Owner is an AgentDrives customer\") and the page URL. Sorted by level, then work done, then minutes to the first call. Up to limit results (default 25, at most 100) from offset; total counts every match, next_offset and more give the rest; with none, try says what next. get_tool gives one product in full by its slug; list_categories gives the category ids. Every field: https://agentdrives.com/openapi.json (ToolSummary).",
"inputSchema": {
"properties": {
"access": {
"description": "only products an agent gets into this way: keyless (no key needed), local (runs locally), try_first (try first, claim later), pay_per_call, key_by_api, mcp_signin (our agent signed in to the product's own MCP server, by OAuth, and got in that way), email_signup, browser_signup, by_name (with a GitHub, Google or platform account), person (a person had to set it up: not counted)",
"enum": [
"keyless",
"local",
"try_first",
"no_account",
"pay_per_call",
"key_by_api",
"mcp_signin",
"email_signup",
"browser_signup",
"by_name",
"person"
],
"type": "string"
},
"agent_can_buy": {
"description": "only products an agent paid through an agent-native rail, proven from our side",
"type": "boolean"
},
"agent_can_leave": {
"description": "only products an agent leaves on its own",
"type": "boolean"
},
"category": {
"description": "A category id or name from list_categories (e.g. 'crm'); an unknown one is an error that says so",
"type": "string"
},
"limit": {
"default": 25,
"description": "the most results to return",
"maximum": 100,
"minimum": 1,
"type": "integer"
},
"min_level": {
"description": "only products at this agent level or higher (0-5)",
"maximum": 5,
"minimum": 0,
"type": "integer"
},
"offset": {
"default": 0,
"description": "skip this many matches first: the next page starts at the previous answer's next_offset",
"minimum": 0,
"type": "integer"
},
"pays_with": {
"description": "only products that offer this agent-native way to pay (seen or paid), e.g. x402, mpp, l402, stripe-projects, acp, ucp, ap2, mcp-payment",
"type": "string"
},
"query": {
"description": "Name, domain or what the tool does, e.g. 'invoicing', 'stripe.com' or 'postgres'; every word must match (the same search as the directory page)",
"type": "string"
}
},
"type": "object"
},
"name": "search_tools"
},
{
"description": "Step 2 (mail route): a 6-digit code to an address at the claimed domain. local is the part before the @ (e.g. jane or admin). Not for a mailbox provider's domain (gmail.com, tuta.com …): DNS, the meta tag or the file prove those. verify_claim checks the code.",
"inputSchema": {
"properties": {
"claim_id": {
"description": "The claim's id, from claim_domain or whoami",
"type": "string"
},
"local": {
"description": "the part before @, e.g. jane or admin",
"type": "string"
}
},
"required": [
"claim_id",
"local"
],
"type": "object"
},
"name": "send_claim_code"
},
{
"description": "No key needed: an account for you, the agent, with no person, no email address and no CAPTCHA, and its API key at once (api_key, shown once: it goes in the x-api-key header, here or to the HTTP API). Also a claim link for your person (claim.url, valid 7 days): when they open it, sign in and confirm, the account's orders become theirs, this key stops working and they get a new one, shown to them once, to give you. Until then, or until it pays for an order, the account has the free check (1 a day), an Audit for a domain it verified, a Tool comparison and a data plan (Builder, Team), paid over HTTP 402 (pay_order); other orders answer claim_required. email (optional): your person's address, the claim link goes there too. Leaving: POST /api/auth/delete-user with the key answers a confirm token; the same call with {token} within 5 minutes deletes the account.",
"inputSchema": {
"properties": {
"agent": {
"description": "Your name as an agent, e.g. claude-code (kept on the account)",
"type": "string"
},
"email": {
"description": "Optional: your person's email address, for the claim link",
"type": "string"
}
},
"type": "object"
},
"name": "sign_up"
},
{
"description": "Suggests a product for our agent to drive and list (free, anyone, any product). It is a signal for our planner, never a promise or a place in the queue: we pick by demand and gaps. A product listed already answers with its listing and the date its next drive is due (listed.next_drive_by). With an email, we write once when its listing is live.",
"inputSchema": {
"properties": {
"email": {
"description": "Optional: your address, for one email when its listing is live",
"type": "string"
},
"url": {
"description": "The product's address or name",
"type": "string"
},
"why": {
"description": "Optional: why agents need it",
"type": "string"
}
},
"required": [
"url"
],
"type": "object"
},
"name": "suggest_product"
},
{
"description": "Answers a question about AgentDrives: prices, plans, levels, the method, orders, the API and MCP. When our published pages answer it, the answer comes at once, quoted, with each source's id, text and URL (answered: true); a question about a listed product's drive (its level, where the agent stopped, why) is answered from that product's record (source tool.<slug>). With an API key, your own orders and claims are part of the answer. When they don't answer it, a case opens (answered: false, case_id; without a key also a case_token), and the answer comes in writing, in case_status (and comes by mail to an account). A test or a placeholder opens no case (state not_opened), and one agent opens at most 3 cases a day. Never promised here: a level, a refund or a date we don't control. Answers come from our support agent.",
"inputSchema": {
"properties": {
"on_behalf": {
"description": "Optional: whom you act for (a person or a company), kept on the case",
"type": "string"
},
"product": {
"description": "Optional: the product's domain or directory slug it is about",
"type": "string"
},
"question": {
"description": "The question, in plain words (up to 2,000 characters)",
"type": "string"
}
},
"required": [
"question"
],
"type": "object"
},
"name": "support_ask"
},
{
"description": "How prepaid credit for paid calls is bought: POST /api/paid/find-tools with your key then takes $0.01 a call from it, with no rate limit, and answers at once. The top-up is paid over HTTP 402, as with pay_order: a POST to the url with body {\"amount_usd\": 5 | 20 | 50} and no credential answers 402 with the challenges (MPP: a card through a Stripe Shared Payment Token, or USDC on Tempo or Base; x402: USDC on Base), and the same request with the credential pays. The idempotency_key from this answer, as the Idempotency-Key header on both requests, makes a retry never pay twice. With your API key the credit goes onto your account; without one the top-up makes an agent account and returns its key, which holds the credit. A balance holds at most $100 and lasts 12 months from the last top-up. It pays for calls only, not a report or a drive. The amount is your credit, before VAT: any VAT is added to the amount the 402 asks, and every top-up has a receipt. With a key this also gives your balance now, and needed: false while it is above 50 calls.",
"inputSchema": {
"properties": {
"amount_usd": {
"description": "The top-up in US dollars: 5, 20, 50. 5 buys 500 calls.",
"enum": [
5,
20,
50
]
}
},
"type": "object"
},
"name": "top_up"
},
{
"description": "Stop following a tool: no more mail about its level. Unfollowing one you don't follow changes nothing. Needs your API key.",
"inputSchema": {
"properties": {
"tool": {
"description": "The tool's slug",
"type": "string"
}
},
"required": [
"tool"
],
"type": "object"
},
"name": "unfollow_tool"
},
{
"description": "Step 2 of 3: verifies a claim. With code: checks the mailed code (send_claim_code). Without: checks the DNS TXT record, then the meta tag, then the file. A newly verified product gets its free check queued (private: nothing shows in the directory until a drive). Every order but the free check needs a verified claim on the domain.",
"inputSchema": {
"properties": {
"claim_id": {
"description": "The claim's id, from claim_domain or whoami",
"type": "string"
},
"code": {
"description": "the 6-digit code from send_claim_code",
"type": "string"
}
},
"required": [
"claim_id"
],
"type": "object"
},
"name": "verify_claim"
},
{
"description": "What changed in the directory in the last days (default 7, at most 31): level_moves, each product's level going up or down between two of its drives, with the date, the cause in words (our agent changed, not confirmed by a second drive yet, sign-up varies from drive to drive) and the level listed now (level_now); net, each product once from its first level in the span to its last (up, down, back); confirmed, the changes the next drive confirmed (the change feed's items); and moves of where it stopped or how it gets in (listed for one product or category, else counted). Newest first. category or slug narrows it.",
"inputSchema": {
"properties": {
"category": {
"description": "Only this category: an id or name from list_categories",
"type": "string"
},
"days": {
"default": 7,
"description": "How many days back",
"maximum": 31,
"minimum": 1,
"type": "integer"
},
"slug": {
"description": "Only this product: its slug from search_tools",
"type": "string"
}
},
"type": "object"
},
"name": "what_changed"
},
{
"description": "Your account, claimed domains and orders.",
"inputSchema": {
"properties": {},
"type": "object"
},
"name": "whoami"
},
{
"description": "Withdraws an order that has not been paid yet.",
"inputSchema": {
"properties": {
"order_id": {
"description": "The order's id, from my_orders",
"type": "string"
}
},
"required": [
"order_id"
],
"type": "object"
},
"name": "withdraw_order"
}
]
}What the leaf hashes
{"body":"9f30b152fbc5e5a962713d9bb783ae93c2ca8f12861f285cb8160c093b6038ba","id":515472,"kind":"mcp.tools","method":"probe.mcp/1","observed_us":1793120063932764,"prev":null,"subject":"f7557db7-0551-44cc-a336-639524773953","subject_kind":"endpoint"}Proof
Its day has not closed yet. A day closes ten minutes after midnight UTC; the proof appears here then.