# AgentDrives (remote · agentdrives.com)

Can an AI agent use this software? Levels from real agent test drives: sign-up, keys, use, pay.

- Trust score: 59/100 (low)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-10-18

## Components

- remote · `agentdrives.com`: 59/100 (this document), [markdown](https://verifymcp.io/servers/com-agentdrives-directory/agentdrives.md), [page](https://verifymcp.io/servers/com-agentdrives-directory/agentdrives)
- remote · `agentdrives.com`: 67/100, [markdown](https://verifymcp.io/servers/com-agentdrives-directory/api-mcp.md), [page](https://verifymcp.io/servers/com-agentdrives-directory/api-mcp)

## Channel facts

- Endpoint: `https://agentdrives.com/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.4.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-10-18.

- **Endpoint Security**: 51/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation check failed: no authorisation is required to call this server, and it exposes a tool marked destructive (withdraw_order).
  - HTTPS check failed: the endpoint is reachable over plaintext HTTP.
  - The HSTS (Strict-Transport-Security) header is present.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 57/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 6312 tokens (~225/item across 28 items; 28 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 7/100
  - Stability observed for 2 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 98/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 95% of tool parameters carry a description.
- **Tool Safety**: 95/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 4 of 5 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "pay_order" implies "pay" and declares readOnlyHint instead, contradicting what its own name says it does.
  - An AI judge read all 29 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

## Install

### How do I install the AgentDrives MCP server?

AgentDrives is a hosted endpoint at https://agentdrives.com/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add --transport http com-agentdrives-directory 'https://agentdrives.com/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "com-agentdrives-directory": {
      "url": "https://agentdrives.com/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "com-agentdrives-directory": {
      "type": "http",
      "url": "https://agentdrives.com/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.com-agentdrives-directory]
url = "https://agentdrives.com/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "com-agentdrives-directory": {
      "type": "remote",
      "url": "https://agentdrives.com/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add com-agentdrives-directory --url 'https://agentdrives.com/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  com-agentdrives-directory:
    url: "https://agentdrives.com/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "com-agentdrives-directory": {
      "Transport": "http",
      "Url": "https://agentdrives.com/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add com-agentdrives-directory -t streamable-http -u 'https://agentdrives.com/mcp'
```

### Other

```json
{
  "mcpServers": {
    "com-agentdrives-directory": {
      "type": "http",
      "url": "https://agentdrives.com/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-10-18 (score 59, 0)

- [security] Tool “followup_drive” rewrote its description, which is the text the model reads
- [security] Tool “pay_check” rewrote its description, which is the text the model reads
- [security] Tool “pay_code” rewrote its description, which is the text the model reads
- [security] Tool “pay_order” rewrote its description, which is the text the model reads
- [security] Tool “recheck_after_fix” rewrote its description, which is the text the model reads
- [security] Tool “sign_up” rewrote its description, which is the text the model reads
- [security] Tool “my_orders” rewrote its description, which is the text the model reads
- [security] Tool “order” rewrote its description, which is the text the model reads
- [functional] New tool “audit_fixes”
- [functional] New tool “mark_fix”
- [cosmetic] “order” added an optional parameter “authorise”
- [cosmetic] “order” added an optional parameter “code”
- [cosmetic] “order” added an optional parameter “idempotency_key”
- [cosmetic] “order” added an optional parameter “processor”
- [cosmetic] “order” added an optional parameter “target”
- [cosmetic] “order” reworded the description of “pay”
- [cosmetic] “order” reworded the description of “product”
- [cosmetic] “pay_order” reworded the description of “order_id”
- [cosmetic] “order” reworded the description of “buyer”
- [cosmetic] “order” dropped the optional parameter “fresh”
- [cosmetic] “order” dropped the optional parameter “upgrade_from”
- [cosmetic] Tool “pay_order” changed its title: Pay for a Drive → Pay for an order
- [cosmetic] Tool “followup_drive” changed its title: Ask for a follow-up drive → Ask for a new drive after a fix
- [cosmetic] Tool “order” changed its title: Order a report or a drive → Order an audit or a drive

### 2026-10-17 (score 59, +1)

- [security] Tool “verify_claim” rewrote its description, which is the text the model reads
- [security] Tool “withdraw_order” rewrote its description, which is the text the model reads
- [security] Tool “cancel_monthly” rewrote its description, which is the text the model reads
- [security] Tool “claim_domain” rewrote its description, which is the text the model reads
- [security] Tool “dispute_result” rewrote its description, which is the text the model reads
- [security] Tool “drive_stop” rewrote its description, which is the text the model reads
- [security] Tool “find_tools_for_task” rewrote its description, which is the text the model reads
- [security] Tool “followup_drive” rewrote its description, which is the text the model reads
- [security] Tool “get_tool” rewrote its description, which is the text the model reads
- [security] Tool “list_categories” rewrote its description, which is the text the model reads
- [security] Tool “my_orders” rewrote its description, which is the text the model reads
- [security] Tool “order” rewrote its description, which is the text the model reads
- [security] Tool “pay_order” rewrote its description, which is the text the model reads
- [security] Tool “search_tools” rewrote its description, which is the text the model reads
- [security] Tool “send_claim_code” rewrote its description, which is the text the model reads
- [security] Tool “sign_up” rewrote its description, which is the text the model reads
- [security] Tool “suggest_product” rewrote its description, which is the text the model reads
- [security] Tool “support_ask” rewrote its description, which is the text the model reads
- [security] Tool “switch_monthly” rewrote its description, which is the text the model reads
- [security] Tool “top_up” rewrote its description, which is the text the model reads
- [functional improvement] Stability: unverified → 0.03
- [functional] New tool “recheck_after_fix”
- [cosmetic] “order” added an optional parameter “fresh”
- [cosmetic] “order” reworded the description of “product”
- [cosmetic] “find_tools_for_task” reworded the description of “task”
- [cosmetic] “order” reworded the description of “pay”
- [cosmetic] “order” reworded the description of “upgrade_from”
- [cosmetic] Tool “order” changed its title: Order a drive → Order a report or a drive

### 2026-10-16 (score 58)

First indexed and scored.

## MCP tools (28)

### `find_tools_for_task` (~409 tokens)

Find tools for a task

Ranks the products AgentDrives has test-driven for a task given in plain words (e.g. 'send an invoice', 'scrape a web page', 'add a contact to a CRM'). 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-paid drive"); and the page URL. Order: strong matches first, then the ones where our agent did the task, then level, then work done. self_signup: true keeps only products our agent got into on its own. Up to limit results (default 10, at most 25); nothing matches: an empty list. get_tool returns one product in full.

Input parameters:

- `category` (string): Only this category: an id or name from list_categories (e.g. 'invoicing')
- `limit` (integer): the most results to return
- `min_level` (integer): only products at this agent level or higher (0-5)
- `self_signup` (boolean): true: only products our agent signed up for and got a key on its own
- `task` (string, required): The task in plain words, e.g. 'send an invoice' or 'create a contact'

### `search_tools` (~688 tokens)

Search the directory

Searches AgentDrives' tested products by name, domain or what they do, and returns each one's agent level and evidence. 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, access, use, pay, leave: each yes, part, no, unreached or na), the part scores (holds_up, docs_match, setup: 0-100, null = not measured), where it stopped, the agent-native ways to pay it offers (pays_with) and whether our side proved a payment (paid), the bot check that stopped our agent on a way in (it may have got in another way) and its wall_type (network: It judged where our agent connects from and its browser, not a person. An agent that works on its own from a data center doesn't get through unless the owner lets 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. It stops every agent on any network, and a signature doesn't help: a person does this step, or the owner opens it for agents.), who paid for the drive (origin: editorial, or owner with disclosure "Owner-paid drive") 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); none match: an empty list. get_tool returns one product's full result by a slug from here; list_categories gives the category ids.

Input parameters:

- `access` (string): 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, email_signup, browser_signup, by_na…
- `agent_can_buy` (boolean): only products an agent paid through an agent-native rail, proven from our side
- `agent_can_leave` (boolean): only products an agent leaves on its own
- `category` (string): A category id or name from list_categories (e.g. 'crm'); an unknown one is an error that says so
- `limit` (integer): the most results to return
- `min_level` (integer): only products at this agent level or higher (0-5)
- `pays_with` (string): 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
- `query` (string): 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)

### `get_tool` (~474 tokens)

Get one tool's drive result

Returns one product's full test-drive result: how far an agent gets with it and where it stops (search_tools gives the slug; an unknown slug is an error that says how to find one): the agent level, the five outcomes (find, 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 in the order of the agent's eight steps (Find: none, it is the Agent-ready setup; Learn: docs; Sign up: sign-up, verify; Get a key: key, first call; Do the work: first action; Pay: pay; Cancel: cancel; Leave: 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, even where it got in another way (agent_check: vendor, step, type network or challenge, the owner's fix), after_wall: what the agent did on its own once a person cleared one step at the door (never part of the level), works_assisted (the core tasks done once a person set up the account; null: not measured yet), robots (a robots.txt rule on the way in: named, the product's wall, or star, a rule for crawlers; held: the level is from the last drive past it), same_level_drives of drives, the level history with why each move happened (product, rules, noise), rules_date: the date of the rules the level was set by. From the rules of 12 Oct 2026 on: routes (every way in it offers and what happened on each, tried agent-native first), checkout (how far the walk to the last click went and what the checkout showed), docs (its docs read and judged) and claims (the documented ways to do the core work, tried once each: held, broken, worked but undocumented).

Input parameters:

- `slug` (string, required): The product's directory slug, from search_tools (e.g. 'attio')

### `list_categories` (~47 tokens)

List categories

Lists every category in the directory: its id (for search_tools' category filter), its name, the number of products driven in it and the best agent level in it (0-5).

### `sign_up` (~247 tokens)

Sign up as an agent

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 give you a new one from their dashboard. Until then, or until it pays for an order, the account has the free check (1 a day) and every report and the Monthly drive for a domain it verified, 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.

Input parameters:

- `agent` (string): Your name as an agent, e.g. claude-code (kept on the account)
- `email` (string): Optional: your person's email address, for the claim link

### `whoami` (~16 tokens)

Your account

Your account, claimed domains and orders.

### `claim_domain` (~175 tokens)

Claim your product's domain

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, matfy.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).

Input parameters:

- `domain` (string, required): Your product's domain, e.g. acme.com
- `tool` (string): Directory slug, if listed

### `send_claim_code` (~114 tokens)

Mail a claim code

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.

Input parameters:

- `claim_id` (string, required): The claim's id, from claim_domain or whoami
- `local` (string, required): the part before @, e.g. jane or admin

### `verify_claim` (~118 tokens)

Verify a claim

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.

Input parameters:

- `claim_id` (string, required): The claim's id, from claim_domain or whoami
- `code` (string): the 6-digit code from send_claim_code

### `drive_stop` (~101 tokens)

Stop or restart our drives of your product

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.

Input parameters:

- `claim_id` (string, required): The claim's id, from whoami
- `stop` (boolean): true: stop our drives; false: let them start again; leave out to read

### `recheck_after_fix` (~131 tokens)

Ask for a free re-check after a fix

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) checks every fix you make for 90 days.

Input parameters:

- `claim_id` (string, required): The claim's id, from whoami
- `confirm` (boolean): true: ask for the re-check now; leave out to read
- `note` (string): What you fixed, in a line

### `followup_drive` (~115 tokens)

Ask for a new drive after a fix

A new drive after your fixes, with an Audit: up to 5 within 90 days of its report, one at a time. It checks your fixes, or, with access (a test account or key), measures the product past your sign-up wall. my_orders shows followup_available and followups_left.

Input parameters:

- `access` (string): Optional: a test account, key or sandbox our agent may use past your sign-up wall
- `order_id` (string, required): Your Audit's order id, from my_orders

### `order` (~1319 tokens)

Order an audit or a drive

Step 3 of 3: orders for your product (prices before tax; every detail and limit: https://agentdrives.com/pricing.json). Every driven product is listed free. free, the Free check ($0): what an agent sees, private; no domain proof; one per domain every 90 days. audit, an Audit ($499): a new drive with your test account (access), every documented API route, MCP tool and CLI command checked against your docs, a security review (security_ok: true), up to 3 rivals compared privately (rivals), your fix list and a new drive after your fixes for 90 days (followup_drive); from L2 up it ends in a certificate with the level the drives find. target (1 to 5): your goal, never a promise. renewal, the Audit renewal ($199 a year), from 11 months after your audit. Report within 48 hours. monthly or yearly, the Monthly drive ($29 a month, or $290 a year): a listed product with a verified claim, driven every month, its findings and a message when the level changes; cancel_monthly any time. Also stack3 or stack, a Stack check ($490, $1,490), and a data plan, builder ($49 a month) or team ($290 a month). A paid order for your own product needs a verified claim on its domain (403 claim_not_verified says how) and business: true (we sell to businesses). With online payment on, payment.url comes back: the page that takes the payment (the same order again while it waits: that order, reused); an Audit and the Monthly drive also return payment.agent, to pay over HTTP 402 without a person (pay_order). Ordering accepts the terms (https://agentdrives.com/legal/terms). An error comes with its fix.

Input parameters:

- `access` (string): Optional: a test account, key, sandbox or coupon our agent may use past your sign-up wall
- `authorise` (boolean): 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)
- `business` (boolean): Paid orders: true confirms you buy for your business. AgentDrives sells to businesses only (https://agentdrives.com/legal/terms#business); the order records it. Stripe's checkout asks the business na…
- `buyer` (object): An Audit paid over HTTP 402 (pay_order): optional, for our invoice. The price includes any VAT; an EU VAT ID that VIES confirms gets our invoice at once, with no VAT outside the Netherlands.
- `code` (string): 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)
- `idempotency_key` (string): 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)
- `listed` (boolean): false: the drive stays private, never in the directory
- `no_offers` (boolean): Paid orders: true and we send you no offers for our other products
- `note` (string): Optional: anything our agent should know
- `offers_ok` (boolean): free: true only if you want the monthly agent access report and offers
- `pay` (object): 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; our card pays that on…
- `plan` (object): 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…
- `processor`: 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 Payme…
- `product` (required): free: Free check · audit: Audit · renewal: Audit renewal · monthly: Monthly drive, monthly · yearly: Monthly drive, yearly · proof: Payment proof · stack/stack3: Stack check · builder/team: data plan…
- `rivals` (array): audit (the Audit): up to 3 rival URLs or directory slugs, compared with you privately
- `security_ok` (boolean): Your go-ahead for the Audit's security review of the agent surfaces, on our own test account (required for audit)
- `target` (integer): 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
- `tool` (string): Your product's directory slug, if listed
- `url` (string): Your product's address, e.g. https://acme.com
- `urls` (array): Stack check: the tools to drive
- `use_case` (string): Stack check: what your agents should do with them

### `pay_order` (~311 tokens)

Pay for an order

How to pay an order that waits for payment, as an agent, over HTTP 402: an Audit (audit) or its renewal (renewal), a Payment proof (proof), or the Monthly drive (monthly or yearly, one period paid ahead, not renewed by itself). It gives the payment URL, the price and the protocols 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 without a credential answers 402 with the challenges of the rails that are on (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 queues the drive. The price is what the card checkout charges: a renewal's price, an Audit's paid plan and its purchase with your code at cost, less a promotion code of ours given with the order. The price includes any VAT and every payment has a receipt; buyer {vat_id, company, address} as the JSON body of both requests, or with the order, puts the business on our invoice. On a person's account the card checkout works too (payment.url from ordering); an agent's own account has none until a person claims it. test_mode: true means Stripe's test mode, where no real money moves.

Input parameters:

- `order_id` (string, required): The order's id, from order or my_orders

### `top_up` (~283 tokens)

Top up credit for paid calls

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 price includes any VAT, 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.

Input parameters:

- `amount_usd`: The top-up in US dollars: 5, 20, 50. 5 buys 500 calls.

### `balance` (~53 tokens)

Your credit for paid calls

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.

### `audit_fixes` (~148 tokens)

Your Audit's fix list

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, and its state (open, fixed, or as_is with your reason). It comes with the Audit's report. Also the Audit's drives (the audit drive and each new drive after fixes, with the level it reached and its report) and redrive (new drives left, until when, and whether one can start now). The list is yours to work through: it never moves your level; a new drive does (followup_drive).

Input parameters:

- `order_id` (string, required): Your Audit's order id, from my_orders

### `mark_fix` (~115 tokens)

Mark a fix on your Audit's list

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), open to undo. Then ask for a new drive (followup_drive) to check your fixes.

Input parameters:

- `n` (integer, required): The fix's number on the list (audit_fixes)
- `order_id` (string, required): Your Audit's order id
- `reason` (string): as_is only: why you leave it, in one line
- `state` (required)

### `my_orders` (~115 tokens)

Your orders

Your orders and their status (requested, paid, queued, running, done, past_due when a renewal failed, cancelled), followup_available and followups_left, 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.

### `withdraw_order` (~35 tokens)

Withdraw an unpaid order

Withdraws an order that has not been paid yet.

Input parameters:

- `order_id` (string, required): The order's id, from my_orders

### `pay_code` (~170 tokens)

Add or remove the code for your order

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 test-mode login or a seat on our test account, until a drive has it; remove: true deletes it. It's sealed, never shown back (whoami and my_orders show its kind, last two characters and status), and deleted after the drive that used it.

Input parameters:

- `kind`
- `order_id` (string, required): The order's id, from my_orders
- `remove` (boolean): true: delete the code or login on this order now
- `value` (string): code: 6 to 64 letters, digits, dots, dashes or underscores; sandbox: the login (up to 2,000 characters)

### `pay_check` (~227 tokens)

Start a free checkout test

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.

Input parameters:

- `kind` (required): 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)
- `tool` (string): Your product's directory slug, if listed
- `url` (string): Your product's address, e.g. https://acme.com (or tool)
- `value` (string, required): The code (6 to 64 letters, digits, dots, dashes or underscores) or the login

### `cancel_monthly` (~71 tokens)

Cancel the Monthly drive

Cancels the Monthly drive: one product (order_id) or all of them. It runs to the end of the paid period. The listing stays, with its date.

Input parameters:

- `order_id` (string): The Monthly drive's order id, from my_orders; leave it out to cancel all of them

### `switch_monthly` (~68 tokens)

Switch the Monthly drive's billing period

Switches the Monthly drive for one product between monthly ($29) and yearly ($290). A subscription from before 10 October 2026 keeps its price (409 legacy_plan).

Input parameters:

- `order_id` (string, required): The Monthly drive's order id, from my_orders
- `to` (required)

### `suggest_product` (~78 tokens)

Suggest a product to drive

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.

Input parameters:

- `url` (string, required): The product's address or name
- `why` (string): Optional: why agents need it

### `support_ask` (~237 tokens)

Ask AgentDrives support

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). 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.

Input parameters:

- `on_behalf` (string): Optional: whom you act for (a person or a company), kept on the case
- `product` (string): Optional: the product's domain or directory slug it is about
- `question` (string, required): The question, in plain words (up to 2,000 characters)

### `dispute_result` (~202 tokens)

Dispute a drive result

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.

Input parameters:

- `checkpoint` (required)
- `claim` (string, required): What is true, in plain words (up to 2,000 characters)
- `evidence_url` (string): Optional: a public page that shows it (kept on the case; we never fetch it automatically)
- `product` (string, required): Your product's domain or directory slug

### `case_status` (~111 tokens)

A support case's status

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.

Input parameters:

- `case_id` (string, required): The case's id, from support_ask or dispute_result
- `case_token` (string): Without a key: the token support_ask returned with the case

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/com-agentdrives-directory/agentdrives#diagnostics

## Score history

- 2026-10-18: 59
- 2026-10-17: 59
- 2026-10-16: 58

## Common questions

### What is the AgentDrives MCP server?

AgentDrives is an MCP server listed in the public MCP registry as com.agentdrives/directory. Can an AI agent use this software? Levels from real agent test drives: sign-up, keys, use, pay. This page covers its hosted endpoint (https://agentdrives.com/mcp).

### Is the AgentDrives MCP server safe to use?

AgentDrives scores 59 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the AgentDrives MCP server expose?

AgentDrives exposes 28 tools: find_tools_for_task, search_tools, get_tool, list_categories, sign_up, and 23 more. Their descriptions and schemas cost roughly 6,178 tokens of context every time the server is loaded.

### Does the AgentDrives MCP server require authentication?

No. We connected to AgentDrives without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the AgentDrives MCP server still maintained?

AgentDrives is still listed as active in the MCP registry. We last reached this channel on 18 October 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- Remote endpoint: https://agentdrives.com/mcp
- Website: https://agentdrives.com/data
- Changelog RSS feed: https://verifymcp.io/servers/com-agentdrives-directory/agentdrives.xml
- Changelog JSON feed: https://verifymcp.io/servers/com-agentdrives-directory/agentdrives.json
- HTML version of this page: https://verifymcp.io/servers/com-agentdrives-directory/agentdrives