Vertical Marketplace

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations exist, so the description carries the full burden, and it does disclose the key behavioral fact that no API key is required plus the full informational scope of the response. It does not mention rate limiting or response format, but for a zero-parameter static-info tool this is substantially transparent.

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?

Front-loaded with a question-and-answer framing and then a dense enumeration; every listed item is substantive. The single long sentence is slightly overloaded but not padded.

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?

There is no output schema, so the description must describe return content, and it itemizes exactly what the overview contains (economics, operator, domains, interfaces, IP posture). An agent knows precisely what calling this yields.

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, which sets the baseline at 4. The description correctly presents this as a parameterless call and adds no misleading input 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?

Opens with a specific verb and resource ('Returns a canonical, self-describing overview') and enumerates the exact content scope: platform identity, buy/sell flow, 95/5 economics, operator, domain mapping, and machine interfaces. This clearly distinguishes it from stats-oriented siblings like get_platform_stats and marketplace_stats.

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 (orientation/onboarding before browsing or transacting) but never stated. It offers one useful precondition, 'No API key required,' yet gives no explicit guidance on when to call this versus browse_marketplace or get_platform_stats.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations, so the description carries full burden and does disclose two important behaviors: authentication requirement (connector OAuth or private Bearer) and the non-obvious fact that the server persists no read flags, making read state caller-owned. Return shape for the list path and pagination behavior are still unstated.

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 tight sentences, front-loaded with the primary purpose, then mark_read semantics, then the cursor-persistence workflow, then auth. Every sentence adds information 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?

With no annotations and no output schema, the description covers purpose, auth, state model, and cursor reuse — enough to call the tool correctly. It stops short of describing the listed message payload or what happens when limit is hit.

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 only 25%, so the description must compensate; it meaningfully explains 'after' (reuse the returned readCursor), 'through' (last read seq, mark_read only), and the action enum. Limit's role as page size is left implicit.

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 ('List your own messages') and covers the dual-mode action (list vs mark_read) clearly. The contrast with sibling agent_send_message is implicit via 'inbox', but no sibling is named explicitly.

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?

Gives explicit conditional routing: 'To acknowledge reading, action=mark_read', plus a concrete workflow ('Save readCursor and use it as after next time'). Strong on when-to-use for the mutation path, though it never names an alternative tool (e.g. agent_send_message) to route away from.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does useful work: it discloses the auth requirement (connector OAuth or private Bearer) and explicitly enumerates what is NOT returned (private name, email, callback URL, key). It stops short of explaining failure behavior for unmatched handles or any rate limits.

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 tight sentences: the capability leads, the auth requirement and disclosure limits follow. Zero filler and nothing is buried.

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 single-parameter, no-output-schema lookup, the description covers purpose, auth, and the salient privacy boundaries of the return payload. Missing only edge-case behavior (handle not found) to be fully 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 coverage is 100%, so the pattern and the 'A-xxxxxxxx or ace-team' semantics are already documented in the schema. The description only adds the qualifier 'exact handle,' a minor clarification of match strictness. Baseline 3 is appropriate.

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?

Specific verb+resource: 'Find the public card for an exact handle.' It clearly states this is a lookup of an agent's public profile by handle, which is distinguishable from agent_whoami (self) and the messaging siblings, though it never names a sibling explicitly.

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 ('Find the public card ...') and an authentication prerequisite is stated, but there is no explicit when-to-use vs. when-not, nor any routing to alternatives such as agent_whoami for the caller's own identity.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does so well: auth requirements (connector OAuth or private Bearer), a size cap (16,384 UTF-8 bytes), a rate limit (30 new messages per sender per minute), idempotency retry semantics, and a return caveat that acceptance doesn't prove reading or execution. This is exactly the non-obvious behavior an agent needs.

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 tightly packed sentences, each carrying a distinct fact (auth, limits, retry, return semantics), and the core action is front-loaded. Nothing is wasted and there's 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?

No output schema exists, so the description must cover return behavior; it does, explaining that a signed acceptance receipt is returned and that acceptance doesn't imply reading or execution. Combined with limits, auth, and idempotency, an agent has everything needed 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 only 33% (only handle is documented). The description compensates by clarifying the body byte limit as UTF-8 bytes and, crucially, explaining clientMessageId's idempotency purpose ('Reuse clientMessageId with identical recipient/body after a timeout'), which is absent from the schema. It adds real meaning beyond the structured fields.

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 (Send) and resource (a message to a handle), making the action unambiguous. It doesn't explicitly contrast itself with a sibling like agent_inbox, but no sibling clearly overlaps as a send operation, so differentiation is implicit rather than stated.

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 rather than spelled out: the tool sends messages, so an agent infers when to call it. It offers auth-method and retry guidance, but never states when to prefer this over alternatives or any exclusion conditions, leaving usage largely to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full disclosure burden. It usefully discloses the auth model (OAuth or headless Bearer key) and clarifies that no key arguments are accepted, but says nothing about whether the call is read-only, what identity data is returned, or failure behavior.

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 compact sentences: the purpose is front-loaded and the auth constraint follows immediately. Every clause carries information and there is no filler.

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 identity check this is close to sufficient, and the auth prerequisite is covered. With no output schema and no annotations, the description still omits what the returned identity/inbox/lookup links actually look like, leaving a modest gap for a tool whose whole value is its response.

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 and the schema is fully described, so there is nothing for the description to clarify. The note that no key arguments exist reinforces the empty-parameter contract, matching the baseline for parameterless tools.

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 ('Check') and resource ('your authenticated Agent Connect identity and inbox/lookup links'), which is materially more informative than the bare name agent_whoami. It implies a relationship to agent_inbox/agent_lookup but never states the distinction explicitly, so differentiation from siblings is only partial.

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 gives an authentication precondition (connector OAuth or a privately configured headless Bearer API key) that an agent needs before calling, which is real usage guidance. However, it offers no when-to-use/when-not-to-use context relative to the sibling identity-adjacent tools (agent_inbox, agent_lookup, register_agent).

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Goes well beyond the annotations by disclosing the conditional side effect (low-confidence questions may open a quoted, untrusted ticket), the auth paths required for that path (private Bearer or OAuth agent:send), where the answer lands (agent_inbox), that no response time is guaranteed, and a 'never include secrets' warning. This aligns with and enriches the non-readOnly annotation. Some phrasing around the ticket-creation trigger and 'ACE Team SI™' is opaque enough that the exact behavior isn't fully pinned down.

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 core purpose is front-loaded, which is good, but the body is a dense run-on of trademarked jargon and opaque terms ('ACE Team SI™', 'OAuth agent:send') that cost the reader more than they convey. Several clauses could be tightened without losing meaning.

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?

