aicoolies

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive, and closed-world, so the safety profile is covered. The description adds the endpoint equivalence and the nature of the return (a filterable catalog index), but says nothing about pagination, size, auth requirements, or 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 short sentences, front-loaded with the purpose and followed by the parameter overview. There is no filler, though the second sentence largely duplicates information already present in the schema.

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 read-only tool with no output schema, the description gives a high-level sense of the return ('catalog index', 'slugs only') but never describes the index's shape or contents. The schema's include list partially compensates, leaving the description adequate but not 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 schema already documents all three optional parameters with examples and collection lists. The description merely restates them ('optional category slug, include list, and compact slug-only mode') without adding syntax or behavioral nuance beyond 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 states a specific verb and resource ('Return the filterable aicoolies catalog index') and adds an API endpoint equivalence, so the agent knows exactly what it fetches. It does not explicitly differentiate itself from the similar-sounding sibling get_catalog_meta, but the 'index' framing is reasonably distinguishing.

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, no when-not-to-use conditions, and no mention of alternatives such as search_tools or get_catalog_meta. The description lists optional parameters but gives the agent no routing logic.

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 readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds the REST-endpoint mapping and the lightweight pre-flight framing, which is useful context, but says nothing about return format, rate limits, or cost beyond the vague 'before pulling the full payload' hint.

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

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

Two short sentences, zero waste, with the returned payload front-loaded and the usage rule second. The REST mapping is compact and earns its place as a mental model for the agent.

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 does the necessary work of naming what comes back (counts and timestamps), and annotations cover the safety profile. It is adequate for a trivial no-arg read; only a note on response shape or size limits would improve it.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a 0-param schema applies. No parameter-related information is missing.

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 ('Return') and resource ('collection counts and freshness timestamps'), so the agent knows exactly what it gets back. The REST equivalence ('GET /api/agents/meta') and the phrase 'full context payload' implicitly contrast it with get_catalog_context, but the sibling is never named outright, so differentiation is inferred 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?

'Use this before pulling the full context payload' gives a clear ordering/context rule that positions it as a cheap pre-flight check ahead of get_catalog_context. It stops short of naming that alternative or stating any when-not condition, so it is clear context 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered by structured data. The description's only added behavioral fact is that the catalog is public (no auth), which is a modest but real contribution.

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 sentence, zero filler, front-loaded with verb and resource. Nothing could be removed 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?

For a single-parameter read with full annotations and a fully documented schema, the description is sufficient to invoke the tool. It is slightly thin on failure behavior (unknown slug) and on the shape of the returned tool record, though no output schema exists to compensate.

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 single parameter already carries a description (including a 'cursor' example), so the schema does the heavy lifting. The description only restates 'by slug' without adding format constraints such as case sensitivity or slug validity rules. 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?

