Heista

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

The description discloses the full pipeline: download, vision tagging (classifies type, detects product name, flags is_primary_product), storage, and database insertion. It also mentions cost and fallback behavior when tagging fails. Annotations are consistent and descriptive.

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 with no wasted words. It front-loads the core action and pipeline, then adds important behavioral details in the second sentence.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has no output schema, the description adequately explains the pipeline and fallback. It covers behavior relevant to decision-making, though it could mention the return value or success indication.

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

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

The input schema covers both parameters with 100% description coverage. The description adds minimal new meaning beyond the schema (e.g., 'Public HTTPS URL'), so it meets the baseline but does not exceed it.

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

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

The description explicitly states 'Upload an image to a brand by URL,' specifying the verb, resource, and method. It clearly distinguishes from sibling tools like retag_brand_asset by detailing the pipeline and fallback.

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 context (uploading by URL with automated tagging) and mentions fallback and retry via retag_brand_asset. While it lacks explicit 'when not to use' guidance, it provides clear context and 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 indicate read-only, idempotent, non-destructive behavior. The description reinforces these with 'Free, read-only, idempotent' and adds behavioral specifics like returning clustered patterns, confidence scores, and visual directions.

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?

Well-structured: main purpose first, then filters, output, usage guidance. Slightly verbose with examples, but each sentence adds value. Could be tightened without losing clarity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity (6 optional params, no output schema), the description covers all essential aspects: what it does, how to use filters, what output fields mean, when to use alternatives. No 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 coverage is 100% with descriptions for each parameter. The description goes further by grouping filters, providing examples, and explaining how they affect results (e.g., vertical examples, hook types). Adds meaning 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 clearly states the tool's purpose: browsing proven ad formula blueprints with structural patterns. It distinguishes from sibling tools like decode_ad and generate_adscript by specifying when to use each.

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

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

Explicitly details when to use (e.g., category-level pattern discovery) and when not to (e.g., specific ad decoding). Provides prioritization criteria for selecting among results and cross-references to 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 annotation defaults, the description reveals cost behavior (2-10 credits), idempotency key retry safety, and that history is not persisted unless thread_id is provided. It does not contradict 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 well-structured, starting with purpose, then discovery, inputs, and output/cost. It is moderately lengthy but each sentence adds value. Minor redundancy could be trimmed, but overall efficient.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (6 parameters, nested objects, no output schema), the description covers essential aspects: one-shot operation, org restrictions, optional inputs, cost, and return envelope structure. Missing explicit details on response format, but acceptable without 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?

Although the input schema already describes all parameters, the description adds high-level context for each (e.g., brand_id loads brand summary, working_context as labels, idempotency_key for retries). This extra guidance aids correct usage beyond the schema alone.

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 invokes a Creative Agent preset, a purpose-built character. It specifies the one-shot nature (message in, text out) and distinguishes from siblings by referencing list_creative_agent_presets for discovery and noting org constraints.

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

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

The description explains when to use the tool (to call a creative character) and provides context on org-based accessibility (workspace vs public). However, it lacks explicit instructions on when not to use it or comparison to alternatives like dispatch 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?

Goes beyond annotations: describes it as a one-shot engine mirroring the internal Creative Director specialist, details output shape switching via medium, notes metered credit usage (3-15) and post-success charging, and mentions structured array for programmatic use. No contradictions with 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?

Well-structured with clear sections and bullet-like formatting, but somewhat lengthy due to exhaustive detail. Front-loads purpose and key distinction, though could be slightly tightened without losing clarity.

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?

Covers all 6 parameters, nested object, output shapes per medium, usage guidance, billing, and integration points. Without output schema, the description fully compensates by detailing return format for each medium.

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?

100% schema coverage already; description adds extensive context: brief examples, count range rationale, full medium enum breakdown with output shape specs, brand_id integration with other tools, lens_hint nested structure, and idempotency_key safety guarantee.

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

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

The description explicitly states the tool is Heista's creative direction engine, providing one-shot generation of N finished creative outputs from a brief. It clearly distinguishes from the sibling chat_with_creative_worlds for refinement, and lists concrete use cases.

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 explicit 'USE WHEN' examples (e.g., 'give me ideas/options/directions', 'write a TVC for...') and clear 'DO NOT USE' exclusions (refinement, critique, non-advertising tasks). Also references the alternative sibling tool for specific scenarios.

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 (readOnlyHint: false, etc.) are generic; the description adds substantial behavioral context: it is a multi-turn, stateful conversation where the agent decides output each turn; session_id management is explained; it lists things it won't do (OKRs, general assistant); metered credits (2-10 per turn) are noted. No contradiction with 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 lengthy but well-structured with clear sections (WHAT YOU CAN ASK, SESSION, USE WHEN, WON'T DO). It front-loads the key distinction from the sibling tool. Minor redundancy (e.g., some examples repeated) prevents a 5, but it remains efficient for the complexity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema exists, so the description must cover return behavior. It explains that a session_id is returned, but doesn't describe the full response structure (e.g., content format, credits used). However, it covers purpose, usage, parameters, and limitations well for a creative tool. Slight gap in return format detail.

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%, but the description adds rich context beyond the schema: examples of what 'message' contains on first vs subsequent turns; clarifies brand_id is only honored on first turn; explains session_id omission/passing. This significantly aids correct usage.

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 specifies a multi-turn conversation with Heista's creative direction engine, listing many concrete output types (territories, TVC scripts, billboards, etc.) and directly distinguishes from the sibling call_creative_worlds by noting outputs outside its medium enum. The verb 'chat' and resource 'creative worlds' are clear.

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

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

Explicit guidance: 'Use whenever the work needs more than one round, OR when you want an output shape not covered by call_creative_worlds' medium enum.' Also states 'Prefer call_creative_worlds when the user wants "three options, done" with no follow-up.' This clearly defines when to use vs 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 indicate readOnly, idempotent, non-destructive. Description adds context about being free, returning specific fields, and providing a top-up link. No contradiction.

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 paragraphs: first describes output, second gives usage guidelines. Every sentence is valuable, no fluff, front-loaded with 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?

Despite no output schema, description lists all returned fields (balance, usage, pricing, top-up link). Covers usage, conditions, and output comprehensively.

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

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

Tool has zero parameters; schema coverage is 100%. Baseline score of 4 is appropriate; description does not need to add parameter info.

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

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

Description clearly states the tool checks the user's credit balance, usage, spend, and pricing. It specifies the verb 'check' and the resource, and distinguishes itself as the only tool for dollar amounts.

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

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

Explicitly states when to use (user asks about credits, balance, usage, etc.) and when not to use (do not use to add credits, do not call on every turn). Provides clear alternatives and constraints.

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 provide readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false, which are consistent with a creation tool. The description adds rich behavioral context: it returns a job_id for polling, costs credits, reads text only, and gives instructions for handling PDFs. No contradiction with 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 fairly long but well-structured with clear paragraphs. It front-loads the main purpose and lists input options concisely. The detailed instructions for documents_inline are necessary given the complexity, but could be slightly trimmed without losing value. Overall, every sentence serves a 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?

Given the complexity (6 parameters, multiple input types, nested objects in documents_inline, no output schema), the description is remarkably complete. It covers all input types (file_ids, document_urls, documents_inline), explains the text-only pipeline, provides polling instructions, lists the output structure (identity, offer, etc.), and gives clear usage guidance. No gaps identified.

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

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

Schema coverage is 100% with descriptions for all 6 parameters. The description significantly adds value beyond the schema, especially for 'documents_inline': it explains the text-only pipeline, how to extract text from PDFs/DOCX, base64 encoding limitations, and why this improves results. For 'brand_id', it explains auto-resolution behavior. Other parameters like 'idempotency_key' and 'context_url' are also well-explained.

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

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

