infobro AI tools directory

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

Annotations already declare readOnlyHint=false and openWorldHint=true, so the description's job is to explain the side effects implied by a non-read-only, open-world call. Instead it uses 'Returns', which reads like a passive read, and says nothing about whether calling it mints a persistent payment intent, whether repeated calls are idempotent, or whether links expire. The 'card or crypto, depending on what is enabled' note adds genuine context, but the mutation semantics remain undisclosed. Not a hard contradiction with readOnlyHint=false, but the framing understates the write 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 short sentences, front-loaded with the core action and with zero redundant filler. The second sentence about an assistant paying itself is slightly tangential but is plausibly useful context for an agentic payment flow. Nothing needs trimming, though the title/name mismatch adds noise the description does not resolve.

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 is the only place an agent can learn what comes back, yet it never specifies the return shape, expiration, or whether the link is single-use. Combined with no annotation-level detail on side effects for an open-world, non-read-only tool, and no guidance on the auth fallback for api_key, key information is missing. What is present is accurate but insufficient 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 description coverage is 100% across all three parameters, so order_id, method, and api_key are already documented in the schema. The description adds no further meaning to any of them, including no hint about how 'method' maps to the card-or-crypto behavior it mentions. Baseline 3 applies when the schema carries the parameter burden.

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 names a specific resource and outcome: it returns a payment page for a given order, with card or crypto depending on what is enabled. That is clear enough to act on, but it never resolves whether the result is a URL, a link, or rendered page content, and it does not differentiate the tool from siblings like order_status or my_tools. The name/title/description also pull in different directions (create_payment vs. 'Get the payment link' vs. 'Returns').

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use or when-not-to-use guidance, no mention of prerequisites such as needing a completed order, and no named alternative among the many siblings. The only usage-adjacent sentence ('an assistant that can pay may pay itself') describes who pays rather than when an agent should call this tool. An agent must infer the trigger condition entirely.

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?

The annotations already establish a read-only, non-destructive, open-world operation. The description adds directory-existence scope but provides no detail about matching behavior, multiple or absent matches, or result shape, which is notable because there is no output 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?

Two short sentences front-load the existence-check purpose and immediately state the supported lookup inputs. There is no redundant or extraneous wording.

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 two-parameter lookup, the description, complete input schema, and safety annotations are sufficient to make a basic call. However, the absence of an output schema leaves result behavior undocumented, and the description does not connect the lookup to the submission or claim workflow.

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 the schema already explains both url_or_name, including that a website address is best, and the optional API-key fallback. The description merely repeats the website-or-name choice, so the high-coverage baseline applies.

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 identifies the operation as searching the infobro directory to determine whether a product is already listed, using a website address or name. This clearly states the resource and purpose, but it does not explicitly distinguish the directory-wide lookup from siblings such as my_tools or prefill_from_url.

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 opening question supplies a concrete use case: checking whether a product already exists in the directory. It does not explicitly recommend using it before submit_tool or identify alternatives for other lookups, so it stops short of complete 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?

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds no behavioral detail beyond that: it doesn't say whether the list is static or fetched live (relevant given openWorldHint), whether it is paginated, or what the returned slugs look like. For a read-only listing tool it is minimally adequate but thin.

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?

It is short and front-loads the key term, so there is no waste. But it is a sentence fragment rather than a complete statement of the action, which costs clarity even if it saves 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?

With no output schema, the description carries the burden of explaining what is returned, and it does not — an agent cannot tell whether it gets strings, objects with slug/label, or counts. The link to submit_tool is the one genuinely useful piece of context, but the return shape is left unspecified.

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?

There is a single optional api_key parameter with 100% schema description coverage, so the schema fully explains it. The description adds nothing about authentication or the parameter, which is acceptable only because the schema does the work.

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 fragment names the resource (category slugs) and ties it to submit_tool, so an agent can infer it lists category slugs. But it never uses a verb or states that it returns a list, so the purpose is implied rather than stated. This is better than a tautology but short of a clear verb+resource statement.

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?

Naming submit_tool as the consumer implies this should be called before submit_tool to obtain valid category values. That is useful routing context, but there is no explicit when/when-not guidance and no mention of other siblings such as update_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?

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered and the description doesn't contradict it. The description adds only that each plan carries prices and inclusions and that plan choice is the owner's decision. It says nothing about authentication (the api_key parameter), pagination, or whether plan data is live or cached.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Three short sentences, front-loaded with the purpose, and no redundant wording. The elliptical phrasing ('one of them', 'for them') is compact but slightly underspecified rather than wasteful.

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, zero-required-parameter read tool with full annotation coverage and no output schema, the description conveys enough: what is returned (plans with prices and inclusions) and when it matters (picking a plan for a listing). Only the absence of any return-shape or auth detail keeps it from a 5.

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?