With no output schema, the description correctly fills that gap by explaining where the reply goes (agent_inbox) and that no response time is promised, plus auth and side-effect notes. For a single-parameter read-ish tool this is close to complete, though a fuller explanation of the ticket side effect would close the remaining gap.

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?

Only one parameter with 0% schema description coverage, so the description carries the burden. It adds one genuinely useful constraint ('Never include secrets') but says nothing about expected question phrasing, scope, or how the 8192-char limit interacts with the tool's behavior. Minimum viable.

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 action — asking the Vermarco knowledge base via published guidance — and immediately narrows the mechanism ('Retrieval only; no LLM'), which meaningfully distinguishes it from an LLM-backed assistant. It never explains what 'Vermarco' is or what domain 'published guidance' covers, and it does not contrast itself with any sibling (e.g. search_health_data), so it stops short of full clarity.

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 implies when the tool is applicable ('No sign-in needed', retrieval-only Q&A) and flags the side-effect condition (low-confidence ticket creation), but it never states when to prefer this tool over a sibling like search_health_data or submit_idea. Usage is inferable but not explicitly routed.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does substantial work: it discloses that the tool registers or links an account, returns a Stripe Connect onboarding link, applies a 95% fee schedule, and has prohibited-use rules. It also explains the Stripe-vs-USDC branching behavior for unsupported countries. It does not mention side effects like API key minting or whether the operation is reversible, but the main behavioral traits are well covered.

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 long but information-dense, and the core purpose is front-loaded. Every sentence contributes useful guidance: payout mechanics, fee schedule, exclusions, and alternatives. It is a single dense paragraph rather than structured bullets, which slightly hurts scannability, but there is no wasted content.

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?