The description clearly states the tool's purpose: 'Build a complete creative intelligence profile from internal brand documents'. It specifies the verb (build/create), the resource (powersource), and the input type (documents). It distinguishes from siblings by explicitly stating when to use create_powersource_url and create_powersource_full, and provides examples of user utterances that trigger this 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?

The description provides explicit usage scenarios: 'when the user says "I have a brief", "here's my brand guidelines", "use this document", drops a PDF / DOCX / strategy deck, or when the truth lives in internal materials'. It also clearly states when NOT to use it ('Do NOT use for URL-only scans') and points to the correct sibling tools. Additionally, it mentions the cost (100 credits) and the polling mechanism.

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 indicate non-read-only and open-world. Description adds credit cost, polling requirement (return job_id, use get_powersource), and internal process detail about cross-checking. No contradiction.

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?

Concise (~200 words), front-loaded with purpose, then parameters, then usage guidance, then cost. No extraneous sentences; every sentence adds value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema, description covers return type (job_id), polling method, credit cost, and how it differs from siblings. Completely addresses what an agent needs to use the tool 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%, but description adds context: explains file_ids, document_urls, and documents_inline with practical tips (pipeline reads text only, base64 encoding, max 5MB). Enhances understanding beyond 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 clearly states the tool builds a high-fidelity creative intelligence profile by combining URL and documents. It uses specific verbs and resources, and distinguishes from siblings like create_powersource_url and create_powersource_docs.

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

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

Explicitly states when to use (both URL and documents, deepest profile) and when not to use (URL-only or docs-only, with sibling tool names and credit costs). Provides clear selection criteria.

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?

Discloses async polling behavior (poll every 3-5s, 60-90s total), suggests get_powersource, details the 14-section output payload, and states cost/credit usage. Annotations already mark readOnlyHint=false and destructiveHint=false; description adds significant behavioral context without contradiction.

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

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

Front-loaded main goal, then parameters, then usage guidelines. Slightly long but justified by complexity; uses bullet-like list for output sections. Could be tightened slightly but effective.

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?

Provides all necessary context: async return pattern, output structure (14 sections), polling guidance, cost, caching, sibling differentiation, and exclusion criteria. No gaps given 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 covers 100% of parameters; description adds value beyond schema by explaining url auto-resolution, brand_id usage context, idempotency_key retry safety, and caching nuance for force_refresh. Webhook_url is minimally explained but acceptable.

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?

Describes specific action: 'Build a complete creative intelligence profile of a brand from a single website URL.' Clearly distinguishes from siblings create_powersource_docs and create_powersource_full by stating what each is for.

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

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

Explicitly lists typical user prompts that trigger this tool, provides when-not-to-use instructions with alternative tool names, and mentions cost and caching behavior. No ambiguity.

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 and idempotentHint=true, so the description does not need to restate safety. It adds value by specifying exactly what data is read (shelves, taxonomy, etc.) and the prerequisite nature, which is 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 that are concise and front-loaded. The first sentence lists the specific data read, and the second provides a clear usage directive. No unnecessary words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with no parameters and no output schema, the description fully covers what the tool does and when to use it. The context of sibling tools (many creative functions) further supports that this is a prerequisite read operation.

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

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

The input schema has zero parameters with 100% schema coverage. The description correctly adds no parameter details because none exist. This is a baseline 4 for zero parameters, but the description's clarity about what the tool returns (though not parameters) earns a 5.

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 reads canonical shelves, taxonomy, relationship Lego, safe content rules, and positional slots for all publishable Creative Library formats. It also specifies a usage directive ('Call this before authoring'), which distinguishes it from sibling tools like creative_get_draft or creative_save_draft.

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 advises calling this before authoring, providing clear context for when to use it. However, it does not explicitly mention when not to use it or list alternative tools, which would improve guidance.

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

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

Annotations already provide readOnlyHint=true and idempotentHint=true. The description adds 'Read one Creative Library draft', which is consistent but does not disclose additional behavioral traits such as error handling or authorization needs. No contradiction with 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 a single, front-loaded sentence with no unnecessary words. It conveys the essential purpose efficiently.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple read operation with annotations covering safety and idempotency, the description is sufficiently complete. No output schema exists, but the tool's return value is straightforward (the draft). The note about review before publication adds useful context.

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

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

Schema coverage is 100% with descriptions for both parameters (slug and shelf). The description does not add extra meaning beyond what the schema provides, so 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?

Description clearly states 'Read one Creative Library draft' with a specific verb (Read) and resource (Creative Library draft). It distinguishes from siblings like creative_publish_article and creative_save_draft by noting the draft is for review before publication.

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?

While the description implies usage for reviewing drafts before publication, it does not explicitly state when to use or not use, nor does it mention alternatives or exclusions. The 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 indicate read-only and idempotent behavior. The description adds value by clarifying that the tool returns editorial metadata only, not customer data, providing additional context beyond 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 extremely concise, consisting of two sentences that are front-loaded with the purpose. Every sentence adds value with no fluff.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple list tool with full parameter documentation in the schema and clear annotations, the description adequately covers the necessary context including the type of data returned, making it 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 covers both parameters (limit and offset) completely with descriptions. The tool description adds no additional meaning beyond what the schema 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 clearly states the action (List), resource (Creative Library articles), and scope (drafts and publication state). It specifies that it returns editorial metadata, distinguishing it from other list tools in the sibling set.

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

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

The description provides clear context about what the tool does and what data it returns (editorial metadata, not customer data). However, it does not explicitly state when to use this tool versus alternatives like creative_get_draft or creative_publish_article.

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 behavioral context beyond annotations: it explains that publication fails if the draft changed, requiring re-review. Annotations already mark it as destructive and idempotent, but the description clarifies the failure condition. No contradiction.

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, direct sentences with no wasted words. The key point is front-loaded: 'Publish only the exact reviewed draft revision.' All content is essential.

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 mutation tool with annotations providing safety info, the description is fairly complete. It explains the failure condition but does not mention the return value (e.g., success indicator). However, given low complexity, a small gap is acceptable.

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 description does not add new information about parameters beyond what the schema descriptions already provide. The description aligns with the expected_revision parameter but adds no further 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 clearly states 'Publish only the exact reviewed draft revision.' This specifies the action (publish) and the resource (draft revision). It distinguishes from sibling tools like creative_save_draft, which saves but doesn't publish.

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 includes a condition: 'If the draft changed after review, publication fails and the new revision must be reviewed.' This makes it clear when to use the tool (after review) and what happens if conditions aren't met. It does not explicitly name alternatives, but the condition provides sufficient guidance.

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

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

Annotations already declare idempotentHint=true, readOnlyHint=false, destructiveHint=false. The description adds the idempotency detail ('identical retry is a no-op') and a limitation ('cannot replace published content or publish a page'), which are helpful but not extensive. No contradiction with 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 three sentences long, each serving a distinct purpose: stating the action, noting idempotency, and clarifying limitations. It is front-loaded and efficient, with no fluff.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the extreme complexity of the input schema (multiple oneOf with many nested objects), the description provides virtually no guidance on how to structure the draft. It fails to explain the different format options, required fields, or constraints. The agent would be left to infer everything from the raw schema, which is unrealistic.

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

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

Schema description coverage is 0%, so the description must compensate for the complex frontmatter and content parameters. The description only vaguely mentions 'canonical taxonomy and format-specific content slots', without explaining the structure, required fields, or allowed formats. This is severely inadequate for an agent to understand how to construct valid parameters.

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

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

