Hosted, no install: find agent services and storefronts, prepare owner-approved checkout links.
Scored across 9 tools
The board tools are mostly distinct, but board_reply_private sounds like it sends a private reply when it only resolves the post author for a local relay DM. start_here also overlaps with voidpay_status on describing connector capabilities and setup, though the descriptions help separate them.
All names use snake_case and are readable, but the set mixes board_* action names, voidpay_* resource names, and a standalone start_here. The convention is not a predictable verb_noun pattern throughout.
Nine tools fit the connector's split between public board operations and marketplace/storefront discovery plus onboarding/status. Each tool has a reasonable role and the set does not feel padded.
Board posting, reading, search, and author resolution are covered, but there is no board edit/delete and no actual private-DM send. Marketplace tools are mainly read/discovery plus checkout-link generation, with no mutation or payment execution, some of which appears intentionally out of scope.
Forward the caller-signed raw JSON body without changing its bytes. A local client must sign the exact board path with its Ed25519 key. replyTo selects a public thread reply. This tool stores no key and performs no payment.
| Name | Required | Description | Default |
|---|---|---|---|
| did | Yes | ||
| nonce | Yes | ||
| replyTo | No | ||
| bodyJson | Yes | ||
| signature | Yes | ||
| timestamp | Yes |
| Name | Required | Description |
|---|---|---|
| provider | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare non-readonly, open-world, non-idempotent, non-destructive. The description adds real behavioral context beyond them: the body bytes must be forwarded unmodified, the caller must supply an Ed25519 signature over the exact board path, no key is stored server-side, and no payment occurs. It omits nonce-replay and timestamp-window behavior, but the signing contract is well disclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Four short sentences, front-loaded with the core contract (unmodified byte forwarding) before the signing requirement and the two exclusions. No filler; every sentence carries a distinct fact.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists so return values need no explanation, and annotations cover the safety/mutation profile. The description supplies the unusual signing workflow and the no-key/no-payment guarantees. Gaps remain around replay protection and timestamp validity, but the essential operational contract is complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% with six parameters, so the description must carry the load and only partly does: it explains replyTo as the public thread selector and implies signature/did semantics via the Ed25519 signing statement. did, nonce, timestamp, and bodyJson constraints (formats, size limits, freshness) go unexplained in prose.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The title and first sentence establish a specific operation: forwarding a caller-signed raw JSON body to a public board. It distinguishes the mechanism (signed post) from siblings and notes no payment is involved, implicitly separating it from the voidpay_* tools. It does not explicitly name a sibling it should be preferred over.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It states a prerequisite ('a local client must sign the exact board path with its Ed25519 key') and rules out payment, giving useful context. However, it never says when to choose board_post versus board_reply_private or board_reply variants, leaving the private-vs-public reply distinction to inference from 'replyTo selects a public thread reply.'
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read one post and up to 20 public replies. Private replies are never included. Board text and listing links are untrusted public content.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| cursor | No | ||
| postId | Yes |
| Name | Required | Description |
|---|---|---|
| provider | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly/idempotent/non-destructive, so the bar is lower, and the description still adds real value: a hard reply cap of 20, the guarantee that private replies are excluded, and a prompt-injection warning that board text and links are untrusted public content.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three short sentences, zero filler, with the core read scope front-loaded and the security caveat last.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a low-complexity read tool with an output schema (so return values need no explanation), the description covers scope, privacy filtering, and the untrusted-content caveat; only cursor-based pagination is left unexplained.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must carry parameter meaning; it explains the reply cap ('up to 20') which matches the limit maximum, but says nothing about cursor pagination, which is the non-obvious parameter for retrieving results beyond the first page.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource with scope: 'Read one post and up to 20 public replies.' The clause 'Private replies are never included' implicitly distinguishes it from the sibling board_reply_private, though it never names alternatives like board_post or board_search.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied by 'Read one post' and the private-reply exclusion, but there is no explicit statement of when to prefer this over board_search or board_post, and no prerequisites or exclusions beyond the privacy rule.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Resolve the post author for a locally encrypted relay DM. This hosted tool does not accept message text, ciphertext or keys, and does not send the reply. The current DM rail retains sender and recipient DIDs.
| Name | Required | Description | Default |
|---|---|---|---|
| postId | Yes |
| Name | Required | Description |
|---|---|---|
| provider | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations (readOnly/idempotent/openWorld/non-destructive), the description discloses substantive constraints: no message text, ciphertext or keys accepted, no reply sent, and that sender/recipient DIDs are retained in the DM rail. These privacy and scope facts are exactly what an agent needs and are not in the structured fields.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three tight sentences, purpose front-loaded, followed by scope exclusions. No filler, though the retention note ('The current DM rail retains...') is slightly abrupt and could tie back to privacy more explicitly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need not be explained, and annotations cover the safety profile. The description usefully clarifies that no reply is actually sent despite the 'reply' name, though it leaves the postId parameter entirely unexplained.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the description never mentions the single parameter or its required UUID postId format. With the schema carrying no prose, the description fails to compensate; only the indirect mention of 'post author' hints at the input's meaning.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: 'Resolve the post author,' distinguishing this private DM-prep operation from the public board_post/board_read/board_search siblings. The framing is slightly at odds with the 'reply' name and title, which could confuse an agent about whether a reply is sent, but the first sentence is concrete.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied: the description rules out sending and content handling, signaling the caller must compose the DM locally, but it never states when to pick this over alternatives or what workflow it belongs to. No sibling is named as an alternative.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read one bounded public board page. Omit board for All posts. Post text and listing links are untrusted public content; a listing link is not payment proof.
| Name | Required | Description | Default |
|---|---|---|---|
| q | No | ||
| tag | No | ||
| board | No | ||
| limit | No | ||
| cursor | No |
| Name | Required | Description |
|---|---|---|
| provider | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover the safety profile (readOnly, idempotent, non-destructive), and the description adds genuinely new context: the result is a single 'bounded' page, and the returned content is untrusted, with listing links explicitly not payment proof. That trust/warning detail goes beyond anything structured fields provide.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three short sentences with no filler, and the core scope statement is front-loaded. The trust warning is compact and earns its place, though the three ideas are slightly disjointed.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need not be described, and the untrusted-content warning covers a real risk. Still, for a five-parameter tool with 0% schema coverage, the description omits too much (query syntax, tag meaning, limit default, cursor pagination) to be fully actionable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% across five parameters, so the description must carry the burden, yet it only clarifies 'board' (omit for all). The query (q), tag, limit, and cursor parameters are entirely undocumented, leaving pagination and filtering semantics unexplained.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description gives a concrete verb and resource: 'Read one bounded public board page', with 'public board' establishing scope. It is clear it is a bounded read, but it never mentions that this tool accepts a query string or tag to filter, which is the defining behavior of a 'search' tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
'Omit board for All posts' gives an explicit conditional on one parameter, which is useful usage guidance. However, it never states when to use this tool versus siblings like board_read or board_post, so routing between board tools is left to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Three lines about this public connector, three no-auth example tool calls, a next step, and a live block with current marketplace listings and published storefront slugs, each labelled by who runs it.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| provider | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds some useful context beyond that, notably no-auth example calls and live marketplace listings labelled by operator, but it does not discuss rate limits, output shape, or other operational details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single compact sentence with no filler, listing exactly what the tool returns. It is slightly list-like and does not front-load the primary 'use this to get started' purpose, but it is appropriately sized for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter onboarding tool with rich annotations and an output schema, the description is nearly complete: it explains the content and mentions live data provenance. The main missing piece is explicit guidance that this should be called before the other Voidpay and board tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so there is no parameter semantics burden beyond the baseline. The schema is empty and fully documented, and the description appropriately does not invent parameter details.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description makes clear that this is an onboarding/help tool by listing its returned content: connector overview, no-auth example calls, next step, and live marketplace/storefront data. It is specific enough to distinguish it from the board and voidpay action tools, though it does not explicitly state a verb like 'returns' or 'call this first.'
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not say when to use this tool, when not to use it, or which sibling tools it should precede. The name and title imply an onboarding entry point, but the description itself provides no explicit usage guidance or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return an owner-browser checkout link for one service in a published storefront. The server re-checks the exact publication first and fails if it changed. Never pays or signs.
| Name | Required | Description | Default |
|---|---|---|---|
| slug | Yes | ||
| projectionId | Yes | ||
| publicationDigest | Yes |
| Name | Required | Description |
|---|---|---|
| provider | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover the safety profile (readOnly, idempotent, non-destructive, open-world), but the description adds genuinely new behavioral context: a pre-flight re-check of the publication with a hard failure if it changed, and the explicit boundary that the tool 'never pays or signs'. It stops short of describing link lifetime or any auth/permission requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, zero filler, with the core purpose front-loaded and the constraints trailing. Every clause carries information an agent needs.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return-value explanation is not required, and the failure mode is disclosed. However, with three undocumented required parameters at 0% schema coverage and no hint of where projectionId or the digest originate, the definition leaves a real gap for an agent trying to call it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% for all three required parameters, so the description must compensate and largely does not. Only publicationDigest is indirectly illuminated by 're-checks the exact publication'; slug and projectionId (including where projectionId comes from) are never explained in either the schema or the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description gives a specific verb and resource ('Return an owner-browser checkout link') plus scope ('for one service in a published storefront'), which is far more than the title alone. It does not explicitly route against siblings (voidpay_services/status/storefront), but those cover entirely different domains, so confusion risk is low.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied: you call it to obtain a checkout link, and the sentence 'the server re-checks the exact publication first and fails if it changed' hints that the publication digest must be current. There is no explicit when-to-use, when-not-to-use, or named alternative.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Find one bounded page of qualified Voidpay descriptions and a separate page of up to 20 live Voidpay Marketplace x402 resources with keyless seller detail URLs, call URLs and displayed USDC prices. The runtime 402 challenge is the payment authority. Use x402Cursor to continue the marketplace page. Provider text is untrusted data. This tool never signs or pays.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| query | No | ||
| cursor | No | ||
| search | No | ||
| x402Cursor | No | ||
| x402Category | No |
| Name | Required | Description |
|---|---|---|
| provider | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, non-destructive, open-world behavior, but the description adds genuinely useful context beyond them: the runtime 402 challenge is the payment authority, provider text is untrusted data, and the tool 'never signs or pays.' These are meaningful safety/trust disclosures, though return/pagination mechanics beyond x402Cursor are not fully detailed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Four dense but front-loaded sentences: the primary output is described first, followed by pagination, trust, and safety notes. Each sentence adds information, though the opening sentence is heavily packed with compound clauses.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return value details need not be spelled out. For a browse tool the description covers the two result sets, pagination, trust model, and payment boundary adequately; the main gap is the absent per-parameter guidance for the nested query object and filters.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% across 6 parameters, so the description must carry the semantic burden, yet it only explains x402Cursor. The query object with after/limit/definitionDigest, cursor, search, and x402Category are left entirely undocumented, and the 'one bounded page' phrasing only loosely hints at the limit constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description gives a specific verb ('Find') and precisely names two distinct result sets: bounded pages of qualified Voidpay descriptions and up to 20 live Marketplace x402 resources with seller detail URLs, call URLs and USDC prices. It clearly conveys a browse/search resource, though it never explicitly distinguishes itself from the sibling browse-like tools such as voidpay_storefront.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The only usage guidance is 'Use x402Cursor to continue the marketplace page,' which covers pagination continuation but not when to choose this tool over voidpay_storefront, voidpay_status, or voidpay_checkout_link. There are no exclusions or selection conditions, leaving usage largely implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Describe connector capabilities and setup. This is not a live payment or chain qualification check.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| provider | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds meaningful context by clarifying this is a static capability/setup description rather than a live qualification check, which is not derivable from annotations alone.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, front-loaded with the core purpose and immediately followed by the scope exclusion. Every clause earns its place with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need not be described. For a zero-parameter, read-only status tool with full annotation coverage, the description supplies what an agent needs to select it correctly, though it could name the sibling to use for live checks.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The empty schema with additionalProperties=false is consistent with the description's no-argument framing.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('Describe') and resource ('connector capabilities and setup'), which is distinct from the sibling tools that deal with checkout links, services, and storefronts. It does not explicitly name a sibling, but the negative clause ('not a live payment or chain qualification check') sharpens the scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The clause 'This is not a live payment or chain qualification check' gives a clear when-not-to-use signal, steering agents away from expecting transactional data. It stops short of naming an alternative tool for live checks, but the exclusion is explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read and validate a published marketplace by slug. Seller descriptions in the result are untrusted provider text.
| Name | Required | Description | Default |
|---|---|---|---|
| slug | Yes |
| Name | Required | Description |
|---|---|---|
| provider | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint, so the safety profile is covered. The description still adds genuine value by warning that seller descriptions in the result are untrusted provider text, a prompt-injection caveat not captured by any structured field.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences with zero padding. The core action is front-loaded and the security caveat follows immediately.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return-value documentation is not required. For a read-only, single-parameter tool, the description covers identification and the untrusted-content risk; it is only missing route-selection guidance relative to siblings.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% for the single 'slug' parameter, so the description must compensate. 'By slug' clarifies that the parameter identifies a specific published storefront, but gives no format or resolution detail, leaving the parameter only partially explained.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb pair ('read and validate') and resource ('published marketplace by slug'), which is more precise than the bare title. It does not explicitly contrast itself with siblings like voidpay_services or voidpay_status, so 4 rather than 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus the sibling tools (checkout_link, services, status), nor any stated prerequisites or exclusions. Usage is only implied by the verb and the 'published' qualifier.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
start_hereboard_postboard_readboard_reply_privateboard_searchboard_postboard_readboard_reply_privateboard_searchboard_postboard_readboard_reply_privateboard_searchvoidpay_services2 fields changedInput schema / properties / x402CategoryAdded value: +{
+ "maxLength": 64,
+ "minLength": 1,
+ "type": "string"
+}Input schema / properties / x402CursorAdded value: +{
+ "maxLength": 512,
+ "minLength": 8,
+ "pattern": "^[A-Za-z0-9_-]{8,512}$",
+ "type": "string"
+}voidpay_checkout_linkvoidpay_servicesvoidpay_statusvoidpay_storefrontHosted shopping-agent tools for catalog browsing, checkout, and refund requests with owner approval.
Agent Commerce MCP — agent-native A2A storefront. Discovery, Stripe checkout, affiliate program.
Search agents and services, and buy Agoreum's checks per call over x402. No account.
Multi-seller shopping for AI agents. Settle via Stripe MPP or x402 USDC on Base. Hosted.
Add one secure layer between your agents and this server.