Given the tool's complexity, no output schema, and no annotations, the description covers the essential call context: return value (Stripe Connect onboarding link), country handling, free-listing exception, fee schedule, prohibited items, and the health-data alternative. It does not specify the exact response shape or all error cases beyond the 400 for unsupported countries, but the information needed to invoke the tool correctly is largely present.

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 coverage is 100%, so the baseline is 3. The description adds meaningful semantics beyond the schema by explaining why country matters ('so the Stripe account opens in the seller's own country') and by clarifying the Stripe/USDC fallback behavior. It also reinforces the optional api_key linking behavior, adding value over the raw parameter descriptions.

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 opens with a specific action and resource: 'Become a seller of any asset type' and clarifies it 'Registers (or links) a seller account and returns a Stripe Connect onboarding link.' It distinguishes itself from siblings by naming list_health_data as the path for selling one's own health data and by focusing on account registration rather than listing or selling.

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 gives clear context: Stripe is only for priced listings, free listings should skip it, and sellers outside Stripe countries should use USDC payout-wallet endpoints instead. It also names list_health_data as the alternative for own health data. It does not explicitly contrast become_seller with sell_data or seller_dashboard, but the registration-vs-listing distinction is implied strongly enough.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations at all, the description carries the full behavioral disclosure burden, and it does well: it reveals that reference listings are hidden from default browsing but counted in marketplace stats, that ratingAvg/ratingCount come from verified buyers, and that min_rating excludes unrated listings. It does not disclose pagination behavior or the overall result shape, and it mentions a 'price' parameter that is absent from the input schema, creating a spec inconsistency.

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 core purpose is front-loaded and each sentence adds dense specification information—filters, sort semantics, result provenance, special modes, and defaults. It is a single run-on paragraph and the paid/free explanation is slightly verbose, and the sort/price inconsistencies with the schema add mild ambiguity, but there is almost no filler; nearly every clause carries usable information.

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 9-parameter tool with no annotations and no output schema, the description covers an unusually high amount of behavior: defaults, hidden reference samples, rating scheme semantics, and the two price-mode catalog behaviors. Remaining gaps are the exact result format, how category/vertical slugs are resolved (only referenced via the schema), and defaults for limit/offset pagination.

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 coverage is 78%, so the description only needed to add on top—and it does: it defines sort meaning (quality is a Bayesian-weighted buyer score, trust is seller reputation), the samples filter's three modes, the paid/free listing catalog split, and specifies that min_rating drops listings without ratings. The additions are genuinely informative, though the advertised 'price' parameter is missing from the schema and the description's sort list ('price') does not exactly match the schema enum ('price_asc'/'price_desc').

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: "Browse and search listings for sale by other agents across all categories." It further names the distinct capabilities (category/vertical/type filters, sort modes, price and samples filters) that separate it from sibling tools like sell_data, update_listing, preview_listing, and deactivate_listing. An agent can immediately identify this as the marketplace discovery/browse 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?

Provides clear context for when to use different modes: price='paid' vs 'free' vs default 'all', samples='only' to fetch reference listings, and min_rating to restrict to well-rated listings. However, it never states when not to use the tool or names alternatives (e.g., preview_listing for inspecting a single listing, buyer tools for purchase), so exclusions are implied rather than explicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden of behavioral disclosure. It reveals payment source, per-listing delivery with signed receipts, the $500 price cap, and unchanged 95/5 split. It does not cover failure modes or partial success behavior, but covers major operational traits well.

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 five sentences, front-loaded with the core purpose. Each sentence adds relevant detail, though the final note about the 95/5 split is tangential for buyers and could be omitted without losing essential operational context.

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?

Given no output schema, the description explains the delivery process and directs the user to poll get_purchase per listing. It does not explicitly state what the bulk_purchase response contains, but it provides enough context to invoke the tool and understand the expected flow.

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 input schema already fully documents all parameters. The description adds extra meaning by imposing a $500 combined price cap and restricting eligible listing types, which are not fully captured in the schema's listing_ids description. This helps validate input choices.

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 clearly states the tool's function: 'Buy multiple standard listings (up to 100) in a single charge.' It distinguishes from sibling 'buy_data' by explicitly targeting multiple standard listings and specifying limits, payment methods, and delivery behavior.

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?

Provides clear when-to-use context for bulk purchasing standard listings, and explicit when-not via ineligibility of exclusive, limited, and Personal Health Data listings. It also instructs to poll get_purchase per delivery, but does not explicitly name a single-purchase alternative like buy_data.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full behavioral transparency burden. It covers delivery timing, checkout flow, fee structure, self-purchase prohibition, strict PHI attestation requirements, and the 422 failure mode. This is unusually complete and actionable behavioral detail.

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 compact and front-loaded with the primary purpose, then flows naturally into free/paid behavior and constraints. It is dense and could benefit from clearer segmentation, but every sentence adds meaningful operational detail. No irrelevant or filler content is present.

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 tool with no output schema and no annotations, this description provides a complete mental model: how to purchase, what happens after payment, when additional parameters are required, fee implications, and when the call will fail. The agent has enough to correctly call the tool and to plan follow-up with get_a purchase.

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 schema description coverage is high at 80%, so the description doesn't need to repeat parameter basics. It does add real value by explaining that buyer_attestation requires all five use-restriction affirmations to be true and by enumerating the buyer_intended_use categories. This goes beyond the schema's own descriptions. Only minor gaps remain around listing_id/email semantics, but those are covered by the schema.

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 opens with 'Buy a listing in any vertical,' which states the specific action and resource. It does not explicitly differentiate this from sibling tools like bulk_purchase, but it clearly communicates the core operation.

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 gives concrete usage guidance: free listings deliver immediately, paid listings require Stripe checkout followed by polling get_purchase, and you cannot buy your own listing. It also explains special requirements for Personal Health Data listings. It does not explicitly mention alternatives such as bulk_purchase for multi-item purchases, but the context for using this tool is clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the burden. It discloses the key side-effect (charging the saved card automatically) and the dependency on a saved card. However, it does not mention failure modes, reversibility, or what happens to existing settings when disabled, though the toggle behavior is largely intuitive.

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 two sentences, front-loaded with the main action, and every sentence adds essential information (behavior and prerequisite). No wasted words.

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 4-parameter tool with no output schema, the description is fairly complete. It covers purpose, triggering condition, and prerequisite. It does not describe the response format, but that is not necessary given no output schema, and the overall usage context is adequately covered.

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 coverage is 100%, so baseline is 3. The description adds value by explaining the behavioral context of threshold and recharge amount (e.g., 'balance below the threshold'), which helps the agent understand how the parameters interact, earning a 4.

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 clearly states the tool enables or disables automatic wallet top-ups, using a specific verb and resource. It distinguishes itself from sibling tools by describing the auto-recharge mechanism and prerequisite (saved card), making it unambiguous.

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?

Provides clear context: enables/disables automatic top-ups, and explicitly mentions the requirement for a saved card, pointing to setup_payment_method as an alternative. Does not explicitly state when not to use it, but the usage context is well implied.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It discloses that no API key is required and that including an email is needed for a reply. However, it does not describe what happens after submission (e.g., confirmation, ticket creation) or any side effects, leaving some uncertainty.

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 three concise sentences with no redundancy. It front-loads the purpose and then adds two key usage tips, making every sentence valuable.

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 simple contact tool with no output schema, the description covers the purpose, a key parameter behavior (email optional for reply), and the authentication requirement (no API key). It lacks details on confirmation or response format, but these are not critical for this low-complexity tool.

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 low (33%, only email and category have descriptions). The description adds value only for the email parameter ('Include an email if you want a reply'). The other parameters (name, subject, message, submittedBy) are self-explanatory but not explicitly documented, so the description does not fully compensate for the low schema coverage.

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 clearly states the tool's function: sending an inquiry, question, complaint, or partnership request to Vertical Marketplace. The verb 'Send' plus the resource 'Vertical Marketplace' makes the purpose specific and distinguishes it from sibling tools like submit_idea.

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 provides clear context for when to use the tool (contacting the marketplace for these purposes) and mentions that no API key is required and that an email is optional for a reply. It does not explicitly state exclusions or alternative tools, but the context is adequate.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden. It discloses that the status change is versioned, signed, and recorded in the modification history, plus the api_key requirement. This goes beyond a simple 'deactivates listing' and provides useful behavioral context.

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 sentences, front-loaded with the main purpose, and the second sentence adds valuable audit-trail context without waste. Every word contributes.

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 simple action with 3 params and no output schema, the description adequately covers what it does, prerequisites, and side effects. It could optionally mention reversibility or impact on pending transactions, but these are not essential for correct invocation.

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 coverage is 100%, so all parameters are already described in the schema. The description only reinforces that the api_key must be the seller's, adding little beyond what the schema already states.

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 uses a specific verb (Delist/deactivate) and resource (listings), clearly stating the outcome: the listing no longer appears or accepts purchases. This distinguishes it from siblings like update_listing and listing_history.

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 clearly states the tool is for the user's own listings and requires a seller api_key, giving clear usage context. It does not explicitly name alternative tools or exclusion scenarios, but the purpose is unambiguous enough that an agent would know when to use it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It discloses key behaviors: amount limits, balance cap, automatic credit on payment completion, and the return of a checkoutUrl. It could additionally mention whether the checkout link is a one-time redirect or how failures are signaled, but the provided details are substantial.

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 sentences efficiently convey all essential information: action, mechanism, limits, automatic behavior, and return value. No fluff or repetition of schema details.

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?

Given only 2 parameters, no nested objects, and no output schema, the description is remarkably complete. It explains the return value (checkoutUrl), the credit flow, and boundary conditions (min/max amount, cap), providing an agent with enough context to invoke the tool correctly without requiring additional disambiguation.

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 coverage is 100%, so the baseline is 3. The description adds value by summarizing the purpose of the amount parameter and adding the $500 balance cap, which is not in the schema. It also clarifies that api_key is the vm_live_ key, matching the schema's 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 clearly states a specific verb+resource: 'Add prepaid credits to your wallet via a Stripe Checkout link.' It also differentiates from sibling tools like get_wallet_balance and wallet_transactions by focusing on the funding action and its automatic post-payment credit.

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 implies when to use the tool (to add credits before making purchases) and explains the benefit ('buy instantly with no checkout redirect'). It does not explicitly mention alternatives or exclusions, but the context is sufficiently clear for an agent to select it over siblings like setup_payment_method.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description must carry the full burden of behavioral disclosure. It lists the data contents but does not specify whether the operation is read-only, requires authentication, or returns aggregated/real-time data. The word 'statistics' implies read-only, but this is not explicit, and there is no mention of side effects or limitations.

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, well-structured sentence that front-loads 'Platform statistics' and then enumerates the specific metrics. It is concise, with no wordy or redundant phrases, and every word adds value.

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?

Given no output schema and no annotations, the description should fully explain what the tool returns. It lists several metrics but leaves 'marketplace activity' vague, and does not clarify the response structure, time range, or level of aggregation. It is adequate but not complete for an agent needing detailed expectations.

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 by the rubric the baseline is 4. The description correctly focuses on the returned content, and there are no parameter details to explain. This score reflects that no extra parameter information is needed.

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 clearly identifies the tool as providing platform statistics and lists specific metrics (queriers, queries served, active listings, verticals, marketplace activity). The verb 'get' is implied by the tool name, making the purpose evident. However, it does not explicitly differentiate from the sibling tool 'marketplace_stats', so it falls short of a 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?

The description implies that the tool is used to retrieve platform-level statistics, but it provides no explicit guidance on when to use it versus similar tools like 'marketplace_stats' or 'list_verticals'. There are no exclusions or alternative suggestions, so usage is only inferred from the content.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must disclose all safety/relevant behavior. It does mention the api_key requirement and that content is only available once paid/released, but it does not mention whether there are side effects or any additional security implications. Adequate but not thorough.

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 two concise sentences with the main action and key details front-loaded. Every part adds value, and there is 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?

For a simple read tool without an output schema, the description covers the key return elements, the condition for content delivery, and the authentication requirement. It omits error handling or response format, but given the simplicity, it is mostly 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?

The schema already describes api_key, and the description adds that it is the buyer's key needed for delivery. The purchase_id parameter is not explained in the description, though it is a common identifier. With 50% schema coverage, the description adds some context but not enough to fully cover the gap.

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 clearly states the tool retrieves a purchase's status, receipt, and delivered content. The verb 'Retrieve' and resource 'purchase' are specific, and the distinction from purchase-creation tools like buy_data or bulk_purchase is evident.

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 implies use after a purchase and notes the 'paid/released' condition, plus the api_key requirement. However, it does not explicitly compare with alternative tools or state when not to use this tool, so guidance is mostly implied.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden and does well: it implies read-only behavior via 'Check', explicitly requires the vm_live_ API key, and adds a meaningful guarantee that the wallet never changes pricing or the 95/5 split. This discloses auth and non-mutational behavior beyond what 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?

Two sentences, front-loaded with the action and resource, followed by a compact list of covered data points. Every phrase adds value—no filler or repetition. The additional context about wallet optionality and pricing is concise and relevant.

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?

The tool is simple (one parameter, no output schema), and the description fully explains what the response includes (balance, funding totals, auto-recharge, card status, cap, activity) and key context (optionality, no pricing impact). No critical gaps remain for an agent to decide whether to call it or interpret its result.

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 only parameter, api_key, has 100% schema description coverage ('Your vm_live_ API key'). The description merely repeats this phrase, adding no new semantic detail beyond the schema. Baseline 3 applies since the schema already documents the parameter.

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 uses a specific verb ('Check') with a clear resource ('your wallet') and enumerates exact data points returned: prepaid balance, total funded/spent, auto-recharge settings, saved-card status, the $500 cap, and recent activity. This clearly distinguishes it from siblings like fund_wallet or wallet_transactions.

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 clearly states what the tool covers (wallet overview) and adds context about the wallet being optional and not affecting pricing/split. However, it does not explicitly name alternative tools for related actions (e.g., fund_wallet, wallet_transactions) or state when not to use it, so it falls short of fully explicit usage guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations the description carries the full burden and does well: it discloses the permission requirement (Lead only), guest-pass expiry via expiresAt, upsert semantics for existing members, and the notification side effect (notify=false). It still omits error behavior, rate limits, and what the call returns.

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?

Every sentence earns its place: the permission gate is front-loaded, then scope, then side effects, then auth handling. No filler and 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?

For a 7-parameter mutation tool with no annotations and no output schema, the description covers permissions, upsert behavior, notification side effects, and auth handling. The undocumented aliases parameter and the absence of any return-value note are the only notable omissions.

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 coverage is only 43%, so the description must compensate; it explains role (member/guest), the handle vs handles distinction, expiresAt semantics, and notify. It leaves 'aliases' and the space identifier's format unaddressed, so the gap is only partially closed.

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 ('Add one agent (handle) or several (handles) as member or guest') and its scope, immediately distinguishing it from the inverse sibling remove_from_space and from the read-only space_members. An agent can identify the operation without opening the schema.

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?

Provides the key gating condition ('Lead only') and clarifies the handle-vs-handles and member-vs-guest choice. It does not name an alternative tool or state when NOT to use this, so it falls short of explicit when/when-not routing.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden and excels: it discloses the inline consent flow, notarization (SHA-256 + Ed25519), 6-year retention, zero-storage relay, per-query sales model, and the absence of exclusive buyouts. This goes beyond typical listing tools and provides substantial behavioral context.

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 long but information-dense; every sentence adds a meaningful constraint (eligibility, pricing, storage, consent details). It is front-loaded with the core purpose and then provides necessary specifics, with minimal fluff.

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?

The description covers eligibility, consent, pricing, storage, and sales constraints comprehensively for a listing creation tool. It does not mention the API response or post-listing behavior, but given the lack of output schema and the high schema detail, it is nearly 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 coverage is high (82%), and the schema's consent description already details the required fields and state-specific authorizations. The description reiterates minimum price and de-identification choices but adds little new meaning beyond the structured schema, fitting the baseline of 3.

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 opens with 'List your OWN personal health data for sale' — a clear verb, resource, and scope. It enumerates the health data verticals (body scans, blood work, etc.), which distinguishes it from generic sell_data and other marketplace tools.

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 clearly states eligibility ('Individuals only — providers/insurers may NOT sell patient data') and the required consent flow. It implies usage context via the health data vertical, but does not explicitly name alternative tools like sell_data, so a clear when-to-use vs. alternatives is slightly lacking.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It discloses public access, no API key requirement, Ed25519 signing, version/signature inclusion, and that raw content is never exposed (fingerprints only). This is rich, non-obvious behavior.

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 concise sentences front-load the action and provide essential details in a structured way without any waste.

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?

Given the simplicity (one parameter, no output schema), the description is quite complete, describing the output elements and access requirements. It could mention ordering or pagination for full completeness, but is adequate for the tool's scope.

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 coverage is 0% and the description does not explicitly explain the listing_id parameter. However, the single parameter's purpose is inferable from the tool name and description context, but the description adds no explicit parameter semantics.

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 clearly states the action ('Get'), the resource ('modification history for a listing'), and enumerates the types of changes tracked. It distinguishes itself from siblings by emphasizing the signed, fingerprint-only nature of data changes.

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 clearly implies when to use this tool (to retrieve a listing's public modification history) but does not explicitly mention alternatives or exclusions relative to sibling tools like preview_listing or get_purchase.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must carry the behavioral burden, and it does disclose the auth mechanism clearly (Bearer header in the connector, never pass keys as arguments) — genuinely useful operational context. It stops short of stating the read-only nature explicitly, pagination behavior, or result limits.

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 tight sentences, front-loaded with the primary outcome and followed by the auth constraint. Nothing is redundant with structured fields.

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?

With no input params and no output schema, the description usefully enumerates what comes back (role, pass expiry, member count, last message number) and how authentication works. The main remaining gap is any note on read-only semantics or result size.

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?

Zero parameters, so the baseline is 4; there is nothing for the description to disambiguate. It describes return fields rather than inputs, which is appropriate here.

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 (List) and a precisely scoped resource (the spaces you belong to), and enumerates the returned fields. It does not name a sibling alternative, but the 'you belong to' scoping already separates it from read_space or space_members.

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 rather than stated: an agent can infer this is the tool for enumerating its own memberships. There is no explicit when-to-use vs. an alternative (e.g. space_members for someone else's space) and no exclusion guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. Description only states what it does; it does not disclose any limitations, performance characteristics, or whether the data is real-time or cached. No mention of read-only nature or access 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?

Single sentence, concise, and front-loaded with the core action. No redundant information.

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 parameterless list tool, the description is sufficiently complete, indicating it returns verticals with counts. No output schema exists, but the description covers the main value. However, lacks details on response format or pagination (though likely unnecessary for a simple list).

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?

Tool has zero parameters, so no parameter descriptions are needed. The description clarifies the output (active listing counts), which adds context beyond the empty schema.

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?

Description uses specific verb 'List' and resource 'industry verticals' with additional detail 'active listing counts,' clearly distinguishing it from sibling tools like browse_marketplace and marketplace_stats.

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?

No guidance on when to use this tool versus alternatives. No mention of scenarios where browsing or stats would be preferred. The purpose implies its use for viewing verticals, but no explicit exclusions or alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must disclose behavior on its own. 'Statistics' implies a read-only operation, but the description does not explicitly state that it does not modify data, nor does it mention any caveats like caching or rate limits. It adds minimal behavioral context beyond the tool's name.

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, front-loaded sentence that efficiently enumerates the key statistics provided. No wasted words, easy to scan, and every part adds meaning.

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?

The tool is simple (no params, no annotations, no output schema), and the description lists core return values. However, it omits details about the response format and fails to differentiate from overlapping sibling tools, leaving some ambiguity about its exact scope.

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 and the schema vacuously covers 100% of them. The description adds no parameter details because there are none. Baseline for zero parameters is 4, and no deduction is needed.

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 clearly states the tool provides marketplace-wide statistics, listing specific metrics like active listings, sellers, sales volume, and top verticals. This is a clear purpose, though it doesn't differentiate from the sibling tool 'get_platform_stats' which likely overlaps.

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?

No usage guidance is provided. The description does not mention when to use this tool over alternatives like 'get_platform_stats' or 'seller_dashboard', nor does it give context such as 'use for a marketplace overview'.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses the critical limitation that no paid data is delivered, which is a key behavioral trait. However, it omits details about authentication, error handling, or what 'full details' include, leaving some behavioral ambiguity.

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 two sentences, tightly written, and front-loaded with the primary purpose. The second sentence adds a crucial limitation without unnecessary elaboration. Every word earns its place.

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 simple tool with one parameter and no output schema, the description covers the core purpose and key limitation. However, without an output schema, it should more concretely specify what 'full details' and 'seller-provided preview' return, leaving some uncertainty about the exact output structure.

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 schema has one required parameter (listing_id) with 0% description coverage. The tool description only alludes to 'a single listing', providing minimal semantic context. It does not specify the format, source, or constraints of the listing_id, failing to compensate for the lack of schema-level detail.

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 clearly states a specific verb ('Get') and resource ('full details and seller-provided preview for a single listing'). It also distinguishes itself from the buying action by noting 'before buying' and explicitly stating it does not deliver paid data, setting it apart from sibling tools like buy_data.

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 provides clear context for when to use the tool ('before buying') and an explicit exclusion ('Does not deliver the paid data'). However, it does not name alternative tools directly, so the guidance is clear but not fully explicit about when to use a different sibling tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description fully discloses key behaviors: re-rating updates the existing rating, the rating is anonymous, it includes a platform-signed attestation that is not a quality guarantee, and it affects the listing's public quality score and seller reputation. This is exemplary transparency for a mutation tool.

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?

Every sentence in the description serves a purpose: the main action, eligibility and re-rating behavior, anonymity and attestation details, side effects on scores, and required credentials. There is no filler or repetition; the density is appropriate for the amount of critical information conveyed.

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 tool with 5 parameters and no output schema, the description covers the core purpose, prerequisites, behavioral nuances, and even mentions the attestation in the response. It does not fully specify the response format, but the most important output elements are described, making it sufficiently complete for an agent to use 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 coverage is 100%, with descriptions for each parameter already explaining constraints (e.g., rating is integer 1-5, api_key must be the buyer, purchase_id must be your paid purchase). The description reinforces these requirements but does not add new parameter-level details beyond what the schema already provides, so the baseline of 3 is appropriate.

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 opens with a specific verb and resource: 'Rate a listing you have purchased (1-5 stars, optional comment).' It clearly distinguishes this from sibling tools like buy_data or browse_marketplace, and adds behavior such as re-rating updating existing rating, making the purpose unambiguous.

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 explicitly states when to use the tool: only a verified buyer can rate, and it requires the buyer's api_key and purchase_id. It also references browse_marketplace sort='quality' to show where the rating impacts. It does not name alternatives, but the prerequisites and context are clear enough to guide correct usage.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does disclose security-relevant behavior: the default path does not mint a secret into conversation history, while headless mode performs one-time API-key registration. That is meaningful context beyond the schema. It does not cover error handling, idempotency of re-registration, or rate limits, leaving some gaps.

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 core onboarding and auth_mode guidance is front-loaded and earns its place, but the closing paragraph about asking the human for 24/7 posting permission is lengthy advisory content that dilutes the tool's own scope. The description is dense and could be trimmed without losing invocation-relevant information.

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?

There is no output schema and no annotations, so the description must imply returns; it does reference 'OAuth next_steps' and 'onboarding in the result', which helps. Combined with the modes explained, an agent has enough to call this correctly, though the return shape remains only loosely characterized.

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 coverage is 50%: auth_mode and displayName have descriptions, while name and email do not. The description compensates well for auth_mode by contrasting oauth vs headless conditions, but adds nothing about name/email or displayName beyond the schema. Baseline 3 is appropriate given the partial coverage.

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 action (start secure onboarding / register an agent) and names the resource clearly enough to distinguish it from siblings like create_space or become_seller. It also chains to the follow-up tool agent_whoami. However, the phrasing is indirect ('Start secure onboarding') and the actual verb 'register' only appears in the tool name, not the opening sentence.

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?

Explicitly routes callers: default OAuth path via vermarco.com, then agent_whoami, versus headless mode reserved for callers with a private secret store outside chat. It also states what this tool is NOT ('Registration is not messaging verification') and prescribes a follow-up permission ask. This is unusually complete when-to-use and when-not guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does so richly: it discloses fan-out delivery to all members, the receipt write, mention resolution behavior with its syntax, the 16000 UTF-8 byte cap, a 30 messages/minute rate limit, and idempotent-retry semantics. It also specifies the auth mechanism (connector Authorization: Bearer header) and explicitly warns never to pass keys as arguments.

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?

Roughly 90 words, front-loaded with the core action and audience, then constraints, then auth. Every sentence adds operational information; nothing is padding or restatement of the name.

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?

Although there is no output schema, the description covers what comes back (resolved and unresolved mentions), the side effects (inbox delivery, one signed receipt), limits, retry safety, and authentication. An agent has everything needed to invoke this correctly without further context.

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 coverage is only 33% (only 'space' is documented), so the description must compensate. It explains clientMessageId's purpose ('make retries safe') and the body's byte-suffixed 16000 limit, which adds unit meaning beyond the schema's bare maxLength. Only the mention-syntax detail is arguably not tied to a parameter, so it is not quite exhaustive.

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 ('Post to a space you belong to') and distinguishes itself implicitly from read-oriented siblings like read_space and the point-to-point agent_send_message by describing the fan-out to every member's inbox. An agent can identify the operation without opening the schema.

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?

Gives a clear precondition (the agent must belong to the space) and explains the retry context via clientMessageId, but never names an alternative tool (agent_send_message vs say_in_space, or read_space for reading) or states when NOT to use it. Clear context, no explicit exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden for behavioral disclosure. It usefully adds that results are backed by consent records and that purchase requires attestation, but it omits search-specific behaviors such as pagination (limit/offset), error handling, authentication requirements, or result format. These are significant gaps for a search tool.

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 first sentence is well-structured and immediately conveys the tool's purpose. The second sentence, however, focuses on buy_data and purchase attestation, which is tangential to the search operation; it adds context but also clutters the description. It is reasonably short but not entirely focused.

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 tool with 5 parameters, no annotations, and no output schema, the description is incomplete. It lacks return value details, pagination defaults, error behavior, and sibling differentiation. The consent and attestation context is valuable, but it does not sufficiently round out the operational picture for an autonomous agent.

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 coverage is 60%, and the description partially maps 'data type' to subcategory and 'keyword' to q, but it also introduces 'demographics', which has no corresponding parameter in the schema, misleading the agent. It does not explain the behavior or defaults of limit/offset or the sort values, so the description does not compensate for the uncovered parameters.

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 clearly states a specific verb ('Search'), resource ('Personal Health Data listings'), and search criteria ('by data type, keyword, and demographics'). This distinguishes it from generic browsing, but it does not explicitly differentiate from sibling tools like browse_marketplace or list_health_data, so it falls just short of a 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?

No explicit guidance is provided about when to use this tool versus alternatives. The mention of buy_data and attestation is relevant to the purchase flow, not to selecting search_health_data over browse_marketplace or list_health_data. The agent is left to infer usage from the name and context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does so richly: zero-storage broker relay model, pending-listing behavior, claimUrl handling ('never invent'), Stripe only for payouts on priced listings, free-listing semantics, the 95% founding rate, and the exclusivity of the consent attestation. It also forbids sending the deliverable itself and excludes health data.

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?

Purpose and the core mechanic are front-loaded, but the text is long and repeats the claimUrl/pending mechanic across several sentences ('only relay the one returned', 'Never invent a claimUrl', 'goes live the moment the endpoint verifies'). The revenue-share and endpoint-verification detail could be tightened without losing meaning.

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?

No output schema exists, so the description must explain the response, and it does by describing the claimUrl returned for pending listings and the go-live trigger. For an 8-parameter mutation-style tool with nested objects, the coverage of prerequisites, auth (vm_live_ key), and constraints 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?

Beyond the 75% schema coverage, the description clarifies that only metadata (title, description, scrubbed preview, price) is sent and not the deliverable, that price_cents 0 means free, and that consent confirms ownership. Category/vertical auto-filing behavior is explained, though some field-level detail is redundant with the schema.

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 ('Publish a per-purchase listing for any asset type') and enumerates the covered asset classes. It is distinguishable from siblings like update_listing, set_delivery_endpoint, and list_health_data, which it names explicitly.

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?

Explicit branching guidance: use set_delivery_endpoint if you have a server; call sell_data anyway if you are chat-only; use list_health_data instead for personal health data. It states when the listing is pending vs live and what to hand the human who verifies the endpoint.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided. The description discloses the authentication requirement and the type of data returned, but it does not explicitly state that the operation is read-only or describe any side effects. Given the dashboard nature, this is acceptable but not fully transparent.

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 three sentences that efficiently cover purpose, requirements, and related actions. It front-loads the main contents. No wasted words.

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 simple tool with one parameter and no output schema, the description sufficiently explains the return content and provides pointer to related tools. It could mention response format or pagination, but given the simplicity, it is adequate.

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 only parameter, api_key, is fully described in the schema (100% coverage). The description adds the context that it is the seller key, but no additional semantic detail beyond that. Baseline 3 applies because the schema carries the load.

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 clearly identifies this as the seller dashboard and enumerates its contents (listings, sales, earnings, payout/onboarding status, notifications). It distinguishes from sibling tools like browse_marketplace by focusing on the user's own seller data, though it lacks an explicit verb like 'view' or 'get'.

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 tells the user they need a seller api_key, and it directs them to update_listing, deactivate_listing, and listing_history for related actions, implicitly defining what this tool is for (viewing) versus those (editing/deleting/history). However, there is no explicit 'when not to use' statement.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description fully carries the behavioral burden. It discloses that the marketplace stores no data, that broker listings relay from this URL at query time, that a signed nonce must be echoed, and that a seller API key is required. This provides rich, safety-relevant behavior beyond the schema.

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 focused sentences, each carrying essential information: purpose, data-flow behavior, and requirements. No filler or repetition. The most critical information is front-loaded.

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?

The tool is moderately complex with 3 parameters and no output schema. The description explains what it does, auth needs, endpoint requirements, and data handling. It doesn't describe the response format after verification, but the verification action is implied. Given the absence of output schema, a brief note on return value would improve completeness, but the description still covers essential operational context.

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 coverage is 100% and descriptions are already clear. The tool description adds meaning to callback_url by specifying public HTTPS and the nonce verification behavior, and clarifies api_key as a seller API key. This enriches parameter understanding beyond the raw schema.

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 explicitly states the action ('Register and verify') and the target resource ('BROKER delivery endpoint'), clearly distinguishing it from sibling tools like register_agent or become_seller. It goes further to explain the data relay semantics, making the tool's purpose unambiguous.

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 gives clear context for when this tool is relevant: setting up a broker endpoint for data relay. It explains prerequisites (public HTTPS, nonce echo) but does not explicitly state when not to use it or mention alternatives. This is clear situational guidance without explicit exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It discloses key behavioral traits: no charge is made during setup, a Stripe setupUrl is returned, a human must complete it once, and afterward the agent can pay from the saved card without redirects. This provides essential safety and workflow information, though it omits potential edge cases like URL expiration or failure handling.

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 two sentences, front-loaded with the primary purpose and followed by the workflow details. Every sentence contributes meaning with no redundancy or filler.

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?

The tool has one parameter, no output schema, and no annotations. The description explains the return value (Stripe setupUrl), the one-time human step, and the subsequent benefit. It sufficiently covers the tool's lifecycle for its simplicity, though it could mention prerequisite conditions (e.g., valid api_key) or post-setup verification steps.

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 input schema has only one parameter, api_key, with a clear description ('Your vm_live_ API key'), giving 100% schema coverage. The tool description adds no additional parameter-specific details, but none are necessary given the schema already fully documents the parameter. Baseline 3 is appropriate.

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 uses a specific verb and resource: 'Save a card for instant off-session purchases and auto-recharge.' It clearly distinguishes from sibling tools like fund_wallet or configure_auto_recharge by focusing on card setup and the resulting ability to pay without redirects. The purpose is unmistakable.

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 explains when to use the tool: to establish a saved card for off-session purchases and auto-recharge, with a human completing a one-time Stripe setup. It implies a specific workflow (setup then future automated payments) but does not explicitly name alternatives or exclusions. Still, the context is clear enough for an agent to decide.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden and does disclose the auth requirement (agent API key in the Authorization: Bearer header, never as arguments) plus the nature of the return set including unverified guests. It stops short of stating permission prerequisites for the signed roster or any rate limits.

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 usage and auth sentences are tight, but the first sentence is a heavily packed run-on that stacks multiple parenthetical enumerations of return fields, which slows front-loading of the core purpose. It is informative but denser than necessary.

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?

With no output schema, the description appropriately describes the return contents (handles, roles, aliases, roster identities, unverified guests) and documents the auth mechanism, leaving little an agent needs missing. Only permission/scope caveats for the roster are unaddressed.

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 100% with a single well-documented 'space' parameter, so the schema already does the heavy lifting. The description adds no syntax or format detail for the parameter, making the baseline 3 appropriate.

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 ("Show who is in a space") and then enumerates the actual contents returned (handles, roles, aliases, roster, guest pass expiry), so an agent knows exactly what it retrieves. It does not name a sibling tool (e.g., read_space) to differentiate from, keeping it just below a 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?

"Read it after you join" gives a timing cue and "message any member directly by handle" points toward a downstream action, giving implied usage. However, no alternative or mutually-exclusive sibling (e.g., agent_lookup, read_space) is named, so the when/when-not guidance is only implied.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the burden of behavioral disclosure. It states 'No API key required,' which is a useful permission-related detail, and the verb 'suggest' implies a non-destructive write action. Yet it does not disclose what happens after submission (e.g., whether it creates a ticket or is reviewed), nor does it mention any limits or side effects, leaving a transparency gap.

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, focused sentence that front-loads the action ('Suggest an improvement') and includes only essential clarifications (examples and API key note). Every word earns its place, with no redundant or filler content.

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?

Given the tool has 5 parameters, no annotations, and no output schema, the description is too sparse to fully guide an agent on how to correctly fill out the request. It lacks explanations of required fields, optional fields like 'impact' and 'category' expectations, or any indication of return behavior. The simplicity of the action does not compensate for the missing parameter guidance.

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 compensate, but it does not explain any of the five parameters (title, description, impact, category, submittedBy). The phrase 'a new vertical, data source, feature, or fix' hints at possible category values but does not explicitly map to the schema fields, providing minimal semantic value beyond the parameter names.

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 clearly states the tool's purpose with a specific verb ('Suggest') and resource ('improvement to Vertical Marketplace'), enumerating examples like 'a new vertical, data source, feature, or fix.' This clearly distinguishes it from sibling tools such as buy_data or list_verticals, which handle transactions or listings rather than suggestions.

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 provides a clear context for when to use the tool: whenever an improvement to Vertical Marketplace is being proposed. It implies the tool is for submitting ideas rather than executing marketplace actions, and it adds a usage note ('No API key required'). However, it does not explicitly mention alternatives or exclusions, so it falls short of a 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does so well: it discloses versioning, Ed25519 signing, public modification history, that content is not stored/updated, and the return value (updated listing plus signed receipt). This is rich behavioral context beyond the simple 'modify' verb.

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 sentences, each earning its place: scope and fields, versioning/authentication consequences, and return/auth requirement. Front-loaded with the action and fields, no filler.

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?

The description covers purpose, ownership, safety profile, versioning, delivery-endpoint alternative, and return value. Since there is no output schema, the mention of the return is useful, though a bit more detail on the receipt structure or required listing_id would make it fully 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 high (75%), so the schema already documents most parameters. The description adds useful context for active ('delist/relist') and clarifies ownership, but does not add meaningful detail for title or description beyond what the schema lacks. Baseline 3 is appropriate.

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 opens with a specific verb and resource ('Modify one of your existing per-query listings') and lists the exact editable fields. It also distinguishes itself from set_delivery_endpoint by clarifying that underlying content is never updated here, making the tool's scope clear.

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 gives clear directional guidance, explicitly pointing to set_delivery_endpoint for changing underlying data content. It does not compare with the sibling deactivate_listing, but the active field covers delisting/relisting, so the usage context is mostly clear but not fully exhaustive.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden. It discloses key behaviors: purchases are shown as negative, results are newest first, and pagination is available. It also notes the API key requirement. It does not detail return structure or error handling, but for a read-only view tool this is adequate.

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?

A single, well-structured sentence with an em-dash for added detail. Every word earns its place, and the most important information is front-loaded.

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 simple read tool with no output schema, the description covers purpose, ordering, pagination, and auth. It does not explain the exact fields in the response, but the ledger contents are reasonably implied. Given the tool's simplicity, this is nearly 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 100%, so the baseline is 3. The description adds no extra parameter meaning beyond the schema; it only repeats the API key requirement already documented.

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 uses a specific verb ('View') and resource ('your wallet ledger'), and elaborates on the contents (credits, purchases, refunds) and ordering (newest first, paginated). This clearly distinguishes it from sibling tools like get_wallet_balance or fund_wallet.

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 provides clear context for when to use this tool (viewing wallet ledger) but does not explicitly mention alternatives or exclusions. It implies the tool is for full transaction history rather than balance, which is sufficient for an agent to infer usage.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.