The description clearly states it validates and saves a complete Creative Library draft using canonical taxonomy and format-specific content slots. The verb 'save' and resource 'draft' are unambiguous, and the tool name matches. It is implicitly distinct from siblings like creative_get_draft or creative_publish_article, though no explicit differentiation is given.

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

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

The description provides some usage boundaries: it notes that an identical retry is a no-op (idempotency) and that it cannot replace published content or publish a page. However, it does not explicitly state when to use this tool versus alternatives like creative_publish_article or creative_get_draft.

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 destructiveHint=true and readOnlyHint=false. The description adds that it stops being public, leaves sitemap, preserves draft, and allows republishing. This goes beyond annotations without contradiction.

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 succinct sentences that cover operation, effect, and consequence. No fluff 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 simple unpublish action with two parameters and no output schema, the description covers key points: public status, sitemap, draft preservation. It could mention response or prerequisites, but it's adequate.

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

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

Schema coverage is 100% with descriptions for slug and shelf. The tool description does not add extra meaning beyond what the schema already provides. Baseline score 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 takes down a live Creative Library article, making it non-public and removing from sitemap. It distinguishes from siblings like creative_publish_article by specifying the reverse operation.

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

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

It explicitly says 'Use this to reverse a publication,' indicating when to use. It also notes the draft is preserved and can be republished, providing context. However, it doesn't explicitly mention alternatives or when not to use.

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?

Discloses credit costs, polling mechanism (15s intervals, 45-60s completion), and async job pattern. Annotations do not contradict, and description adds significant behavioral context.

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

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

Well-structured with core purpose first, then output format, usage, sources, cost, and exclusions. Minor redundancy but overall efficient.

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?

Despite no output schema, description explains return format (job_id, poll for results) and content of decoded result (breakdown, classification). Covers all key aspects for correct usage.

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 covers both parameters fully. Description adds value by explaining idempotency_key behavior (safe retry without re-charge) and listing supported URL types.

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?

Clearly states it decodes a video ad URL into a structural formula, distinguishing from siblings like decoder_intelligence and adformula_intelligence. Explicitly mentions supported platforms and exclusions (image ads).

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 detailed when-to-use scenarios (user pastes URL, asks for decode) and when-not-to (browsing corpus, image ads) with specific alternative tools mentioned.

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. The description adds context: free, no credits consumed, returns beat timeline and classification, and that the response is the spine; for full bundle call get_decode. No contradiction.

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 well-structured: first sentence introduces the tool, then lists filters and result contents, then usage guidance, then explicit exclusions. Every sentence adds value, and it is concise for the amount of 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?

Despite no output schema, the description explains response contents (beat timeline, classification, psychology, runtime signals, decode id) and the relationship with get_decode. Seven parameters are all described, and sibling differentiation is provided for key alternatives.

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

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

Schema coverage is 100%, so baseline is 3. The description adds context: each filter's purpose, examples (e.g., 'case-insensitive partial match' for brand, '1-10, default 5' for limit), and relationship with generate_adscript. This adds meaning beyond 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 clearly states it browses individual decoded ads from Heista's corpus with optional filters. It uses specific verbs like 'browse' and 'decoded ads', and distinguishes from siblings like decode_ad (new ad) and adformula_intelligence (category patterns).

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 explicitly lists when to use (user wants specific ad as template, asks for winning ads) and when not to use (do NOT for new ad decode, category patterns, writing script). It names alternatives: decode_ad, adformula_intelligence, generate_adscript.

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?

Description explains removal of database row and storage object conditionally, adding context beyond annotations (destructiveHint=true) and specifying destructive 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?

Three concise sentences with clear structure: action, effect, guidance. No redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Single parameter, no output schema, but description provides complete context: what it does, side effects, prerequisite, safety warning. No 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 covers asset_id fully (100%), but description adds value by telling how to obtain it (from list_brand_assets), aiding correct invocation.

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?

Clearly states verb 'delete' and resource 'brand asset', distinguishes from siblings like 'delete_saved_asset' by specifying deletion of brand_assets row and possibly storage object.

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

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

Explicitly instructs to confirm with user before calling and to use list_brand_assets first to find asset_id, providing clear when-to-use and warnings.

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 significant behavioral detail beyond annotations: destruction warning, auth model nuances, and cleanup of storage objects for private saves. Annotations already set destructiveHint=true, but description enriches with actionable context.

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

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

Description is three sentences, each adding distinct value. Front-loaded with the core action, followed by usage warnings and auth details. No redundant or extraneous 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?

Covers all essential aspects: purpose, risks, auth rules, and side effects. Despite having no output schema, the tool's simplicity means this is fully adequate for safe and correct invocation.

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

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

Schema coverage is 100% with a well-described asset_id parameter. Description does not add any new semantic information about the parameter 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 clearly states 'Delete one saved asset by id.' It uses specific verb (delete) and resource (saved asset), and distinguishes from siblings like favorite_saved_asset or list_saved_assets by emphasizing destructive action.

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

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

Explicitly warns about destructiveness and to confirm with user. Clarifies auth model differences (OAuth vs API-key) and constraints on deletion. Does not name alternative tools explicitly but provides clear when-to-use context.

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

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

The description discloses that the tool performs multi-source FACT/INFERENCE extraction with citation discipline, returns labeled findings, and is vertical/geography agnostic. Annotations (readOnlyHint=false, openWorldHint=true, idempotentHint=false) are consistent and the description adds valuable behavioral context beyond what annotations provide.

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

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

The description is concise (~100 words), front-loaded with purpose, and efficiently covers use cases, exclusions, and return structure without unnecessary 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?

Given the tool has 5 parameters and many siblings, the description provides a clear return structure (BRIEF + NOT IN SCOPE + findings + citations + Sources) and lists exclusions. It lacks mention of the async variant (dispatch_desk_researcher_async) but is otherwise 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% with descriptions for all 5 parameters. The description does not add extra meaning to individual parameters beyond the schema, but the schema itself is sufficient. 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 states the tool dispatches to a desk researcher for source-grounded synthesis, with specific use cases like 'what is known about X' and 'fact-check Z'. It distinguishes itself from siblings by listing four excluded tool types (e.g., dispatch_trend_researcher for trajectory), leaving no ambiguity about its function.

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 explicitly says 'Use for:' and 'NOT for:' with clear alternatives for each excluded use case. This gives the agent precise context for when to invoke this tool vs. its siblings.

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 significant behavioral context beyond annotations: it explains that the tool returns a job_id immediately, runs durably on Vercel Workflow without a 300s timeout, and is idempotent. There is no contradiction with annotations (readOnlyHint=false, openWorldHint=true, idempotentHint=true).

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 well-structured and front-loaded with the purpose, then usage guidance, then async specifics and idempotency. It is slightly long but every sentence earns its place. Minor loss for density but still efficient.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of an async dispatch tool with many siblings and parameters, the description is complete. It explains the async pattern, polling instructions, idempotency, and outlines the return structure (BRIEF restatement, NOT IN SCOPE, findings with labels, citations, Sources). Output schema is not provided, so the description compensates effectively.

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

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

The input schema has 100% coverage with descriptions for all 5 parameters. The description adds some context about how parameters relate to the overall goal but does not significantly enhance the meaning beyond the schema. The baseline of 3 is appropriate as the schema already 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?

The description clearly states the tool's purpose as dispatching to the DESK RESEARCHER for source-grounded synthesis on a topic landscape, with specific use cases. It distinguishes from siblings by listing what it is NOT for, such as trajectory questions or entity teardowns, and clearly identifies it as the async version.

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

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

The description provides explicit when-to-use and when-not-to-use guidance, including alternatives for other dispatch tools. It explains the async behavior (use when >90s), how to poll results via get_dispatch_result, and mentions idempotency to avoid duplicate runs. This gives clear context for selecting and invoking the tool correctly.

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?