There is a single parameter (api_key) with 100% schema description coverage, so the schema already explains everything needed. The description adds no meaning about that parameter, so the baseline of 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description gives a specific verb and resource: 'Listing plans with prices and what each includes', which is clearly a read of a plan catalogue. It falls short of 5 because 'plans' is never grounded (subscription plans for a listing?) and no sibling is named as a contrast, though no sibling in the list is a competing plan-lister.

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?

'A new listing needs one of them' implies the usage context (call this before/while creating a listing), but it is only implied, not stated as an instruction. 'The owner decides, or tells you to decide for them' hints at a decision hand-off but gives no explicit when-to-call, prerequisites, or alternative tools to consider.

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?

Beyond the annotations (readOnlyHint=false, openWorldHint=true, destructiveHint=false), the description contributes real behavioral facts: the link is single-use and expires in 15 minutes. That is exactly the kind of context annotations cannot express. It omits the security weight of the link (it grants full dashboard access) and that a credential is required, which keeps it from a 5.

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 sentence with zero filler; the defining properties (one-time, 15-minute) are placed immediately after the artifact so an agent scanning the first clause already knows the key constraint.

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 two-optional-parameter tool with no output schema, the description should state that the result is the link itself (a URL string) and where it can be used. It says 'in the browser' but never confirms the return value, leaving the agent to infer what comes back from a call with readOnlyHint=false.

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 both 'page' and 'api_key' are already documented with examples and fallback behavior. The description mentions 'dashboard' and 'browser', loosely gesturing at the page parameter, but adds no syntax, defaults, or constraints beyond the schema. Baseline 3 applies.

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 names a specific artifact ('a one-time link') and its effect ('signs the owner into their infobro dashboard in the browser'), which is unambiguous and clearly distinct from every sibling (whoami, verify_signup, etc.). It stops short of a 5 only because it is phrased as a noun phrase rather than stating the action ('generate/create a sign-in link').

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is implied by the purpose — an agent can infer this is for handing the owner a browser session — but there is no explicit when-to-use, no statement of prerequisites (owner identity, valid API key), and no mention of alternatives such as whoami for identity checks. Nothing misleading, just unstated.

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?

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds genuine value by disclosing the returned content (review status, editor notes, unpaid orders, views, clicks), but says nothing about scope (all listings? one?), pagination, or freshness — gaps that matter for an open-world read.

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?

One short sentence fragment, front-loaded with the resource and followed by the field list; nothing is redundant. The only cost is terseness — the elliptical phrasing leaves the action implicit.

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 carries the burden of explaining return values, and it does list the fields the agent will get. However, it omits how results are shaped or scoped (single listing vs. collection, pagination, ordering), which leaves the agent guessing about the response envelope.

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?