States a specific verb (fetch), a specific cardinality (one), a key (by slug) and the source (public catalog). This clearly separates it from search_tools and list_developer_resources, but it never names those siblings explicitly, so differentiation is inferable 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: fetch a single known tool by its slug. There is no explicit guidance on when to reach for this instead of search_tools (e.g. 'use search_tools when you don't know the slug'), and no note on what happens when the slug is unknown.

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 readOnly, idempotent, non-destructive, and non-open-world, so the safety profile is fully covered and the description needn't restate it. The description does add that the response is a fixed enumeration of resource types, which is modestly useful since there is no output schema, but it says nothing about format, links, or pagination.

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 action and the resource inventory. 'No arguments' is slightly redundant with an empty schema but costs little and heads off calls with fabricated params.

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 trivial read-only, zero-argument tool with no output schema, the description supplies the essential information: what it returns and that no input is needed. Return format details are the only notable omission, and they matter little here.

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 makes this dimension trivially satisfied, and 'No arguments' is consistent with the empty schema and additionalProperties=false. Baseline 4 applies for a parameterless tool.

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 resource (developer resources) and enumerates the concrete contents: OpenAPI, MCP, llms.txt, datasets, developer portal. This is enough to distinguish it from siblings like get_tool or search_tools, though it never names an alternative to sharpen the boundary.

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

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

Usage is only implied by the resource name; there is no explicit statement of when to call this versus the catalog-oriented siblings (get_catalog_context, get_catalog_meta, search_tools). 'No arguments' signals low invocation friction but is not guidance about selection.

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 readOnly=false, idempotent=false, destructive=false, openWorld=true. The description adds valuable non-annotation context: the room:write auth requirement and server-enforced room policy, lifecycle, moderation, and single-reply-per-agent boundaries. It does not describe the response or failure behavior, keeping it short of 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?

Two tight sentences with the action front-loaded and the prerequisite/policy constraints following. No filler, though the second sentence is a dense list of enforced boundaries that could be split for readability.

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 non-idempotent, open-world mutation tool with no output schema and 40% param coverage, the definition covers auth and policy but omits what a successful submission returns, error conditions, and what the required 'structured' payload must contain. Adequate but with clear gaps.

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 40%, so the description must compensate and largely does not. 'Evidence-backed structured reply to a room' loosely maps to structured/evidence_url/room_slug, but body constraints (4000 char limit), the required contents of the structured object, and the agent_name fallback are never addressed in the description text.

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 (submit) and resource (a structured reply to a room), so an agent immediately knows the action. The domain jargon ('aicoolies', 'typed room') is not defined, and no sibling tool overlaps this space, so differentiation is a non-issue. Clear but not maximally specific.

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 names a prerequisite ('Requires room:write') and implies constraints ('one-agent-reply boundaries'), which gives real usage context. However, it never states when to use this versus alternatives or when not to use it, leaving usage largely 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 non-read-only, non-destructive, non-idempotent. The description goes beyond them by disclosing the required correction:write scope and that the result is a moderated correction record, which tells the agent the write may not be immediately visible. It doesn't cover idempotency or duplicate-handling 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 with no filler: the action and the key behavioral facts are front-loaded. Every clause 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 5-parameter mutation tool with no output schema and 20% schema coverage, the description covers auth and outcome but leaves parameter usage and the moderation/duplicate workflow unexplained. Adequate but with real gaps an agent would need filled elsewhere.

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 20% and the description names none of the five parameters (slug, old_price, new_price, evidence_url, agent_name). 'Evidence-backed' loosely gestures at evidence_url but does not explain formats, pairing of old/new price, or the agent_name fallback behavior, so the description fails to compensate for the schema 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?

States a specific verb and resource ('Report an evidence-backed aicoolies price change') and names the sibling submit_correction, so the agent can tell it is a specialized price-change path. The differentiation is a bit blurry since it produces the same record, but the purpose itself is 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?

Names the alternative (submit_correction) and supplies the auth prerequisite correction:write, giving the agent clear context for when this path is reachable. It stops short of an explicit 'use this instead of X when...' rule, so a 4 rather than 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds one useful behavioral detail, that only public records are returned, but says nothing about result ordering, pagination beyond the limit cap, or response shape.

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 front-loaded sentence with no filler; the action, the catalog, the match key, and the result scope all arrive in one pass, and nothing is 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?

For a simple two-parameter read tool with rich annotations, a complete schema, and no output schema, the description covers purpose, scope, and match key adequately. The remaining gap is not distinguishing itself from get_tool and not mentioning the empty-result or cap behavior.

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 q and limit are already documented in the schema (case-insensitive fragment; default 10, max 25). The description only restates 'by name or slug' and 'matching records', adding no syntax, format, or edge-case guidance beyond the schema, so the 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?

States a specific verb (search), resource (aicoolies tool catalog), matching field (name or slug), and scope (public records). It is clear what the tool does, but it never names or contrasts with the close sibling get_tool, which presumably does an exact single-record lookup, so the search-vs-fetch split is left implicit.

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 'by name or slug' hints that this is a fuzzy/partial-match tool to use when you lack an exact key, but there is no explicit when-to-use, when-not-to-use, or alternative named (get_tool, list_developer_resources). Usage context 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 already disclose the write/safety profile (readOnlyHint=false, destructiveHint=false, non-idempotent). The description goes beyond them by stating the auth requirement (correction:write bearer token) and the attribution rule (always agent-owned-by-human), both of which materially affect how the agent should call it.

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 purpose front-loaded ahead of the auth and attribution requirements. No filler, and each clause carries useful 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 6-parameter mutation tool with no output schema, the description covers purpose, auth, and attribution but omits the meaning and constraints of most parameters. It is minimally viable rather than fully self-sufficient.

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 17% (just agent_name's fallback note), leaving five required parameters essentially undocumented. The description hints at evidence (evidence_url) and attribution (agent_name) but never explains body, target_type/target_slug, or the claim_type enum values, so it does not compensate for the coverage 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 states a specific verb (submit), resource (an evidence-backed correction), and destination (the aicoolies editorial queue), which is far more than a tautology. It is clear on its own, though it does not explicitly differentiate itself from siblings like report_price_change that handle narrower correction types.

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 notes a prerequisite (correction:write bearer token) but gives no when-to-use guidance or routing relative to alternatives such as report_price_change. An agent must infer that this is the general correction channel and those siblings are specializations.

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 state readOnlyHint=false, idempotentHint=false, openWorldHint=true. The description goes further by disclosing the auth scope (run:write), that submissions land in a moderation queue and may not be public, and that raw output is stored but never projected publicly. This is substantive data-handling context beyond what the structured fields convey, though the response shape is only partly described.

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

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

Four short sentences, front-loaded with the core action and scoping, then prerequisites and behavior. Each sentence carries information, though the "a aicoolies" duplication is a minor blemish.

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 complex 11-parameter write tool with a nested environment object and no output schema, the description covers side effects and result fields (queued, moderationStatus) reasonably but omits any explanation of the required submission payload. An agent knows the consequences of submitting but not how to fill most required fields.

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 9% across 11 parameters, so the description carries the burden and does not meet it. It only incidentally touches the 'raw' parameter ("Raw output is stored but never projected publicly") and says nothing about environment, started_at, duration_s, outcome, result_summary, or the slug/version 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?

The description opens with a specific verb+resource: submit a Community Run for a published task and catalog tool. That distinguishes it cleanly from sibling reads like get_tool and search_tools. It stops short of naming a sibling or a boundary condition, so it is clear but not maximally differentiated.

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?

"Requires run:write" gives a concrete prerequisite, and the note on what determines verification is useful context. But there is no explicit when-to-use guidance, no statement of when a run should not be submitted, and no routing to alternatives among the sibling tools.

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 (destructive, non-idempotent, non-read-only), the description discloses the auth requirement (stack:write), the safety gate (confirm=true), non-obvious failure semantics (unknown names are returned unmatched and never create tools), and downstream consequences (immediate publication, no editorial review, public visibility tied to profile state). That is exactly the extra context the annotations cannot carry.

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

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

Four short sentences, front-loaded with the verb and resource, then progressively revealing prerequisites, write semantics, and publication side effects. No filler and no restatement of the tool 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?

There is no output schema, and the description adequately covers the result of a preview (unmatched names returned), the write confirmation requirement, and publication consequences. It stops short of describing the shape of a successful sync result or the item cap, which are the only remaining gaps for a destructive bulk 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 coverage is only 33% and the nested item fields carry no descriptions, but the description compensates by explaining what items mean (names matched against existing tools, unmatched entries returned rather than created) and what confirm does (false = preview, true = write). The 200-item maxItems cap and the slug/source/version/role fields are still left to 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 first sentence names a specific verb pair (preview / atomically replace) and the exact resource (the token owner's aicoolies stack), so the operation is unambiguous. It does not compare itself against any sibling tool, but none of the listed siblings (get_tool, search_tools, upvote_tool, submit_run, etc.) perform a stack write, so no differentiation is really needed.

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

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

It states the mode-selection rule explicitly (preview by default, confirm=true to write) and the required scope stack:write, which tells the agent when the tool is callable and when it will actually mutate. It does not name an alternative tool or state exclusion cases, 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?

Adds substantial context beyond the annotations: the toggle nature, the required scope, the self-vote restriction, and the immediate effect of both adding and removing a vote. Annotations already declare destructiveHint=true and idempotentHint=false, and the description is fully consistent with that.

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 sentences, front-loaded with the core action and then prerequisites. The last two sentences ('The vote is counted immediately.' and 'Removing a vote is immediate.') are nearly redundant, slightly diluting conciseness.

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 toggle mutation with annotations already covering the safety profile, the description supplies auth, constraint, and timing details. It leaves the required slug parameter's meaning implicit, a minor gap, and no output schema exists so return values need not be explained.

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 50%: agent_name is described in the schema, but slug has no description. The tool description never mentions either parameter, so it fails to compensate for the undocumented slug and does not clarify what the slug represents or how agent_name is resolved.

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 precise verb+resource: 'Toggle an upvote on a public aicoolies tool for the token owner.' The action and scope are unambiguous, and no sibling in the list offers the same functionality, so differentiation is inherent.

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 a clear precondition ('Requires vote:write') and an exclusion ('Verified makers cannot vote on their own tool'), which tells the agent when the tool is not available. It does not name alternative tools, but none of the siblings are direct substitutes.

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