Describes the full workflow: decomposition, parallel dispatch, polling, quality judgment, and synthesis. Includes wall time (2-5 min), cost ($0.20-1.50), and return fields. No contradictions with annotations; adds significant context beyond readOnlyHint and openWorldHint.

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 well-structured paragraph that front-loads the main action, then flows logically through workflow, usage, exclusions, cost, and returns. Every sentence adds necessary information; no waste.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema, the description provides the return format. With 3 parameters all described, annotations present, and complexity high (orchestrating 6 specialists), the description covers workflow, timing, cost, and constraints completely.

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 100% schema coverage, the description still adds value: brief parameter gets guidance on self-contained structure and concreteness; priority explains production vs. deep models and cost implications; max_wait_seconds explains default and when to adjust. These exceed schema descriptions.

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

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

The description clearly states it runs a full research workflow via the Head of Research agent, decomposing briefs into specialist sub-questions and orchestrating parallel dispatch. It distinguishes itself from individual specialist dispatchers (e.g., dispatch_desk_researcher) by being the orchestrator, and lists concrete use cases.

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

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

Explicitly states when to use (source-grounded research requests) and when not (non-research requests like writing or casual chat). Also provides wall time, cost range, and return structure, helping agents decide appropriateness.

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 indicate readOnlyHint=false (may mutate), openWorldHint=true, idempotentHint=false. The description does not contradict these but adds minimal behavioral detail beyond stating it's a 'dispatch' tool that spawns a specialist. No contradiction detected.

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 well-structured with front-loaded purpose, use cases, exclusions, and return details. It is fairly concise but could be slightly trimmed without losing clarity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 5 well-documented parameters and no output schema, the description adequately explains the tool's purpose, return structure, and differentiation from numerous siblings. Some behavioral details could be added, but overall 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 baseline is 3. The description adds high-level context but does not enhance understanding of individual parameters beyond their schema descriptions.

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

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

The description clearly states the tool performs an entity-deep teardown of a named brand or vendor, with specific examples of use cases. It explicitly distinguishes from siblings by noting what it is NOT for (e.g., dispatch_desk_researcher for topic landscapes, dispatch_trend_researcher for trajectory questions).

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

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

The description provides explicit when-to-use (e.g., 'what is brand X / how does company Y work') and when-not-to-use scenarios, naming alternative tools. This gives clear guidance for tool 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?

Discloses async nature, immediate job_id return, durable execution on Vercel Workflow, polling instructions with wait_ms_hint, idempotency, and expected output (8-axis extraction + MOAT + GAP + Sources). Adds value beyond annotations which only indicated openWorldHint and idempotentHint.

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

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

Front-loaded with purpose, then usage guidelines, output, and async behavior. Every sentence adds value; no filler. Efficiently structured for quick comprehension.

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?

Covers input schema (5 params, 4 required, all described), async workflow, idempotency, and output. No output schema needed since description explains returns. Complete for a complex research 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% with detailed descriptions for each parameter. The description does not add new parameter-level meaning beyond referencing objective and boundaries in context. Baseline 3 is appropriate since schema already fully explains parameters.

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

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

Clearly states it performs entity-deep teardown of a named brand or vendor with specific examples. Distinguishes from sibling tools by explicitly noting it is NOT for topic landscapes (use dispatch_desk_researcher) or category trajectory (use dispatch_trend_researcher).

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 explicit when-to-use criteria (brand, company, competitor, vendor teardown) and when-not-to-use conditions (topic landscapes, category trajectory). Names alternative sibling tools for excluded cases.

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?

Description adds value beyond annotations by detailing the output structure (Corpus, Sampling, etc.) and noting that each theme includes evidence count, quotes, and outlier checks. It does not fully explain side effects (e.g., whether results are stored or if there are costs), but annotations already indicate mutability and external data access.

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?

Description is well-organized with clear sections for use cases, NOT for, and returns. Every sentence contributes useful information without 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?

Given the absence of an output schema, the description thoroughly explains the return structure and methodological components. It also addresses the tool's niche and limitations relative to siblings, making it highly informative 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?

Input schema covers all 5 parameters with descriptions (100% coverage). The description does not add additional meaning beyond the schema; baseline 3 is appropriate as it does not detract but does not enhance.

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

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

Description clearly states the tool performs thematic synthesis from unstructured text, gives specific use-case examples, and distinguishes from sibling tools like dispatch_quantitative_researcher and dispatch_social_listening_researcher by listing what it is NOT for.

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

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

Explicitly states when to use ('what are the 2-3 recurring themes...') and when NOT to use, referencing alternative tools for quantitative effect sizes and multi-platform discourse mapping. This provides clear decision support for the agent.

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

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

Annotations already indicate idempotentHint=true, and the description reinforces this with 'Idempotent: same brief + same org reuses the same job_id'. It also adds useful behavioral details like the async workflow (returns { job_id } immediately, no 300s timeout, durable Vercel Workflow) and describes the specialist's output contents. Does not contradict 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 moderately long but well-structured into clear sections: purpose, use cases, output, alternatives, async specifics. It front-loads the core purpose and is efficient without excessive fluff.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (async, polling, idempotent, many sibling tools), the description covers all necessary aspects: why to use, when to use async, how to poll, output contents, and exclusions. No output schema exists, but the description details the return format sufficiently.

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 clear descriptions for each parameter. The description does not add significant meaning beyond the schema, but the overall context of what the tool does helps infer parameter usage. No explicit parameter examples or cross-references are provided.

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 dispatches to a qualitative researcher for thematic synthesis from unstructured text, with specific example questions. It distinguishes from sibling tools like dispatch_quantitative_researcher and dispatch_social_listening_researcher, making the purpose unmistakable.

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

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

The description explicitly states when to use ('Use for:') and when not to use ('NOT for:') with concrete alternatives. It also specifies when to prefer the async version (over 90s expected duration) and provides polling instructions via get_dispatch_result.

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?

Discloses that negative findings are deliverable ('Often answers with insufficient-evidence when underlying data is thin'). Annotations already indicate openWorldHint=true and readOnlyHint=false, and description adds context about methodology rigor, which is valuable beyond structured fields.

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

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

Four sentences, front-loaded with purpose and usage, no wasted words. Clearly structured with positive use cases, behavioral notes, return format, and explicit exclusions.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 5 parameters (4 required) and no output schema, the description covers purpose, usage, behavioral traits, and return format (4-axis summary, table, gaps, sources). It provides all necessary context for an agent to decide when and how to invoke this 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%, so baseline is 3. Description does not add extra meaning for parameters beyond what schema provides, but that is acceptable given full schema 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?

Clearly states it dispatches to a quantitative researcher for numerical analysis with full methodology context. Provides specific example briefs like 'effect size of X' and explicitly distinguishes from sibling tools (dispatch_desk_researcher, dispatch_qualitative_researcher).

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

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

Explicitly states when to use ('briefs that turn on numbers done rigorously') and when not to use ('NOT for: topic landscapes / community language patterns'), naming alternative sibling tools directly.

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 significant behavioral context beyond annotations: async return of job_id, durable execution on Vercel Workflow, idempotency, negative findings as deliverable, and return structure. No contradiction with 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?

Well-structured and concise, front-loaded with purpose, then usage boundaries, then async specifics. Bullet points for NOT-for and ASYNC version are effective. Every sentence adds value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Covers async workflow, idempotency, polling mechanism, and return summary. With no output schema, the description provides enough context for an agent to understand what to expect and how to handle the response. Could be slightly more precise on the return format but 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 description coverage is 100% with good individual parameter descriptions. The tool description adds contextual meaning (e.g., reference to delegation contract for objective) but does not substantially enhance parameter-level details beyond what the schema 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?