There is a single parameter (api_key) with 100% schema description coverage, so the schema already explains the auth fallback behavior. The description adds no information about it, so baseline 3 applies.

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 identifies the resource ('The account's listings') and enumerates the payload fields (review status, editor notes, plan, unpaid orders, views, clicks), which disambiguates it from the create_/update_/submit_ siblings. It lacks an explicit verb like 'retrieve' and does not name any sibling it contrasts with, but the read-oriented noun phrase is clear enough to classify the 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?

There is no statement of when to use this versus alternatives such as order_status, list_plans, or update_tool, and no prerequisites or exclusions. At best, the enumerated fields imply it is a dashboard-style overview of the caller's own listings, but that must be inferred.

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?

Annotations already declare readOnlyHint=true, openWorldHint=true and destructiveHint=false, so safety is covered structurally. The description adds essentially nothing beyond that: no mention of the remote API call, the api_key auth requirement, or what happens when the order is unknown.

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?

It is a single short sentence with no wasted words, though brevity here reflects under-specification rather than disciplined editing.

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?

A read-only lookup against an external API with no output schema needs to explain what state is returned (paid/unpaid, statuses, error on missing order). None of that is present, leaving the agent unable to predict the 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?

Schema description coverage is 100%, so both api_key and order_id are documented in the schema itself; the baseline of 3 applies. The description contributes no additional meaning about identifier formats or key handling.

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 reads "Whether an order is paid" – it restates the title and names the resource only obliquely. It does not say this retrieves an order's payment status, nor does it distinguish itself from siblings such as create_payment.

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 when-to-use, when-not-to-use, or alternative guidance is given. An agent has no basis for choosing this over create_payment or whoami when checking payment state.

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?

Annotations already cover the safety profile (readOnlyHint=true, openWorldHint=true, destructiveHint=false), so the bar is lower. The description still adds value by disclosing that the operation produces a non-persisted draft rather than a live listing, and by naming the four fields returned — important since no output schema exists. It does not mention fetch failures or rate limits on external sites.

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 sentence with no filler: the read action, the returned fields, and the downstream destination all come in one pass. Nothing is repeated from the title and no sentence is wasted.

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 compensates by listing the four draft fields, and the two-parameter read tool is simple enough that little else is required. Only minor gaps remain, such as what happens when the site is unreachable or how large the draft is.

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 'url' documented as 'The product's website', so the description's reference to reading the website adds little beyond it. The api_key parameter is never mentioned in the description, though the schema covers it. Baseline 3 is appropriate when the schema carries the parameter documentation.

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 ('Reads the product's website') and enumerates the returned draft fields (name, tagline, description, images), then names the sibling it feeds into (submit_tool). An agent can distinguish this from submit_tool and update_tool without opening any 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?

The phrase 'to improve and pass to submit_tool' establishes the workflow position clearly: use this first to draft, then edit, then submit. It lacks an explicit when-not-to-use clause (e.g., no site available, or updating an existing listing via update_tool), which keeps it 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?

Beyond the annotations (readOnlyHint=false, destructiveHint=false, openWorldHint=true), it adds the cost profile ('Free'), describes exactly what the call produces (a meta tag or DNS TXT record), and names the required next step. It does not say whether repeated calls create duplicate pending claims or how long the token stays valid, which matters for a non-read-only operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Three short sentences, front-loaded with cost then action then next step; nothing is filler. The opening 'Free.' fragment is slightly abrupt but carries real decision-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?

For a state-changing tool with no output schema, the description covers what is returned (a DNS/meta verification artifact) and the required follow-up call, which is the essential loop. Gaps around token lifetime and re-invocation behavior keep it short of 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%, and both parameters (`tool` slug from find_tool, `api_key` fallback for the Authorization header) are already documented in the schema. The description adds no format or constraint detail beyond that, so the baseline of 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description makes clear that the tool initiates a domain-ownership claim by issuing a verification token (meta tag or DNS TXT record), and it names verify_claim as the follow-up, so an agent can separate it from verify_claim and start_signup. It never literally states the verb 'start a claim' on the listing identified by the `tool` parameter, so the action is inferred from the title rather than the prose.

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 explicit sequencing guidance ('Add it, then call verify_claim'), which is the primary when-to-use signal. It does not contrast with start_signup (new listing) or say what to do if a claim is already pending, so the choice among sibling tools 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?

Annotations only mark it non-read-only and open-world; the description adds the concrete side effect (an email with a 6-digit code is sent to the owner) and the dual new/existing account behavior. It does not disclose code expiry, resend/rate limits, or what the call returns, which matters since there is no output 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?

Four short, front-loaded sentences with zero filler; the action, applicability, and next step are each stated once.

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 one-required-param trigger tool with no output schema, the description covers purpose, effect, and follow-up call. The main remaining gap is the response shape and whether a session/identifier is returned to pass into verify_signup.

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 email and name are already documented as the owner's address and name. The description adds only a slight hint that the target is the 'product owner'; it adds no format or conditional semantics (e.g., whether name is ignored for existing accounts).

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 concrete action and its effect: emails a 6-digit code to the product owner to begin signup. It also positions itself as step 1 ahead of verify_signup, so the agent can tell it apart from the verify/claim siblings.

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?

Clear sequencing guidance ('Step 1... Then call verify_signup') and a qualifying fact that it works for both new and existing accounts. It stops short of naming when a different path (e.g., login_link for an existing account that just needs a link) would be preferable.

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?

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the mutating, external-facing nature is covered. The description adds genuine state-transition context — the record starts as an unpaid draft and only reaches editor review once paid — but says nothing about what identifiers are returned, whether drafts expire, or what happens on duplicate submissions.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two short sentences, front-loaded with the primary effect and followed by the workflow and writing constraints. The style directive ('no hype words, no claims you can't back') does affect how required description/tagline fields get filled, so it earns its place, but the phrasing is slightly informal for a tool spec.

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 an 18-parameter, 7-required creation tool with no output schema, the description covers the lifecycle but omits the return shape — notably that the resulting listing/order identifier is presumably what feeds create_payment. An agent must infer that linkage, which is a meaningful gap for a multi-step 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?

Schema coverage is 83%, so the schema already documents nearly every field including lengths, plan enum and category slug sourcing. The description only restates 'the chosen plan' and adds a content-quality rule rather than any per-parameter meaning, 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 uses a specific verb and resource ('Creates the listing') and frames the two objects produced: an unpaid draft plus an order for the chosen plan. It also names the downstream sibling create_payment, so the agent can distinguish submission from payment, though it does not contrast with update_tool for editing an existing listing.

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 establishes the ordering of the workflow: submit first, pay later via create_payment, after which editor review begins. That gives clear conditions for when to call this versus the payment tool, but there is no explicit guidance on when not to use it (e.g., to modify an existing listing) and no mention that a plan should already be selected.

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?

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds real value beyond that by disclosing two behavioral traits the annotations cannot express: partial-update semantics and the editor-review delay before live listings actually change. It stops short of saying what happens to non-live listings or whether an editor can reject changes.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two short sentences, front-loaded with the core action, and each sentence carries distinct information (update scope, then moderation timing). Nothing is wasted or repeated.

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 moderation caveat and partial-update rule are the right things to front-load for a mutation tool with no output schema. But for a 23-parameter tool with nested objects and 39% schema coverage, the description is too thin: it never addresses the required listing slug's source, the optional API key/auth path, or the Pro-only fields hinted at in the schema.

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?

With 23 parameters and only 39% schema description coverage, the description must compensate, and it does not — it names no field, no format, and no constraint. Many parameters (name, features, platforms, logo_url, pricing_model, starting_price, extra_categories, has_api, and the nested socials keys) carry no description in either place, so the agent is left guessing at their meaning.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource ('Changes fields of one of the account's listings') and clarifies the edit scope. It does not name a sibling such as submit_tool or create_payment, so an agent must infer from the name alone that this edits rather than creates.

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?

'Only the fields you pass change' establishes partial-update usage, which is genuinely useful guidance for a 23-parameter tool with one required field. However, there is no explicit when-to-use vs. when-not guidance, no mention of prerequisites (e.g., Pro-tier fields like cta_url/cta_label), and no pointer to my_tools for obtaining the required slug.

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?

Annotations already declare that this is a non-read-only, open-world, non-destructive operation. The description usefully adds that it performs an external meta-tag or DNS check and conditionally reassigns the listing, but it omits failure behavior, permission requirements, and what 'moves the listing' changes in practice.

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 efficient sentence with no wasted wording. It front-loads the verification mechanism and follows with the conditional outcome.

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 state-changing ownership verification tool, the description covers the core mechanism and outcome but leaves out prerequisites, failure cases, and what the caller should expect when the tag or DNS record is absent. With no output schema, more description of the result would be helpful.

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%, and both parameters are documented there: the required listing slug and optional API key. The description does not add format details, examples, or additional meaning for either parameter, so the schema baseline of 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states concrete actions: it checks for a meta tag or DNS record and conditionally moves the listing to the account. That is specific enough to identify the operation, but it does not explicitly distinguish this verification step from sibling claim-related tools such as start_claim.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no explicit when-to-use guidance, no prerequisite such as having already started a claim, and no mention of alternatives. The phrase 'if found' describes internal behavior rather than when an agent should invoke this 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?

Annotations only declare readOnlyHint=false, openWorldHint=true and destructiveHint=false. The description adds genuinely useful context beyond those: this call issues an API key that acts on behalf of the account, which is a security-sensitive side effect the agent should know about. It does not cover failure behavior for an invalid or expired code.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two short sentences with the step marker front-loaded and the outcome stated immediately. No wasted wording, though 'Step 2' is only meaningful if the reader already knows the flow.

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 compensates by stating that the return value is an API key that acts for the account. For a two-parameter verification tool this covers the essentials; only error/expiry behavior is left unstated.

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 both email and code documented in the schema, so the baseline is 3. The description restates 'code from the email' but adds no format, tolerance, or retry semantics beyond what the schema already provides.

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: checks an emailed code and returns an API key for the account. The 'Step 2' framing signals it belongs to a multi-step flow without naming the sibling tool (start_signup) that precedes it, which is referenced only inside 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?

The 'Step 2' label implies ordering after a signup start, but the description never names start_signup as the prerequisite or states when not to call it (e.g., existing accounts, expired codes). Usage context is 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?

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds almost nothing beyond that: it does not say what happens with a missing or invalid key, whether the api_key override is honored the same way as the Authorization header, or what account fields are returned. Since no output schema exists, the description carries some burden it does not discharge.

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 short sentence with no filler and front-loaded meaning. It is efficient, though it is terse to the point of under-specification rather than genuinely informative.

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 one-parameter read-only identity lookup this is close to adequate, and the annotations plus schema cover safety and input semantics. The missing piece is what the call returns and how it behaves on an invalid key, which matters because there is no output schema.

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 single parameter has 100% schema description coverage, and the schema already explains the optional api_key fallback to the Authorization header. The description does not mention parameters at all, so baseline 3 applies since the schema does the work.

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?

"Which account the key belongs to" identifies the resource (account) and the keying input (API key), which is enough for an agent to recognize a whoami-style lookup. However, it is a verbless fragment that never states what it actually does (return account details) or what an agent gets back, so purpose is clear in spirit but vague in form. No sibling covers accounts, 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?

There is no when-to-use guidance and no mention of alternatives among the fourteen siblings (e.g. login_link, my_tools). An agent must infer that this is the diagnostic call to run when it needs to know which identity the current API key represents.

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