Grok Bot Wiki

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds that the status is transient (a review-queue state), which explains why the tool is flagged idempotentHint=false - repeated calls can legitimately return different results - and it discloses accepted input forms, useful context beyond the annotations.

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: the first front-loads the outcomes the agent cares about, the second covers accepted inputs. No filler or redundant restatement of the title.

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 carries the burden of describing return semantics - and it does list the three key status values plus the upgrades flag. It does not describe the full response shape (e.g., additional fields), so it is strong but not fully complete for a no-output-schema 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 100% and the single parameter's schema description ('x.ai share link, directory slug or Bot page address') already states the accepted formats. The description largely repeats this, only slightly expanding the third format to 'grokbotwiki.com/bots/', which rests on the domain name. Baseline 3 applies when the schema does the heavy lifting.

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 operation (check a Bot's listing status) and enumerates the three possible outcomes: listed, waiting in the review queue, or not submitted. This scoping distinguishes it from siblings like get_bot (fetch bot details), submit_bot (submit), and search_bots (discovery) without needing to name them.

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 framing question implies the usage context (verifying submission state after submitting), and 'Includes optional upgrades' hints at scope. However, there is no explicit when-to-use vs. when-not guidance and no named alternative such as get_bot for full bot details, so usage 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, idempotentHint=true, destructiveHint=false, so the safety profile is covered. The description adds that it returns full text and the id format, which is useful. It doesn't mention pagination, size limits, or error behavior, but for a simple fetch operation with strong annotations, 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?

Two sentences, no waste. The core action and id format are front-loaded. 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 single-parameter read-only fetch with a rich schema and strong annotations, the description is nearly complete. It explains the id format and what the tool returns. It could mention that the id comes from search results, but that's implied by the schema description. No output schema exists, but the return value is described as 'full text' which is 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 100%: the id parameter has a pattern, maxLength, minLength, and description. The description adds the id format examples ('bot:<slug>' or 'guide:<slug>') which reinforces the schema pattern, but doesn't add significant new meaning beyond what the schema already provides. 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 clearly states the tool fetches the full text of a Bot or guide by id, with a specific verb ('fetch') and resource ('Bot or guide'). It distinguishes from siblings by mentioning the id format, but doesn't explicitly name alternatives like get_bot or get_guide, so it's clear but not fully 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?

The description implies usage: use this tool when you have an id from search. It doesn't explicitly state when not to use it or mention alternatives like get_bot/get_guide, but the id format and 'from search' hint provide some context. No explicit exclusions or alternative 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 mark this as read-only, idempotent, and non-destructive. The description adds valuable behavioral context beyond annotations by stating that only public, live listings are returned and that nothing beyond the creator's public share-page description is exposed.

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; the first states the operation and result fields, the second clarifies availability and scope boundaries. No filler or repetition.

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 tool with no output schema, the description adequately communicates what is returned and what constraints apply. It could mention not-found behavior, but that is a minor gap given the simplicity.

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 fully documents the single parameter, including format and an example ('Bot slug from search_bots, e.g. 'daili''). The description adds little beyond saying retrieval is by slug, so the schema carries the semantic weight.

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 action and resource ('One listing by slug') and enumerates the returned fields (creator, share link, description, tags, dates, editorial notes). It is clear but does not explicitly differentiate itself from sibling tools like get_guide or search_bots.

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 intended use is implied: retrieve a single bot listing by its slug. The schema hints that the slug comes from search_bots, but the description itself does not state when to use this tool versus alternatives or mention 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?

The description adds meaningful behavioral details beyond the annotations: the output is plain text, includes specific metadata like evidence label/update date/sources, and is capped at about 12,000 characters. It also reveals that the full page is available via URL, matching the readOnly/idempotent annotations.

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-loads the core behavior, and saves every word. It states what the result is, what it contains, and the main limitation, with no filler or 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 single-parameter read tool, the description covers the output shape, metadata included, and truncation behavior. The schema and annotation context already provide safety and parameter constraints, so nothing essential is missing for an agent to invoke this 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% for the single required slug parameter, including a pattern, max length, and an example. The description does not need to add much parameter-level meaning, and the example in the schema already clarifies what 'slug' means. This aligns with the baseline of 3 for high 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 identifies the operation: retrieve one specific guide as plain text, with its evidence label, update date, and sources. It clearly distinguishes the tool from siblings like search_guides and list_categories by emphasizing the singular result and content format.

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 itself does not explicitly state when to use this tool over alternatives, but the input schema adds 'Guide slug from search_guides', implying the expected workflow is to call search_guides first. This is clear context rather than leaving the agent completely unguided, so it earns the middle-ground score.

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, and destructiveHint=false, so the safety profile is fully covered. The description adds that it returns live counts and page links, which is useful behavioral context beyond the annotations. However, it doesn't describe the output format or whether the data is static vs. dynamic beyond 'live counts'.

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, no filler. The first sentence states the primary content, the second adds the cross-tool relevance. 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 zero-parameter read-only tool with rich annotations, the description is nearly complete. It tells the agent what data to expect and how it relates to search_bots. The only minor gap is the lack of an explicit output format, but with no output schema and no parameters, the description covers the essential 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?

The tool has zero parameters, so the schema is trivially complete. The description adds meaning by explaining what the output contains (categories, tag collections, app slugs), which is the only semantic content an agent needs. Baseline 4 for zero-param tools 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 states a specific verb ('lists') and resource ('eight directory categories and the tag collections'), and distinguishes itself from siblings by noting it also lists app slugs accepted by search_bots. This makes it clear what the tool returns and how it differs from other list/search 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 implies when to use this tool: when you need directory categories, tag collections, or app slugs for search_bots. It doesn't explicitly state when not to use it or name alternatives, but the mention of search_bots provides a clear context signal. A small gap: no explicit exclusion of other 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?

Annotations already establish readOnly, idempotent, and non-destructive behavior. The description adds useful context about returning only metadata and directing full-text needs to fetch, but it does not disclose result limits, pagination, or other behavioral details.

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

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

The description is short and front-loads the core purpose and result fields. The second sentence is slightly awkward but still compact 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?

For a one-parameter read-only search tool, the description gives the key result fields and a hint about full-text retrieval. Yet it leaves sibling differentiation implicit and does not mention result count or pagination, which would matter more given 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?

Schema coverage is 100% and the single query parameter already has a basic description. The tool description adds no parameter-level detail beyond what the schema provides, so the baseline score 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 states a concrete action and scope: it searches 'across Bots and guides' and returns 'ids, titles and URLs.' It is clear about what the tool produces, though it does not explicitly differentiate itself from sibling tools like search_bots or search_guides.

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 workflow is implied: search returns metadata, and 'Pass an id to fetch for the full text' indicates that full-text retrieval should happen after obtaining an id. However, it never explicitly contrasts this tool with search_bots or search_guides.

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 read-only and non-destructive behavior, but the description adds meaningful caveats: results are 'not tested', listings come from public share pages, and results are capped at 20. It also instructs the agent to 'Cite the url field', which is useful beyond the schema. No contradiction with annotations is present.

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 compact sentences cover the search dimensions, result fields, limits, caveats, and citation expectation without wasted words. The most important operational information is front-loaded, and each sentence serves a distinct purpose.

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 search tool with no output schema, the description enumerates the returned fields (name, slug, URL, share link, creator, summary, category), the 300-character summary limit, and the untested nature of listings. It lacks detail on empty-result or error behavior, but those are minor gaps given the schema and annotations.

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 each parameter is already documented. The description adds minimal semantic value by mapping 'task, keyword, category or app' to the query, category, and app fields, and by noting the 20-result cap, but it does not explain parameter syntax or relationships 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?

The description opens with a specific verb and resource ('Search community Grok Bot templates') and names the exact dimensions by which search is possible: task, keyword, category, or app. It also distinguishes itself from siblings like search_guides and get_bot by clarifying it returns template listings, not guides or detailed bot info.

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 context is implied: use this tool when looking for community bot templates, especially because results are 'read from public share pages' and 'not tested'. However, it does not explicitly state when to prefer this over the sibling 'search' or 'search_guides', nor does it name 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds value by disclosing the return shape (title, URL, description, last update date) and the specific guide domains, but does not mention ordering, pagination, or search behavior. With annotations carrying the safety burden, this is adequate but not rich.

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 16-word sentence that front-loads the action and scope, then states the return fields. There is no filler, repetition, or unnecessary detail; 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?

With no output schema, the description appropriately discloses return fields. The schema covers all parameters at 100% and annotations cover the read-only/idempotent safety profile. The only notable gaps are the lack of sibling differentiation and result ordering, but for a simple filtered search tool the description is largely 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% – both 'query' and 'limit' have clear descriptions with examples and constraints. The description adds no parameter-specific meaning beyond what the schema already provides, 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 states a specific verb ('Search') and resource ('setup, pricing, workflow, safety and troubleshooting guides'), and lists the return fields (title, URL, description, last update date). This clearly distinguishes it from sibling tools like search_bots or get_guide by resource type, though it does not explicitly name an alternative.

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 context is implied by the resource scope (guides covering setup, pricing, workflow, safety, troubleshooting) and by the schema's example topics ('pricing', 'skills vs routines', 'permissions'). However, there is no explicit when-to-use, when-not-to-use, or alternative tool guidance, so an agent must infer when this is preferable to 'search' or 'search_bots'.

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 cover safety (readOnly=false, destructive=false, idempotent=true), but the description adds genuinely non-derivable context: no money is charged by this call, the result is a checkoutUrl the user opens to pay externally, and the tool hands off to Stripe. It does not restate or contradict the idempotency hint, and the extra 'nothing is charged' detail is exactly the kind of behavior an agent needs before invoking a payment flow.

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 gating condition and the safety reassurance, and zero filler. The leading 'Optional:' label is slightly puzzling for a top-level tool description and costs it the top mark, but overall it is tight and well-ordered.

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 covers the return value (checkoutUrl) and the payment semantics, and it documents the precondition and terms handshake. It omits the idempotent behavior and any note on what happens after payment, but for a six-parameter tool whose remaining fields are fully schema-documented it is largely 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 baseline is 3, but the description meaningfully extends it by tying acceptTerms to a specific upstream source (the upgrades list's termsVersion) and by framing the whole call as producing checkoutUrl. It still leaves offer/bot/category/shareUrl entirely to the schema, so it is above baseline, not exceptional.

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+resource: starting a Stripe checkout for a paid upgrade (fast-track or Featured placement), and clarifies that it produces a payment link rather than performing the charge. It does not explicitly contrast itself with the payment-adjacent siblings (submit_bot, check_listing), so it lands at clear-but-undifferentiated rather than 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?

It states an explicit precondition chain: call only after the user asked for the upgrade and agreed to its terms, using termsUrl from the upgrades list, and pass that termsVersion as acceptTerms. That is a when-to-call rule with a concrete gating condition, which is as prescriptive as this tool family allows.

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 (readOnlyHint=false, openWorldHint=true, idempotentHint=true, destructiveHint=false): it discloses human review, a live x.ai validation of the share link, creator crediting, the exact status vocabulary returned, and the presence of optional paid upgrades. With no output schema, these details are the agent's only view of the result surface.

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 purpose before constraints, behavior, and cost. Dense but nearly every clause carries decision-relevant information; the status list and cost note could be marginally better separated from the prose, but 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?

No output schema exists, yet the description enumerates the return statuses, explains the validation step, and clarifies that upgrades are optional — filling exactly the gaps a caller would otherwise hit. Combined with annotations covering safety and idempotency, an agent has what it needs to invoke 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 100%, so all five parameters are already documented, including the enum categories and max lengths. The description adds only indirect meaning ('credited to the creator', link checked live) rather than syntax or format guidance, 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 and resource — submit a public Grok Bot share link for a directory listing — with the scope qualifier 'human-reviewed'. This is clearly distinguishable from check_listing or get_bot, which inspect rather than submit.

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 an explicit precondition ('Only for a Bot the user built or has permission to share') and routes to an alternative with a condition ('never call start_checkout unless the user asks'). The free/paid distinction tells the agent which flow belongs to which sibling.

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 read-only, idempotent, and non-destructive behavior. The description adds genuinely useful traits: it caps results at 1–3, returns only the first answer per guide, and warns that content is community guidance rather than official support. This contextualizes trust and result shape beyond the structured annotations.

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-load the main action and cap count, then specify output fields and authority. Every sentence carries information and there is no filler or schema repetition.

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 one well-documented parameter and no output schema, the description compensates by spelling out the output structure (URL, short answer, section, sources) and result count. An agent has enough context to invoke the tool and interpret 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 single required parameter is already fully documented in the schema with a defined description and examples, so the description does not need to add much. The phrase 'Describe a Grok Bot problem' restates the parameter's purpose but adds no new semantic detail beyond the 100% 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 opens with a concrete verb-resource pair ('Describe a Grok Bot problem') and states the exact deliverable: 1–3 relevant Fix problems guides with their first answer. This scope, including result fields, clearly separates it from generic sibling search tools without needing to open their schemas.

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?

'Describe a Grok Bot problem' provides a clear when-to-use trigger: natural-language symptom descriptions rather than keyword lookup. It stops short of explicitly naming alternatives or saying when not to use the tool, but the 'Community guidance, not official support' line adds a meaningful boundary.

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