Clearly states it dispatches to a quantitative researcher for numerical analysis with methodology context. Distinguishes from sibling tools like dispatch_desk_researcher and dispatch_qualitative_researcher by specifying it is for numbers-driven briefs.

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

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

Explicitly states when to use (briefs requiring rigorous numerical analysis) and when not to use (topic landscapes for dispatch_desk_researcher, community language patterns for dispatch_qualitative_researcher), providing clear 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 (readOnlyHint=false, openWorldHint=true, idempotentHint=false) indicate a non-read, non-idempotent operation with potential external effects. The description adds detail: treats T3 community sources as primary data, samples ≥3 platforms, and returns a structured signal map with evidence and confidence flags. No contradiction with annotations. Could mention if it modifies any state beyond returning data, but overall strong.

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 paragraph, well-structured with use cases, exclusions, and return format. It is concise but informative. Minor improvement could be bullet points, but it is still effective.

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?

Despite no output schema, the description comprehensively lists what the tool returns (Signal map with components, per-platform evidence, classification, confidence flag, sources). It covers purpose, usage boundaries, and output format. Given the tool's complexity (multi-platform analysis), the description provides complete context.

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

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

Schema description coverage is 100%; all five parameters have descriptions in the schema. The description does not repeat or enhance parameter details beyond the schema, which is fine. Baseline 3 is appropriate as the schema carries the parameter semantics, and the description focuses on overall behavior.

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+resource ('Dispatch to the SOCIAL LISTENING RESEARCHER - multi-platform community-signal interpretation') and gives concrete examples ('what are practitioners saying about X across platforms...'). It explicitly distinguishes from siblings by naming alternative tools (dispatch_qualitative_researcher, dispatch_quantitative_researcher) and their purposes.

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

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

The description provides explicit 'Use for:' and 'NOT for:' sections, listing when to use (cross-platform discourse) and when not (single-source themes, numerical sentiment). It directly names sibling tools for the excluded cases, offering clear guidance.

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

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

Adds critical behavioral context beyond annotations: async job returns {job_id}, durable execution on Vercel Workflow, polling instructions with wait_ms_hint, and idempotency guarantee. No contradiction with 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?

Well-structured with clear sections (purpose, use cases, return format, comparisons, async behavior). Dense but every sentence adds value; slightly long but justified by complexity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Covers purpose, usage, return shape, async pattern, and idempotency. Lacks detailed return JSON structure, but the high-level description is sufficient given the complexity 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 already provides 100% parameter descriptions. The description does not add per-parameter details beyond the schema, so baseline 3 is appropriate; it does provide usage context for the parameters collectively.

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

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

The description clearly identifies the tool as dispatching to a social listening researcher for multi-platform community-signal interpretation, with explicit use cases. It distinguishes from single-source thematic work and quantitative sentiment analysis by naming alternative 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?

Explicitly states when to use (e.g., cross-platform discourse, jargon emergence) and when not to use (single-source or numerical effect sizes), naming alternatives. Also specifies async usage for >90s tasks and idempotency behavior.

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 declare readOnlyHint=false, openWorldHint=true, idempotentHint=false, which align with the dispatch action. The description adds context about the specialist's approach and output structure, but does not detail potential side effects or authorization requirements.

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

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

Well-structured with front-loaded purpose and bullet points. Every sentence adds value, covering use cases, exclusions, and output. Efficient and informative without 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 complex dispatch tool with no output schema, the description fully specifies what is returned (four-axis assessment, drivers, counter-signals, etc.) and covers limitations via NOT-for clauses. All critical usage context is provided.

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

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

Schema coverage is 100%, so baseline is 3. The description does not add parameter-specific guidance beyond the schema, though the overall purpose helps contextualize the parameters.

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

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

The description clearly states it dispatches to a trend researcher for recency-dominant trajectory investigation, lists specific use cases (e.g., 'is X a real trend'), and distinguishes from siblings by explicitly naming alternatives (dispatch_desk_researcher, dispatch_market_analyst, dispatch_quantitative_researcher).

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 explicit when-to-use ('Use for: ...') and when-not-to-use ('NOT for: ...') with sibling tool names. Also describes the methodology ('Commits to falsifying conditions before searching'), offering clear guidance on invocation context.

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

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

Annotations already indicate non-read-only, open world, and idempotent. Description adds: returns job_id, runs durably on Vercel Workflow (no 300s timeout), commits to falsifying conditions, and details output format. No contradiction.

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?

Description is relatively long but well-organized with clear sections (purpose, examples, output, not-for, async behavior). Every sentence adds value, though slight verbosity prevents a 5.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (async, multiple siblings, detailed output), the description fully explains what the tool does, how to use it, when to choose async, and how to retrieve results. No missing information.

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 each parameter has a description. The tool description does not add significant new meaning beyond the schema, though it contextualizes the overall workflow. 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's purpose: trend research with recency-dominant trajectory investigation. It provides example queries and distinguishes from sibling tools like dispatch_desk_researcher, dispatch_market_analyst, and dispatch_quantitative_researcher.

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

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

Explicitly lists when to use (e.g., 'is X a real trend') and when not to use (e.g., static landscape questions, entity teardowns). Also gives async-specific guidance: use when >90s, poll with get_dispatch_result, and notes idempotency.

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 indicate idempotent and not destructive. The description adds context about favorited_at being set/cleared in lockstep for sorting correctness, enhancing transparency beyond annotations. No contradictions.

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: purpose, usage, behavioral detail. No unnecessary words, easy to parse, and front-loaded with the core action.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description covers all necessary aspects for this simple tool: what it does, how to use parameters, behavioral effect, and safety (not destructive). Could mention error handling if asset doesn't exist, but that's a minor gap for a minimal 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 both parameters have descriptions. The description adds value by specifying how to use is_favorite (true/false) and explaining the side effect on favorited_at, going beyond schema alone.

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 toggles the favorite flag on a saved asset, using specific verbs ('Toggle', 'Pass'). It distinguishes from siblings like save_asset (which saves) and list_saved_assets (which lists) by explicitly mentioning the action and parameter usage.

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

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

Explicitly tells when to use it (to favorite/unfavorite) and how to use the is_favorite parameter. However, it does not explicitly contrast with alternatives or state when not to use it, though the context is clear given siblings.

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?

Describes internal routing for PDFs vs HTML (OCR vs readability stripping) and SSRF protection. Adds context beyond annotations (readOnlyHint, openWorldHint) without contradiction.

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?

Concise, well-structured: purpose first, then routing, usage guidelines, non-usage, parameter details. No redundant sentences; every sentence adds value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 2-param tool with no output schema, description covers everything needed: behavior, routing, usage, security, parameters. Agents can select and 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 covers both parameters fully (100% coverage). Description adds default value for max_chars (8000) and reinforces SSRF constraints on url, providing marginal extra value.

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?

Clearly states specific verb (drill into/fetch) and resource (URL after search surfaces it). Distinguishes from sibling search tools by explicitly stating 'NOT for discovering new URLs' and naming alternatives.

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

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

Explicitly lists use cases (verifying quotes, reading primary sources, drilling into product pages) and non-use cases (discovering URLs), directing to sibling tools like search, search_community, search_research.

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 and idempotentHint=true. The description adds valuable behavioral context: 'Aggregates only — never person-level data' (privacy) and 'Returns an error result if product analytics is not configured' (configuration dependency). No contradictions with 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 extremely concise: two sentences that front-load the main purpose and cover scope, privacy, and error condition. Every sentence adds essential information with zero wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (single optional parameter, no output schema), the description covers the key aspects: what is returned (metrics and funnel), constraints (aggregates only, error if not configured), and available time windows. It does not detail the return format, but for an overview aggregation tool this 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% (all parameters described). The description adds minimal extra value beyond the schema: it confirms the possible days values (7, 28, 90) and the default of 7, plus lists the analytics included. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Aggregate') and identifies the resource ('marketing analytics') and scope ('for the last 7/28/90 days'). It lists concrete metrics (pageviews, visitors, sessions, etc.) and explicitly distinguishes from sibling tools by stating 'Aggregates only — never person-level data.' This clearly differentiates from tools like fleet_analytics_top_pages or fleet_analytics_trend.

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

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

The description provides clear context: when to use (need aggregated marketing analytics for predefined windows) and what to expect ('Returns an error result if product analytics is not configured'). It does not explicitly name alternatives or state when not to use, but the purpose is well-defined enough to guide the agent.

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

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

Annotations already declare readOnly and idempotent; description adds hard cap and engagement signals details but lacks rate limits or auth requirements.

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

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

Three sentences, no redundancy, front-loaded with key purpose and constraints.

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?

Covers purpose, parameters, behavior, and constraints adequately. Lacks output format details but sufficient for a simple read-only 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%; description adds real-world examples for path_prefix (e.g., '/decode'), adding value beyond schema descriptions.

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

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

Clearly states the tool returns top marketing pages by views with optional path prefix filter, aggregates only, hard cap 50 rows. Distinguishes itself from other fleet analytics tools like overview and trend.

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?

Implied usage for retrieving top pages by views, but no explicit guidance on when not to use or alternatives like fleet_analytics_overview or trend.

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 declare readOnlyHint and idempotentHint. Description adds 'Aggregates only. Read-only.' reinforcing safety and clarifying data scope beyond 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 concise sentences front-load the functional output and purpose. No extraneous 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?

Given no output schema, the description sufficiently explains the return type (daily pageview series) and scope. For a simple analytics tool, it covers the necessary information.

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 days and metric parameters are well-described. The tool description adds usage context but no parameter details beyond what the schema provides, meeting the baseline.

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 it returns a daily pageview series for specific time windows split by traffic source categories. It distinguishes itself from fleet_analytics_overview and fleet_analytics_top_pages by specifying the granularity and aggregation.

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

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

Explicitly states use case: 'measure launch weeks and content momentum'. Does not exclude alternatives, but the context makes it suitable for aggregated trend analysis.

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?

Consistent with annotations (readOnly, idempotent). Adds critical context: logging start date, 180-day retention, and that crawlers do not execute tracking scripts. No contradictions.

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

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

Three sentences, each serving a purpose: definition, unique value, and usage details. Front-loaded with core purpose, concise and clear.

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?

Covers all essential context: what data is returned, retention policy, start date, and read-only nature. No output schema needed for a straightforward list 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 covers all 5 parameters with descriptions. The description adds value by summarizing grouping and filtering capabilities, reinforcing parameter usage patterns.

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?

Clearly states the tool retrieves server-logged crawler fetches for AI and search engines, naming specific bots and the domain. Distinguishes from siblings like fleet_analytics_overview by focusing on crawler-specific data.

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

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

Explains that crawler hits are invisible to page analytics, justifying its unique use case. Provides grouping and filtering options but does not explicitly mention when to avoid using it or list 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 openWorldHint=false. The description adds that the report includes a creative intelligence payload, but does not disclose additional behavioral traits like rate limits or authorization requirements. With annotations covering safety, the description adds modest context.

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

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

The description is a single concise sentence that front-loads the action and includes relevant context like the payload and read-only nature. Every phrase adds value; 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?

Given the tool's simplicity (one parameter, no output schema), the description fully explains what the tool does and what it returns. It provides enough context for an agent to use it correctly without additional information.

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% for the single slug parameter, which is described as 'Brand report slug from fleet_list_brand_reports'. The description also mentions 'by slug' reinforcing the source. No additional parameter semantics are provided beyond what the schema already states, 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 clearly states the tool reads a live brand report in full by slug, including the creative intelligence payload. It distinguishes itself from sibling tools like fleet_list_brand_reports by specifying it retrieves a single report, not a list.

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 after obtaining a slug from fleet_list_brand_reports, and mentions the report contains 'proof points for outreach and positioning', hinting at when it is useful. No explicit alternatives or exclusions are given, but the context is clear enough.

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

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

Annotations already provide readOnlyHint and idempotentHint. Description adds context that it returns public structural payload (beats, classification, patterns) and that it's the same data as the public decode page.

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. First sentence defines core function and output, second provides usage and restriction. No redundant information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With one parameter, no output schema, and high schema coverage, the description sufficiently clarifies return content and scope. Could optionally mention that the output matches the public decode page format.

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 a clear description for id_or_slug. Description mentions 'by id or slug' but does not add new semantics beyond what the schema 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?

Clearly states verb (read), resource (published decode), and output (structural payload). Distinguishes from sibling tools like fleet_search_decoded_ads and explicitly excludes customer workspace decodes.

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

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

Explicitly says when to use (proof points, content briefs, pattern citations) and when not to (customer workspace decodes). Read-only is stated, but no alternative tool named for excluded use case.

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 indicate readOnlyHint and idempotentHint. Description adds that it returns recent comments including automated scope/fix notes, and that it's locked to team HEI, providing context beyond 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 efficient sentences covering purpose, scope, and output. No redundancy, front-loaded with key 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?

Given the single parameter and no output schema, the description adequately explains what the tool does and returns. Slightly could specify order or limit of comments, but sufficient for a simple read 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?

The schema has one parameter with description, coverage 100%. The description adds example format 'HEI-14' and mentions UUID as alternative, enhancing the schema's info.

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

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

The description explicitly states it reads one Heista Linear issue by identifier or UUID, detailing specific fields returned (title, state, priority, assignee, labels, full description, recent comments). This clearly distinguishes it from sibling tools like fleet_list_issues.

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 clarifies it's read-only and locked to team HEI, implying when to use (fetching a single issue) vs alternatives like fleet_list_issues for multiple issues. No explicit when-not, but clear enough.

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

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

Annotations already indicate readOnlyHint and idempotentHint. The description adds context beyond annotations: quota limit, that indexing is not possible via API, and the specific diagnostic scope. No contradictions with 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 concise with three sentences, each adding distinct value: first states purpose and outputs, second emphasizes diagnostic role, third notes quota and caution. No fluff, front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite no output schema, the description lists specific return fields (index verdict, coverage state, etc.). It also mentions quota and read-only nature. For a single-parameter tool, it is fairly complete, though missing error or response format details.

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 description restates the parameter (url) with similar wording. It does not add new meaning or constraints beyond what the schema already provides, so scores baseline 3.

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

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

The description specifies the verb (inspect), resource (URL index status), and lists concrete outputs (index verdict, coverage state, last crawl time, robots state, canonical resolution). It also explicitly states it is 'THE tool for diagnosing why a page has no impressions,' distinguishing it from sibling tools like fleet_gsc_query or fleet_gsc_top_pages.

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

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

The description provides a quota (2,000 inspections/day) and a caution to 'batch thoughtfully.' It positions the tool as the primary diagnostic for impression issues, implying when to use it. It also clarifies read-only nature, but does not explicitly list alternatives or when not to use.

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 provide readOnlyHint and idempotentHint; the description adds behavioral details like 'LIVE', hard cap of 100 rows, and data lag (~2-3 days), enhancing transparency.

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 clear sentences plus a NOTE, efficient with no wasted words; key information is front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description covers purpose, usage, limitations, and important caveats (e.g., query dimension omission, data lag, history length), making it complete for the tool's complexity.

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 covers 100% of parameters with descriptions; the description adds value through contextual notes (e.g., query dimension caveat) but does not significantly extend beyond 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 clearly states it's a LIVE Google Search Analytics query that groups by up to 3 dimensions with filters over 16 months, distinguishing it from snapshot 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?

Explicitly advises when to use it ('ad-hoc analysis') versus snapshot tools, and includes a specific NOTE about when to avoid certain dimensions for complete totals.

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, making the behavior clear. The description confirms read-only and adds context about returned fields (counts, timestamps, warnings, errors) and a specific data example. This adds moderate value beyond 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 concise at two sentences plus a brief example. Every sentence provides essential information: what the tool does, what data it returns, an illustrative example, and constraints. No wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter read-only tool, the description fully covers what the agent needs: data content (submitted/indexed counts, last-download time, warnings/errors), a real-world example to calibrate expectations, and the read-only nature. No output schema needed.

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 with 100% schema coverage. The description explicitly states 'No parameters,' which is clear and sufficient. Baseline for 0 params is 4, and the description meets that.

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

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

The description clearly states the tool retrieves sitemap indexing data from Search Console, including submitted vs indexed counts, timestamps, and errors. It distinguishes itself from sibling tools like fleet_gsc_summary by focusing specifically on sitemaps, and mentions a concrete example that clarifies the output.

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 for tracking SEO fixes ('Track this as SEO fixes land.') and explicitly notes it has no parameters and is read-only. It does not explicitly list when not to use or alternative tools, but the context and sibling names make this inferable.

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 indicate read-only and idempotent. The description adds critical behavioral context: data is synced 6-hourly, lags by 2-3 days, limited to a 28-day window, and is read-only. No contradictions with 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 a single, well-structured sentence that front-loads the purpose and includes all key details (metrics, data source, sync interval, lag, constraints). No wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite lacking an output schema, the description lists all returned metrics (clicks, impressions, CTR, position, distinct queries/pages), data source, sync cadence, lag, and window constraint. For a tool with 2 optional params, this is fully complete.

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

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

Schema has 100% description coverage for both parameters (days, page_prefix). The description mentions the page-path filter and alludes to the window size but adds no new meaning beyond the schema. 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 it provides total search performance metrics (clicks, impressions, CTR, etc.) from Google Search Console. It distinguishes itself from sibling GSC tools by focusing on aggregate totals and mentions optional page-path filter, making its purpose unambiguous.

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

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

The description implicitly guides usage by noting it's for totals and includes data lag (2-3 days) and max window (28 days). However, it does not explicitly compare to sibling tools like fleet_gsc_query or fleet_gsc_top_pages, so some guidance is present but not exhaustive.

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

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

Beyond annotations (readOnlyHint=true, idempotentHint=true), the description adds key constraints: 'Hard cap 50 rows, max window 28 days' and clarifies it uses 'first-party Search Console data'. These are critical for agent decision-making and are not present in 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, front-loaded with purpose and parameters, followed by usage and constraints. Every word adds value; no redundancy or fluff.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description clarifies the data source, optional filter, and constraints. Without an output schema, it could detail the returned fields more explicitly, but the purpose is clear enough for correct selection.

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 description does not add substantial meaning beyond the schema. It mentions the optional query_contains filter but does not elaborate on format or behavior. 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 returns 'Top pages by Google search clicks or impressions' with optional query filtering, and specifies its use case for finding 'pSEO pages' that earn search demand. This distinguishes it from sibling tools like fleet_gsc_top_queries.

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

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

The description provides a clear use case ('Use to find which pSEO pages earn search demand') and implies it is for page-level data. It does not explicitly state when not to use or name alternatives, but the context of sibling tools makes the differentiation evident.

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 and idempotentHint. Description adds hard caps, max window, and data source (first-party Search Console). No contradictions. Could mention sorting behavior, but overall sufficient.

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

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

Three sentences, each serving a purpose: functionality, use case, constraints. Front-loaded with core action. No extraneous 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?

Covers data source, filtering, ordering, limits, use case, and safety. Lacks explicit mention of output fields (e.g., clicks, impressions, position), but this is implied. Sufficient for a read-only listing tool with good 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 covers all parameters with descriptions (100% coverage). Description reinforces constraints (hard caps) and adds usage context for page_prefix filter. Adds value beyond 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?

Clearly states it retrieves top Google search queries (verb+resource) from Search Console data. Distinguishes from siblings like fleet_gsc_top_pages by focusing on queries, and explicitly calls it 'the core tool for briefing programmatic SEO.'

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

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

Provides clear context for use ('the core tool for briefing programmatic SEO') and constraints (50 rows, 28 days). Does not explicitly state when not to use or list alternatives, but the family of fleet_gsc tools imply differentiation.

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 indicate read-only, idempotent behavior. The description adds that it is free and has no parameters, and clarifies the specific data it returns, which is 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?

Three sentences, front-loaded with the most important information, no wasted words. The description is tightly written and easy to parse.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no parameters and no output schema, the description fully covers the tool's purpose and output. It lists all returned fields and usage context, leaving no 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?

No parameters, so schema coverage is 100%. The description explicitly mentions 'no parameters,' confirming the empty schema. Baseline of 4 is appropriate as no further semantic detail is needed.

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

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

The description clearly states it returns canonical corpus counts for ad intelligence, listing specific data points (decoded ads published, total corpus size, etc.). It distinguishes itself as the single source of truth to prevent number drift, setting it apart from 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?

Explicitly advises using this tool BEFORE citing any corpus number in content, outreach, or briefs, providing clear guidance on when to use it and implying it should be preferred over other tools for these counts.

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 and idempotentHint=true. Description states 'Read-only', aligning with annotations and adding no contradictions.

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 with key information front-loaded. Every sentence adds value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite no output schema, description lists return items (identifiers, ad counts, public URLs) and mentions alternative tool. Sufficient for a listing tool with clear 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 coverage is 100% with detailed parameter descriptions. The description adds a holistic summary (optional filter, pagination, cap) but doesn't add new semantic detail beyond 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 clearly states the tool lists live brand-level Ad Intelligence reports and specifies the public /decode/brand pages. It distinguishes from sibling tool fleet_get_brand_report.

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

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

Explicitly mentions optional brand-name filter, pagination, hard cap 50 rows, and directs to fleet_get_brand_report for full details. Provides when-to-use and alternative.

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 behavioral details beyond annotations: hard cap of 50 rows, read-only confirmation, and the nature of articles (live, not static). No contradictions with 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 plus a note, each sentence adds value. Front-loaded with main action, no wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Covers input constraints and exclusions well. Lacks output schema or description of return fields, which is a minor gap given 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%, but description adds value by contextualizing parameters (e.g., 'Filter by kind (weekly/category) or vertical') and reinforcing hard cap.

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

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

Description clearly states 'List live intelligence articles' with verb and resource. It distinguishes from static deep-dive articles and sibling tools like creative_list_articles and fleet_list_issues.

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 filtering options (kind, vertical) and explicitly excludes static articles. Lacks explicit when-not-to-use compared to alternatives, but context is clear.

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

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

Annotations already provide readOnlyHint and idempotentHint. Description adds hard cap (100 rows) and explicitly states fleet cannot create/edit/close tickets, reinforcing safety.

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 well-structured sentences, front-loaded with purpose, no unnecessary 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?

Covers board, team, filtering, limit, read-only constraint, and sibling differentiation. Complete for a list tool with 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%, descriptions are already effective. Description adds example values for state and label filters but no new syntax or constraints beyond 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?

Clearly states listing issues on a specific Linear board (Heista, team HEI) with a read-only purpose. Differentiates from fleet_get_issue for full details.

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

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

Explicitly directs to fleet_get_issue for full description/comments, and mentions hard cap and read-only nature. Does not explicitly state when not to use, but sibling differentiation is clear.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds that it requires mcp:fleet:customer_pii permission, every call is audit-logged, and it's read-only. This adds behavioral context (auth, logging) beyond annotations, without contradiction. It does not explain return format but is sufficient.

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: first sentence details what it does and lists key metrics, second sentence adds usage guidance, permissions, logging, and read-only flag. It's front-loaded with the most important information and every sentence earns its place. No wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (aggregating funnel stats), the schema is minimal (1 param) and there is no output schema. The description explains what metrics are returned conceptually (conversion rate, etc.) and the purpose. It doesn't specify exact return format, but it's complete enough for an agent to understand the tool's value and operation.

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

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

Only one parameter 'days' with full schema description (max 90, min 1, default 30). The description mentions 'last N days, max 90' which reinforces the schema. No additional meaning beyond what the schema already provides. Baseline 3 is appropriate given 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 clearly states it aggregates conversion/drop-off stats for a signup cohort, listing specific metrics like trial active, expired-unconverted, converted-to-paid, conversion rate, etc. It explicitly distinguishes itself from aggregating individual summaries, and the verb 'aggregate' with resource 'signup cohort stats' is specific. It also answers 'where is the funnel leaking' which is a clear purpose.

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 says when to use: to get funnel stats in one call instead of aggregating individual summaries. It mentions the parameter limit (max 90 days). It doesn't explicitly say when not to use or name alternatives, but the context of sibling tools implies it's for a specific purpose. It provides clear context but lacks 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?

Beyond annotations, description adds auth requirement (mcp:fleet:customer_pii), audit-logging, read-only nature, and hard cap of 50 rows. All disclosures are consistent with 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 sentences: first states action and constraints, second gives use case, third notes permissions and logging. Every sentence adds value, no redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a read-only list tool with full schema and annotations, description covers usage, permissions, shape reference (to fleet_product_user_summary), and logging. No gaps for typical agent use.

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 covers 100% of parameters with clear descriptions (days, limit). Description reiterates constraints (last N days, hard cap 50) but adds no significant new meaning beyond schema.

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

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

Description clearly states 'List recent signups' with specific constraints (last N days, hard cap 50 rows) and shapes (same as fleet_product_user_summary). Distinctive from siblings by focusing on newest cohort.

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

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

Explicitly says 'Use to see the newest cohort at a glance before drilling into individuals' and lists required permission and audit logging. Lacks explicit exclusions or alternatives to other fleet 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 declare readOnly and idempotent hints. Description adds 'Every call is audit-logged' and explicitly states 'Read-only', reinforcing and extending behavioral context. No contradiction with 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 with dense, useful information. Could be slightly more structured (e.g., bullet points), but it's concise and front-loaded with purpose. No wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema but description lists returned data points comprehensively. Covers input, prerequisites, and behavior. Given the single parameter and rich output, this is complete.

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

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

Schema has 100% coverage with email description. The description does not add parameter-specific details beyond what the schema provides, so 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 starts with a specific verb+resource ('Look up ONE customer's product-backend state') and lists concrete fields (trial status, credit balance, etc.), distinguishing it from sibling tools like fleet_product_funnel_summary. Clearly states what it does.

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

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

Explicitly states required scope ('mcp:fleet:customer_pii') and references documentation. Implicitly tells when to use: when needing customer product state. No explicit alternative exclusion, but specificity makes it clear.

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

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

Discloses return format (list rows with public URLs), hard limit 50, pagination requirement, and read-only behavior. Annotations already indicate readOnlyHint, idempotentHint, no contradiction.

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: first states purpose and filters, second details limitations and alternatives. Extremely concise and well-structured.

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?

Fully covers return format, pagination, limits, read-only, and alternative tool. With 7 optional parameters and no output schema, description is sufficient 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%, so description adds minimal value beyond summarizing filter types. No new parameter details beyond schema.

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

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

Description clearly states the tool searches the published Ad Intelligence corpus and lists filters (free-text, brand, category, vertical, platform). It distinguishes from fleet_get_decoded_ad by noting it returns list rows with public URLs, not full payload.

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

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

Explicitly states when not to use (for full structural payload, use fleet_get_decoded_ad), hard cap 50 rows, paginate with offset, and read-only nature.

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 and idempotentHint=true, so the description's 'Read-only' is redundant but consistent. It adds value by specifying default window (7 days), max window (180), and that GSC/orphan figures are trailing-28d snapshots, which aids agent understanding of data freshness.

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 efficient but dense, front-loading the purpose and key metrics. Every sentence adds value, though it could be slightly shorter without losing meaning. The structure is logical: purpose, data types, usage guidance.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema, the description adequately outlines the return values (orphan counts, crawl activity, GSC metrics) and baseline comparisons. It covers behavior, window constraints, and intended use, making it sufficiently complete for an agent 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 coverage is 100% for the single parameter 'days', with a description. The tool description adds context beyond the schema by explaining the default (7), max (180), and that GSC/orphan figures are unaffected by this parameter. This helps the agent set appropriate values.

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 it's a 'one-row verification scorecard' for the 'indexing-recovery plan', enumerating specific metrics (orphan counts, crawl activity, GSC data). It distinguishes itself from generic analytics or GSC tools by focusing on recovery verification with baseline comparisons.

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 explicitly advises when to use this tool: 'Use this to confirm PR-A/B/C landed and is moving the needle, not just that the code shipped.' This gives clear usage context and implies it's the right tool for this verification, differentiating it from other monitoring 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?

The description adds value beyond annotations by explicitly listing the fields returned (total pages, OK/redirect/error counts, ORPHAN pages, etc.) and stating it is read-only. Annotations already declare readOnlyHint and idempotentHint, but the description enriches with specific output details.

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

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

The description is a single concise sentence with a well-structured list. It is front-loaded with the core purpose and every element adds value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite no output schema, the description lists the output fields comprehensively. It also references the sibling tool fleet_site_pages for deeper analysis, making it complete for the tool's role.

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 no parameters, and schema coverage is effectively 100%. The description does not need to add parameter information, so baseline of 4 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 it provides a 'one-row health scoreboard' from a weekly crawl, listing specific metrics. It distinguishes from sibling 'fleet_site_pages' by advising to 'Start here before drilling into fleet_site_pages.'

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

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

The description gives clear context: 'Start here before drilling into fleet_site_pages.' It implies the alternative tool (fleet_site_pages) but does not explicitly state when not to use it.

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

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

Beyond annotations (readOnlyHint, idempotentHint), the description adds key behavioral context: data comes from first render of sitemap-listed pages, pagination-only links are not observed, and it mirrors crawler discovery. This helps the agent understand data completeness and limitations.

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

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

The description is three sentences with front-loaded purpose, followed by data source context and constraints. Every sentence adds value with no redundancy or extraneous 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?

Given 3 parameters, good annotations, and no output schema, the description covers the tool's behavior adequately: direction meaning, data source, limits, and read-only nature. It could briefly mention output structure, but overall it is fairly 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% and the description adds little beyond schema definitions. It explains direction values and mentions the default limit, but does not provide additional meaning or formatting details beyond what is already in 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 clearly states the tool retrieves internal links for one page, explaining 'in' and 'out' directions with examples (e.g., 'zero inlinks = orphan'). This distinguishes it from sibling tools and provides a specific verb+resource.

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

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

The description explains that the tool works for a single page, requires a path, and offers direction options. It mentions constraints like hard cap 200 rows and data source limitations, but does not explicitly compare with alternatives or state when not to use it.

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