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

With no annotations, the description carries the full burden of behavioral disclosure. It only lists analysis dimensions and does not mention side effects, external data access, read-only nature, performance implications, or any constraints. An agent cannot anticipate what happens when the tool is invoked.

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

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

The description is a single, efficient sentence that is front-loaded with the core purpose ('Deep-dive competitive analysis') and enumerates relevant facets without redundancy. It is appropriately concise, though it could benefit from a brief use-case note without losing economy.

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 only two parameters and no output schema, the description covers what the analysis addresses but omits essential context such as when to use it, what the output looks like, any prerequisites (e.g., having a brand name), and how it differs from similar sibling tools. This leaves significant gaps 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 0%, and the description does not mention either parameter (brand or category). It provides zero added meaning beyond the bare schema types, leaving the required 'brand' and optional 'category' undefined in terms of expected format or interpretation.

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 a deep-dive competitive analysis and lists specific dimensions (positioning, messaging, ad strategy, etc.). However, it does not differentiate from nearby siblings like compare_competitors, analyze_positioning, or analyze_competitor_ad, leaving overlap ambiguity.

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

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

No guidance is given on when to use this tool versus alternatives. There is no mention of prerequisites, typical scenarios, or conditions that would make this tool preferable to a sibling, leaving the agent without direction on 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?

With no annotations, the description carries the full burden. It does disclose a key behavior: 'Falls back to copy heuristics when no vision backend available', which is valuable. However, it does not mention whether the operation is read-only, potential side effects, or the return format, leaving some ambiguity for an agent.

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

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

The description is three concise sentences with no filler. The primary purpose is front-loaded in the first sentence, the fallback behavior in the second, and the derive usage in the third. Every sentence adds distinct 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 five optional parameters, no annotations, and no output schema, the description should provide more operational detail. It explains the core analysis and the fallback, but does not describe the expected output shape (raw breakdown vs. counter-brief), how to use 'batch' vs. single-input fields, or any prerequisites. The agent is left to infer much of the calling convention.

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

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

Schema coverage is only 40% (batch and derive have descriptions). The description adds meaning to 'image_path_or_url' by stating it can be a 'URL or local path' and clarifies 'derive' as aggregation, but it does not explain 'caption' or 'transcript' beyond their existence, nor the structure of the 'batch' array objects beyond a terse schema hint. It partially compensates for the coverage gap but not fully.

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

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

The description clearly states a specific verb ('Deconstruct'), resource ('competitor ad'), and method ('via VLM'), and enumerates the analytical dimensions (hook, pacing, psychological triggers, CTA, counter-angles). It distinguishes itself from generic 'analyze_competitor' by focusing on ad deconstruction, but does not explicitly differentiate from sibling 'breakdown_ad', so it loses the top score.

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

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

There is no explicit guidance on when to use this tool versus alternatives like 'analyze_competitor' or 'breakdown_ad'. The only usage hint is the conditional 'Use derive=true to aggregate multiple ads into a counter-brief for generate_creatives', which addresses a specific flag but not overall tool selection or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the return values but says nothing about side effects, data sources, required inputs, or any constraints. For an analysis tool that likely performs significant processing, this is insufficient 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?

The description is a single, efficient sentence that front-loads the action. It avoids redundancy and is appropriately brief, though it might be too sparse given the tool's 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?

The tool expects three parameters with one required, but the description doesn't elaborate on what constitutes a valid 'brand' or how 'product' and 'industry' modify the analysis. There's no mention of output format beyond the vague list, and no guidance on edge cases or expected usage context. This is incomplete for a tool that returns complex business analysis.

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%, and the description does not compensate at all. It doesn't explain what values 'brand,' 'product,' or 'industry' should take, what the defaults mean, or how they influence the output. The parameter names alone are insufficient.

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 (analyze your brand's market positioning against competitors) and the expected outputs (positioning map, differentiation strategy, messaging framework). It distinguishes itself from sibling tools like analyze_competitor and compare_competitors by focusing on 'your brand,' though it doesn't explicitly name those 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?

The description provides no guidance on when to use this tool versus similar sibling tools (e.g., analyze_competitor, compare_competitors). There's no context about prerequisites, typical scenarios, or 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?

With no annotations, the description carries the behavioral burden. It does disclose that routing can be previewed without executing, implying that execution occurs otherwise. However, it doesn't explain potential side effects, return behavior, or consequences of routing to tools that may create, launch, or schedule content.

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

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

The description is short, front-loaded with the core purpose, and each sentence earns its place: purpose, plain-language usage, example queries, and route_only guidance. No redundant or filler content.

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

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

It gives enough to select the tool, but for a router with no output schema and a nested arguments object, it should clarify what the response looks like, how routing decisions are surfaced, and how arguments should be shaped. These gaps make it adequate but not 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?

The schema covers question and arguments descriptions, and the description adds useful examples and clarifies route_only=true as a preview mechanism. However, the arguments object remains vague—what shape it should take and how it maps to routed tools is not 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 identifies the tool as a 'Master router - one entry point for Marketic' and states that it routes natural-language requests to specialist tools. This distinguishes it from the many sibling specialist tools and gives concrete examples of supported requests.

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 conveys clear context: use this as a single entry point for natural-language marketing questions or tasks, and use route_only=true to preview routing. It doesn't explicitly state when not to use it or name alternatives, but the router positioning makes the intended usage 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 are absent, so the description carries full responsibility for behavioral disclosure. It implies a read-only operation via 'Get' but doesn't state it explicitly, nor does it mention return format, side effects, permissions, or rate limits. The behavioral transparency is minimal.

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, succinct sentence with no redundant words. It is front-loaded with the action and resource. While concise, the brevity also contributes to incompleteness, but on this dimension alone it is 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?

With no output schema, no annotations, and no parameter descriptions, the definition is severely inadequate. It doesn't explain the nature of the cost summary, how 'model and action type' map to parameters, or expected date formats. An agent cannot reliably invoke this tool correctly based on this description alone.

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% and the description fails to explain the parameters. It mentions 'date range' but doesn't clarify start_date/end_date format. It also mentions 'model and action type' which are not present in the schema parameters, causing confusion. The description adds little value beyond the bare parameter names.

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

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

The description clearly states the verb 'Get' with a specific resource 'cost summary' and scope 'by model and action type for a date range'. This differentiates it from log-related siblings like audit_get_log. However, it could explicitly contrast with siblings to score a 5.

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

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

There is no guidance on when to use this tool versus alternatives like audit_get_log. No mention of prerequisites, use cases, or when not to use it. The description simply states what it does without any routing context.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It implies a read-only operation via 'Retrieve' but does not state whether there are side effects, pagination behavior, rate limits, or what the response format is. The description adds minimal transparency beyond the basic action.

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 sentence that immediately states the function and filtering scope. It is concise with no extraneous information, fully front-loaded with the core capability.

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 five parameters, no output schema, and no annotations, the description is insufficient. It does not explain what constitutes an audit log entry, how to specify a valid action or date range, what the 'limit' parameter controls, or what the response contains. An agent would struggle to invoke it correctly without additional 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?

Since schema description coverage is 0%, the description must compensate by explaining parameters. It mentions filtering by brand, action, and date range, which maps to brand_id, action, start_date, and end_date. However, it gives no details on acceptable formats for dates or action values, and it entirely omits the 'limit' parameter. Adds some meaning but leaves significant gaps.

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 clear action ('Retrieve') and resource ('audit log entries') with specific filtering dimensions (brand, action, date range). It is specific, though it does not explicitly distinguish itself from the sibling 'audit_log' tool, which likely serves a similar 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 provides no guidance on when to use this tool versus alternatives like 'audit_get_cost_summary' or 'audit_log'. It does not mention any conditions that would make this the preferred choice, nor any 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses the fields it records (model, cost, confidence, reasoning chain, human approval status), which is informative. However, it does not mention any side effects (e.g., permanence of the log, auth/permission requirements, rate limits) or whether the operation is synchronous. For a logging tool, this is a moderate level of transparency, but gaps remain.

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 sentence that front-loads the core action ('Log an AI marketing action') and then lists the recorded fields. There is no redundant or filler text; every clause adds value. It is concise and well-structured for quick parsing.

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 its concise phrasing, the description is not complete given the tool's complexity (11 parameters, nested objects, no output schema). It does not explain return values, the significance of many parameters, or the expected behavior when fields are omitted (e.g., defaults). The absence of annotations amplifies the need for more context, which is not 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 description coverage is 0%, so the description must compensate for parameter meanings. It clarifies the purpose of model, cost, confidence, reasoning_chain, and human_approved. However, it leaves action, brand_id, metadata, input_tokens, output_tokens, and result_summary unexplained. With 11 parameters, covering only 5 is insufficient; an agent would not know the significance of the omitted ones without further context.

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

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

The description clearly states the tool's purpose with a specific verb and resource: 'Log an AI marketing action with full audit trail.' It also enumerates the key data recorded (model, cost, confidence, reasoning chain, human approval status), which makes its function unambiguous. The verb 'log' distinguishes it from retrieval siblings like audit_get_log and audit_get_cost_summary.

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 (when an AI marketing action needs to be recorded) but does not explicitly state when to use this tool versus alternatives. It does not mention audit_get_log or audit_get_cost_summary as alternatives, nor does it specify conditions for choosing this tool over others. The verb 'log' gives a hint, but explicit guidance is absent.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does reveal the fallback chain (Ollama vision locally → cloud vision → heuristic parsing), which is useful. It also mentions optional brand enrichment. However, it does not describe the output format (e.g., a structured list of components) or what happens if all vision methods fail, leaving meaningful behavioral gaps.

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

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

The description is remarkably concise: two sentences that front-load the core purpose (breakdown into components) and efficiently cover input modes and the processing fallback. Every sentence adds value, and there is no redundant phrasing or unnecessary detail. It is appropriately sized for the tool's 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?

The description does a good job of explaining how the tool processes inputs (URL or text, vision/fallback, optional brand context), but it omits details about the return structure. Since there is no output schema, the agent must infer what the breakdown looks like. It also doesn't mention failure handling beyond the fallback, nor rate limits or error conditions. Overall, it covers the input side well but leaves the output side ambiguous.

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

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

The schema already provides 100% description coverage for all three parameters, including their purposes and allowed values. The description adds a small amount of extra meaning by clarifying that ad_url_or_text can be either a URL or text, and by explaining the depth levels implicitly through the fallback chain. However, it largely restates what the schema already says, so it does not meaningfully augment the parameter understanding.

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 breaks down competitor ads into specific structural components (hook, offer, call-to-action, emotional triggers, pacing, format) and specifies two input modes (URL or text). It is specific about the verb ('break down') and the resource ('competitor ad'), but it does not explicitly distinguish itself from the similar sibling 'analyze_competitor_ad', which could lead to ambiguity about which tool to use for a given task.

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 by stating the tool works from a URL or raw ad copy text, and that it can optionally enrich with brand context. However, it provides no explicit guidance on when to use this tool versus the closely related sibling 'analyze_competitor_ad', nor does it mention any exclusions or alternative routing. The context is clear but the differentiation is missing.

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

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

With no annotations provided, the description carries the full burden of behavior disclosure. It only says it 'builds' a strategy, which implies creation, but it doesn't state whether this mutates data, requires authentication or permissions, or produces a plan vs. persisting changes. There is no mention of side effects or output 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?

A single, front-loaded sentence with no filler. It states the primary purpose immediately. However, given the tool's complexity and the lack of other documentation, its brevity borders on under-specification, so it doesn't earn 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?

The tool has 6 parameters, 2 required, no output schema, and no annotations. The description only provides a high-level purpose with no details on return values, prerequisites, error conditions, or how to use the parameters. It is far from complete for an agent to successfully invoke it without additional 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 0%, so the description must compensate by explaining parameters. It references 'channel-specific tactics, budgets, and timelines' which loosely map to channels, total_budget, and duration_weeks, but it omits campaign_name, objective, and target_audience entirely. It adds minimal value over the bare schema and fails to clarify required vs optional semantics.

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

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

The description states a clear verb ('build') and resource ('complete multi-channel campaign strategy') with specifics like 'channel-specific tactics, budgets, and timelines.' It distinguishes from execution tools like launch_campaign_ad by focusing on strategy creation, but doesn't explicitly name alternatives, so it falls short of a 5.

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

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

No guidance on when to use this tool versus related siblings like schedule_content, optimize_budget, or generate_creatives. The description implies it's for planning but never states usage context, prerequisites, or exclusions. An agent would have to infer when this is the right tool.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states the action ('Build') without revealing return format, side effects, validation rules, or any other behavioral traits. For a tool that constructs a URL, an agent might expect to know if it returns a string, whether it encodes parameters, etc. This is a significant gap, rating a 2.

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

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

The description is a single, efficient sentence with no wasted words. It front-loads the main purpose. However, it is so minimal that it borders on under-specification, but since it is concise and not tautological, it earns a 4 rather than 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 6 parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain what each parameter means, the expected return, or any constraints. An agent cannot reliably call this tool correctly with the provided information, so contextual completeness is 1.

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 by explaining parameter meanings. It does not—no parameter semantics are provided beyond the raw schema names. The description adds zero value in this dimension, so a score of 1 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 verb 'Build' and resource 'UTM-tagged URL' with a purpose ('for campaign tracking'). It is unambiguous but does not differentiate from the sibling 'parse_utm_params', which performs the inverse operation. Hence a 4, clear but lacking sibling distinction.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., parse_utm_params for parsing instead of building). There is no mention of contexts, exclusions, or preferred scenarios. This falls under 'no guidance', earning a 2.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It only says it 'collects' signals, which implies a read operation, but it does not disclose side effects, rate limits, pagination, return format, or whether it aggregates across sources or returns raw data. This is a significant gap for a multi-source data collection tool.

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

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

The description is a single, efficient sentence that front-loads the action and lists the key sources. There is no fluff or redundancy. It is appropriately compact for a tool with this level of 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?

Given three parameters, no annotations, and no output schema, the description is insufficient. It does not explain what constitutes a 'signal', how the data is returned (structure, format), whether results are aggregated or individual, or any filtering/resolution logic. An agent would need to guess at the actual behavior, making this tool risky to invoke correctly without further documentation.

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. It mentions the sources (product_hunt, hacker_news, twitter, reddit) which aligns with the sources parameter, and 'for a brand' clarifies the brand parameter. However, it does not explain the 'days' parameter at all, and the meaning of 'signals' remains ambiguous. The description adds minimal value beyond the parameter names.

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

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

The description clearly states the action (collect), the resource (marketing signals), and explicitly lists the sources (Product Hunt, Hacker News, Twitter, Reddit) and scope (for a brand). It is specific enough to distinguish from generic tools, though it does not reference sibling tools by name.

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 no guidance on when to use this tool versus alternatives like track_signal, resolve_signal, or signal_fanout. It does not mention exclusions, prerequisites, or describe the preferred context. The only implied usage is 'for a brand', which is insufficient for a tool with multiple related 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?

With no annotations, the description carries the full burden of disclosing behavior. It does state that the tool 'Returns feature comparison matrix, price comparison, and strategic recommendations,' which is good, but it does not explicitly state read-only nature or absence of side effects. For an analysis tool this is acceptable, but not fully transparent.

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

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

The description is a single, efficient sentence that front-loads the purpose and then lists the outputs. There is no wasted text, making it easy to parse quickly.

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

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

For a simple tool with two parameters and no output schema, the description covers the primary purpose and output types. However, it does not mention potential error conditions, input format expectations, or any special prerequisites, leaving minor gaps for an agent that needs to call it correctly.

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

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

Schema description coverage is 0%, meaning the description does not explain the parameters beyond what the schema names. It mentions 'your product' and 'multiple competitors' but does not elaborate on formats, constraints, or examples. The description fails to compensate for the low schema coverage, so an agent gets little extra semantic clarity.

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 clear verb ('Compare') and resource ('your product against multiple competitors'), and specifies the output types. The phrase 'multiple competitors' distinguishes it from sibling tools like 'analyze_competitor' which likely handle single competitors, so an agent can tell them apart without opening the schema.

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

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

The description provides clear context: it is for comparing against multiple competitors, which implicitly guides selection over single-competitor tools. However, it does not explicitly mention alternatives or when not to use it, so it lacks exclusions but is clear enough for typical 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?

No annotations are provided, so the description carries the full burden. It mentions the tool 'sets' value, stage, and links to lead, indicating mutation, but does not disclose side effects, required permissions, prerequisites (e.g., lead must exist), or behavior when lead_id is empty. Lacks detail for a mutation tool.

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

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

A single, efficient sentence that front-loads the action. Every word carries meaning, but the structure is flat with no additional contextual layers.

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

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

For a tool with 5 parameters, no output schema, and no annotations, the description is incomplete. It fails to explain the purpose of owner_id, the scenario when lead_id is absent, the return value, or how it differs from crm_move_deal. An agent would need to infer important 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 description coverage is 0%, so the description must compensate. It mentions value, stage, and lead_id indirectly, but does not explain the meaning of 'name' or cover 'owner_id' at all. The schema provides types/defaults but no descriptions, and the description adds little beyond what the schema already exposes.

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

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

States a specific verb (create), resource (deal/opportunity), and source (from a lead). It also lists the key fields it sets (value, stage, links to lead). Clearly differentiates from siblings like crm_create_lead and crm_move_deal.

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?

Implies usage by describing the action (create a deal from a lead), but does not explicitly state when to use this tool instead of alternatives like crm_move_deal or crm_create_lead. No exclusions or conditions are given.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states creation and stored fields, but does not mention duplicate handling, required permissions, idempotency, or what happens to existing leads. The mention of 'scoring data' is vague and unexplained.

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

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

A single, direct sentence that front-loads the action ('Create a new CRM lead') and lists key fields. No wasted words; appropriately concise.

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

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

For an 8-parameter tool with no annotations and no output schema, the description is severely incomplete. It does not explain the required email field, default values, the enum for source, or any behavioral nuances. An agent would lack critical information to correctly invoke the tool.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions email, name, company, source, and 'scoring data', but omits phone, tags, and job_title. 'Name' is ambiguous (could refer to first_name/last_name), and 'scoring data' does not correspond to any field in the schema, potentially misleading the agent.

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

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

States a clear verb and resource ('Create a new CRM lead') and lists key stored fields (email, name, company, source, scoring data). The purpose is unambiguous, though it does not explicitly differentiate from siblings like crm_create_deal.

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 no guidance on when to use this tool versus alternatives. No exclusions, prerequisites, or context such as 'use when you have marketing data' are given.

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

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

No annotations are provided, so the description must fully disclose behavior. It only repeats the action ('Get') without explaining side effects, safety, return format, or any constraints. This is especially problematic for a tool that likely reads data, but nothing is explicitly stated.

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 short sentence with no redundancy, which is efficient. However, it is under-specified, but conciseness focuses on economy of language, not completeness. It earns a 4 for being tight and to the point, though it could have been more informative.

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

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

Given the presence of sibling tools and the lack of annotations or output schema, the description is grossly incomplete. It does not specify what metrics are returned, how it differs from crm_get_pipeline, or what an agent should expect. This is inadequate for a tool with this level of ambiguity.

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

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

The tool has zero parameters and schema coverage is 100% (trivially, as there are no properties). Baseline for 0 params is 4. The description adds no parameter information, but none is needed since there are no parameters to explain.

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 clear verb ('Get') and resource ('CRM dashboard') but is vague about what the dashboard contains. It does not distinguish it from sibling tools like crm_get_pipeline, which could also provide pipeline metrics. The purpose is understandable but lacks specificity to uniquely identify this tool among 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?

There is no guidance on when to use this tool versus alternatives. The description does not mention any context, exclusions, or conditions. With multiple related CRM tools (crm_get_pipeline, crm_get_timeline, etc.), the lack of usage guidance leaves the agent to guess.

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

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

With no annotations provided, the description bears the full burden of behavioral disclosure. It uses the verb 'Get' which implies a read-only operation, but it does not explicitly state side-effect safety, authentication requirements, or return characteristics beyond the summary. The description is adequate but minimal, offering no extra behavioral context.

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

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

The description is a single, tightly constructed sentence that leads with the action and resource, includes the key detail ('values per stage'), and contains no fluff. It is appropriately sized for a parameterless tool 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?

For a tool with no parameters and no output schema, the description is essentially complete. It conveys what the tool returns (a summary with stage values) and is self-contained. Minor omissions like pagination or possible filters are not critical given the simplicity.

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

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

The tool has zero parameters, and schema coverage is 100% (empty schema fully documents this). Per the baseline for 0 parameters, the description does not need to elaborate on parameter semantics, and the provided sentence is sufficient.

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

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

The description clearly states a specific action ('Get') on a specific resource ('deal pipeline summary') with a specific detail ('values per stage'). It is distinct from sibling tools like crm_get_dashboard or crm_get_timeline, so it fully identifies the tool's 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 implies the tool is used to retrieve a pipeline summary, but it does not provide explicit guidance on when to use it versus alternatives like crm_get_dashboard or crm_move_deal. No exclusions or context for selection are given, so the agent must infer usage from the name and generic 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?

No annotations are provided, so the description carries the full burden. 'Get timeline' implies a read-only operation, but it does not disclose what the returned timeline contains, whether it is paginated, requires specific permissions, or covers only currently-visible activities. Minimal disclosure beyond the basic purpose.

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

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

A single efficient sentence with no filler. The core object (timeline), content (activities and stage changes), and target (lead or deal) are front-loaded in a compact phrasing.

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

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

For a single-parameter get tool it is minimally adequate, but with no output schema and no annotations, an agent lacks detail on the returned structure or ordering. Given the tool sits among many CRM tools, more context on what a 'timeline' includes would improve completeness.

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. It does clarify that entity_id refers to a lead or deal identifier, which adds meaning beyond the bare string type, but it does not detail the expected format of the ID or how leads vs deals are distinguished.

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

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

States a specific verb and resource: fetching the timeline of activities and stage changes for a lead or deal. It is clearly scoped but does not explicitly differentiate from siblings like crm_get_pipeline or crm_log_activity, which would be helpful given the large sibling 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?

No statement of when to use this tool versus alternatives such as crm_get_pipeline or audit logs. No exclusions, prerequisites, or comparison to sibling tools are provided, leaving the agent to infer when this is the right choice.

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

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

No annotations are present, so the description carries the full burden. It implies a write operation ('log') but does not disclose side effects, permission requirements, reversibility, or what happens to existing data. For a mutation tool, this is inadequate.

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 no unnecessary words. It is front-loaded with the action and object. However, its brevity borders on under-specification, but as a structural matter it is 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?

With 5 parameters, no schema coverage, no annotations, and no output schema, the description is severely incomplete. It does not explain required parameters, parameter format, usage examples, or return values. An agent would struggle to call this tool 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 0%, and the description adds almost no parameter context. It mentions call, email, meeting, note, which partially maps to activity_type, but omits task and campaign, and completely ignores entity_id, notes, subject, and duration_minutes. It fails to compensate for the schema's lack of 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?

The description uses a specific verb 'Log' with a clear resource ('activity on a lead or deal') and lists example activity types. It is distinct from sibling tools like crm_create_lead or crm_create_deal, though it does not explicitly state those distinctions. The purpose is immediately understandable.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no mention of exclusions. The description simply states what it does without contextualizing the appropriate 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?

No annotations are provided, so the description must carry full behavioral disclosure. It discloses that probability is updated and stage history is logged, which is useful. However, it does not mention reversal behavior, validation rules for stage transitions (e.g., can closed_won go back?), permission requirements, or idempotency. The disclosure is partial but not misleading.

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, compact sentence. The core action is front-loaded, and the side effects are included without extra fluff. It earns its place, though it could be slightly richer without becoming verbose. No structural issues.

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 that there is no output schema, no annotations, and two simple parameters, the description is adequate but not complete. It omits return value details (does it return the updated deal?), error scenarios (invalid stage transition, nonexistent deal), and any permissions. For a mutation tool, an agent might need to know what to expect after calling, which is missing. A more complete description would cover these.

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 explain both parameters. It does not explicitly name deal_id or new_stage, though 'new pipeline stage' maps to new_stage. The enum values in the schema already define allowed stages, so the description adds no additional constraints or context about how the parameters interact (e.g., what probability is set to). The description adds only minimal 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 verb 'move' with resource 'deal' and target 'new pipeline stage' is specific and unambiguous. It also names two side effects (updates probability, logs stage history) which further clarifies the operation. It clearly distinguishes from read-only siblings like crm_get_pipeline or crm_get_timeline.

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 makes the primary use case obvious—changing a deal's stage—and implies this is the right tool for that task. However, it does not state when not to use it, mention any prerequisites (e.g., deal must exist), or call out alternative tools like crm_update_deal. The guidance is implied rather than explicit.

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

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

No annotations are provided, so the description carries the full burden. It says 'Search' implying read-only, but does not state that explicitly, nor does it mention pagination, ordering, return format, or how results are limited. For a search tool, this is a significant gap.

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

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

The description is a single concise sentence with no extraneous information. It is front-loaded with the verb and resource. However, it's so brief that it omits useful details, but that's a completeness issue, not a conciseness issue.

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 search tool with only two parameters and no output schema, the description should at least mention what is returned and how limit behaves. It also doesn't mention any result ordering or relevance. Given the simplicity, this is a moderate gap, making it minimally viable.

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

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

Schema coverage is 0%, so the description must compensate. It clarifies that the 'query' parameter searches by name, email, or company, which adds meaning beyond the schema. However, it does not explain the 'limit' parameter or its default/maximum, leaving it undocumented in both schema and description.

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

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

Description states a clear verb 'Search' with resource 'CRM leads' and specifies searchable fields (name, email, company). This differentiates it from create operations like crm_create_lead and from hub_search_prospects, though it doesn't explicitly name any sibling as alternative. The purpose is unambiguous.

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

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

No guidance on when to use this tool versus alternatives like hub_search_prospects or search_fb_ads. It doesn't mention any prerequisite or scenario where this is preferred. The agent is left to infer from the name alone.

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

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

With no annotations, the description carries the full burden. It discloses the operational flow (hashtag monitoring, aesthetic filtering, sorted return) and implies a read-only selection action, but it does not mention authentication, platform access, rate limits, or whether any UGC states change.

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

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

Two compact sentences, with the verb+resource in the first clause and no filler. Every phrase adds information about scope, process, or output ordering.

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 states what is returned (a sorted list) and the core selection logic, which is adequate for a 4-parameter tool. However, with no output schema, return fields are unknown, and platform/limit semantics are unaddressed, leaving non-trivial gaps for an agent deciding whether defaults are 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 0%, so the description must compensate for the schema's bare parameter names. It clarifies hashtag and alludes to min_aesthetic_score via 'filters by aesthetic score', but it never explains platform or limit, even though both have defaults that materially change results.

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

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

The description names a specific verb ('curate'), a resource ('user-generated content'), and a scope ('for a given hashtag'). It then spells out the pipeline — discover, filter, sort — which clearly distinguishes it from siblings like request_ugc_permission and track_ugc.

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

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

The intended context is clear: use this when you want to identify/rank UGC for a hashtag via aesthetic and relevance scoring. It does not explicitly name alternatives or exclusion cases, but the process description makes the primary use unambiguous.

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

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

No annotations are provided, so the description must fully disclose side effects. It mentions exporting a markdown file and optional rule capture, but it does not state whether it modifies the audit trail, requires authentication, has rate limits, or any other behavioral implications. The lack of annotation coverage leaves significant transparency gaps.

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

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

The description is a single sentence that efficiently conveys the main action and key optional behaviors. It is front-loaded with the primary purpose and adds detail without excessive verbosity, though a slightly clearer separation of the alternatives could improve structure.

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 5 parameters, 0 required, and no output schema, the description is incomplete. It does not explain the meaning of brand, category, or min_occurrences, nor does it describe the expected output beyond the markdown export. An agent would struggle to know what values to provide or what to expect in response.

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

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

Schema description coverage is only 20% (only capture_rule has a description). The description clarifies capture_rule and export_brain indirectly, but does not explain brand, category, or min_occurrences. Given low schema coverage, the description fails to compensate for the undocumented parameters, leaving agents without sufficient guidance on these inputs.

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 primary action ('Promote recurring audit-trail patterns into brand learnings') and mentions optional rule capture and markdown export. It distinguishes itself from sibling audit tools by focusing on distillation rather than raw log access or detail.

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 when recurring audit-trail patterns exist, but it does not explicitly state when to use this tool versus alternatives like audit_log or audit_get_log. There is no 'instead of' guidance or exclusion of other tools, leaving the decision somewhat inferred.

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

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

No annotations exist, so the description carries the full burden of behavioral disclosure. It does reveal one notable trait — automatic model-tier selection (hinting the tool may override the models parameter) — and states the output shape (consensus + confidence). But it omits failure behavior when consensus cannot be reached, cost/latency implications of calling multiple models, and any caveats.

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, each contributing a distinct fact (the action, the auto-selection behavior, the return shape). No filler or redundant restatement of the tool name. Content-to-length ratio is good even if the structure risks skimming over needed parameter details.

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

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

This is a 4-parameter tool with a required enum, a free-form nested context object, no output schema, and an auto-selection behavior that interacts ambiguously with the models parameter. The description does not explain the task_type enum values, the purpose of context, or how models relates to the auto tier selection. For this complexity, the description is too thin.

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 all four parameters (models, prompt, context, task_type) are undocumented in the schema and the description must compensate. It explains none of them — nothing about what models accepts, what context supplies, or what values task_type expects. The description adds zero meaning over bare parameter names.

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

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

The description states a specific verb-resource pair ('Run ensemble voting across multiple AI models') and lists two concrete behaviors: selecting an optimal model tier and returning a consensus decision with a confidence score. No sibling tool offers ensemble voting, so it is readily distinguishable by subject matter, though it never explicitly contrasts any sibling.

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

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

There is no when-to-use guidance, no named alternatives, and no exclusions. The phrase 'Selects optimal model tier based on task complexity' implies automatic behavior but never tells an agent when to choose this tool over siblings like ask_marketic or the generate_* 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?

With no annotations, the description carries the full burden. It states the tool generates a brief (implying a read/create operation) and mentions that the executing agent can run fully from the output, which implies the output is complete. However, it does not disclose whether the tool writes to storage, requires authentication, has side effects, or what happens if required inputs are missing. It adds some context but leaves critical behavioral aspects undisclosed.

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

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

Two sentences, no filler. The purpose and key benefit (self-contained, no callback) are front-loaded. Every phrase earns its place, and the structure is clear and 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 (13 parameters, nested objects, no output schema), the description is incomplete. It lists the brief's contents but never describes the output format (text, JSON?), how required inputs are used, or any constraints. No edge cases or error conditions are mentioned. The description relies on the schema for required fields but those are not obvious to an agent without reading it; also the description offers no guidance on when to use this over adjacent tools like build_campaign.

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

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

Schema description coverage is only 15% (2 of 13 parameters have descriptions), so the tool description must compensate. The description mentions content like 'budget split' and 'posting windows' which maps loosely to parameters like total_budget and duration_weeks, but it does not explain how any of the parameters should be set, their formats, or their interdependencies. It offers high-level hints but insufficient detail for an agent to correctly fill all 13 parameters, especially since several lack 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 states a clear verb ('Generate'), resource ('campaign brief'), and content list ('positioning, budget split, posting windows, resolved BrandTokens, and execution contract'). It distinguishes itself from execution tools by calling it a 'handoff artifact' and noting that the executing agent can run 'without calling back.' However, it does not explicitly name alternative sibling tools, relying on implicit contrast.

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

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

The phrase 'for any brand execution agent' gives some context that this is used to hand off to another agent, and the statement 'The agent can execute without calling back' implies you use it when you need a self-contained task spec. But it provides no explicit 'when not to use', no comparison to alternatives like build_campaign, and no mention of prerequisites. Usage guidance is inferred rather than explicit.

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

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

With no annotations, the description must carry the burden. It discloses what the tool produces (variants with specific components) and implies it's a generation operation without side effects. However, it doesn't mention any behavioral aspects like required inputs, potential costs, rate limits, or whether it invokes external services. The description gives some insight into output but not into the operational behavior, so it's average.

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 main action and lists key output elements. It is concise with no filler. However, it could be slightly more structured by separating the output list, but it's efficient 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?

Given the tool has 8 parameters, no output schema, and no annotations, the description provides only partial context. It explains what the output contains (headline, description, etc.) but fails to explain input parameters like tone, channel, objective, and num_variants. The agent would not know how to control the variant count or tailor the copy. The description is incomplete for effective 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?

The description does not mention any of the 8 parameters by name or explain their meaning. The schema has enums and defaults, but the description adds no value beyond that. Since schema description coverage is 0%, the description should compensate, but it only talks about output, not inputs. This leaves parameters like 'tone', 'channel', 'objective', and 'num_variants' unexplained in the description, which is a significant gap.

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

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

The description states a clear verb ('generate') and resource ('ad copy variants'), specifies the channels (Google, Meta, LinkedIn, etc.), and lists what each variant includes (headline, description, CTA, hooks, confidence score, performance prediction). This distinguishes it from sibling tools like generate_social_posts or generate_seo_content, though it doesn't explicitly name alternatives. It's specific enough to convey the core 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 provides no guidance on when to use this tool versus alternatives like generate_social_posts, generate_brief, or build_campaign. It doesn't mention any criteria for choosing this tool (e.g., 'use for paid ads across multiple channels'), nor does it state exclusions. The agent is left to infer the use case from the purpose alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It simply says 'generate' without explaining side effects, required context, output format, or any interaction details. It offers no more than the tool name implies.

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 one efficient sentence and front-loads the primary action. However, it is overly terse for a tool with four parameters and no other documentation, so it does not fully earn its brevity by omitting essential detail.

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 annotations, output schema, and any parameter explanation, this description is grossly incomplete. An agent cannot determine required inputs, expected outputs, or behavioral consequences. It is inadequate for a generation tool of this 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 description coverage is 0%, so the description must compensate for underspecified parameters, but it does not. It makes no reference to narrative_type, brand, product, or industry, leaving agents without any interpretation of what these inputs mean or how they affect output.

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 verb 'Generate' and the resource 'brand narrative, stories, and messaging frameworks for marketing,' giving a specific purpose. However, it does not differentiate from sibling tools like generate_creatives or generate_social_posts, so it only partially distinguishes itself.

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 no guidance on when to use this tool versus alternatives, no context about appropriate scenarios, and no exclusions. It is a bare statement with zero usage direction.

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

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

With no annotations provided, the description is the sole source of behavioral info. It only states that content is generated, but discloses no side effects, prerequisites, return format, or operational constraints. This is a minimal disclosure for a generation tool.

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

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

The description is a single, front-loaded sentence with no waste. It packs the core action and key deliverables efficiently, though it omits necessary detail elsewhere.

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 4 parameters, no output schema, and no annotations, the description is severely under-specified. It does not clarify the output format, how parameters affect results, or any limitations. An agent would have to guess about response shape and behavior.

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

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

The schema has 0% description coverage, yet the description does not elaborate on any parameter except a vague mention of 'target keywords', which maps to the required parameter. word_count, content_type, and competitor_url are entirely unexplained, forcing the agent to rely on raw schema types and defaults.

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 verb 'generate' and the resource 'SEO-optimized content', listing specific outputs (meta titles, descriptions, headers, FAQs). It implies distinction from siblings like generate_social_posts or generate_creatives, but does not explicitly differentiate.

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

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

No guidance is provided about when to use this tool versus other content-generation or analysis tools among the many siblings. There is no explicit context, alternatives, or exclusions, leaving the agent to infer from the name.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states what it generates and the supported formats; it does not disclose whether it returns output, executes side effects, requires any auth/preconditions, or how the generation behaves. For a content-generation tool this is a thin profile.

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 no filler, and the core purpose is front-loaded. Efficient, though it could spare a few words to instead capture more behavioral detail 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?

With 6 parameters, 0% schema coverage, no annotations, and no output schema, the description is under-equipped. It does not explain the expected return value, how format interacts with platform, or what 'multi-format content' concretely produces. An agent needs more to call this correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It does partially: 'platform-specific' maps to the platform enum and 'threads/single posts/multi-format' maps to the format enum. However, it adds nothing about tone, length, or hashtags, which are left to the schema alone — partial compensation only.

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

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

States a specific verb ('Generate') and resource ('platform-specific social media posts') and lists the four supported platforms. Mentions threads, single posts, and multi-format content. However, it does not explicitly differentiate from siblings like generate_creatives or generate_seo_content, which could overlap in 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?

No guidance on when to use this tool versus alternatives. The description never names sibling tools (schedule_content, generate_creatives, generate_seo_content) or states exclusions. The use case is only implied by the phrase 'social media posts,' leaving the agent to infer when this tool is the right choice.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the tool 'calculates' attribution, without indicating whether it is read-only, what it returns, any side effects, or performance implications. The nature of the operation and its output are left unspecified, which is insufficient for an agent to understand its behavior safely.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without redundancy. It is front-loaded with the primary action and resource, making it easily scannable. Every word serves a purpose, and there is no unnecessary detail.

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

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

The tool lacks an output schema, and the description does not explain what the result looks like—whether it returns a detailed breakdown, a single metric, or a comparison of models. It also does not address error handling, data format expectations, or prerequisites. Given the moderate complexity and absent annotations, the description is clearly incomplete for guiding an agent through 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?

The description mentions 'various models,' which adds some context to the model parameter, but it does not explain how to select among the five enum options. The channel_points parameter already has a schema description, and the description adds no further meaning there. With 50% schema coverage, the description partially compensates for the undocumented model parameter but remains limited in adding value 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 calculates multi-touch attribution across marketing channels using various models. It specifies a precise verb and resource, and its unique focus on attribution distinguishes it from sibling tools, none of which mention attribution in their names. An agent can confidently identify its purpose without confusion.

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 does not provide explicit guidance on when to use this tool instead of alternatives; it only states its function. The usage is implied by the purpose (attribution analysis), but there is no mention of exclusions, conditions, or reference to other tools. This meets the baseline for implied usage but does not offer clear direction on model selection or contextual recommendations.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the report contains a Brier score with 'lower=better' and a breakdown of resolved vs pending predictions, which adds value beyond the name. However, it does not explicitly state that the operation is read-only, nor does it disclose any potential side effects or limitations (e.g., whether results are cached or require specific permissions). This is a moderate gap.

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

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

The description is two sentences long, with no fluff. The first sentence front-loads the purpose and specifics, and the second adds a useful interpretation of the report's significance. Every sentence earns its place, making it highly 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?

The tool has 3 parameters with no schema descriptions, no output schema, and no annotations. The description does summarize the output contents, which is helpful, but it fails to explain the role of any parameter. Without knowing how date ranges or source filtering work, an agent cannot correctly invoke the tool. This is a significant completeness gap.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It only hints at 'source' via 'per-source accuracy,' but it does not directly explain what source, start_date, or end_date mean or how they affect the report. No format, defaults, or relationships are described. An agent would be left guessing how to populate these fields correctly.

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

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

The description opens with a clear verb+resource ('Get the signal calibration report') and then elaborates the exact contents: predictions count, Brier score, resolved vs pending breakdown, and per-source accuracy. It also states the purpose ('Shows whether Marketic's signal sources are reliable'), which distinguishes it from siblings like track_signal or collect_signals that focus on data ingestion rather than reporting. This is specific and 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 implies a use case: assessing signal source reliability, which is clear from 'Shows whether Marketic's signal sources are reliable.' However, it does not explicitly mention alternatives or when not to use this tool. Given the large sibling list, naming an alternative would strengthen this, but the context is sufficiently clear to guide an 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states a get operation with no mention of side effects, read-only nature, pagination, filtering behavior, or whether only published drafts are included. The description is too terse to provide meaningful behavioral transparency beyond the obvious 'get' implication.

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

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

A single sentence with zero filler, presenting the core action upfront. The wording is efficient and immediately clear. It earns its place by conveying the essential purpose without redundant details.

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

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

Given 3 optional parameters, no output schema, and no annotations, the description is insufficient. It doesn't explain return format, the meaning of limit and platform, or edge cases like empty results. The description is adequate for a simple lookup but leaves critical gaps 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 0%, so the description must compensate. It explains the 'days' parameter via 'upcoming N days', but does not clarify the 'limit' parameter (pagination?) or 'platform' (filter by platform? expected values?). The description adds only partial value for a subset of parameters, leaving the agent guessing about the others.

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

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

The description clearly states the action (get), the resource (scheduled posts from the content calendar), and the scope (upcoming N days). It's specific enough to differentiate from most siblings, though it doesn't explicitly reference alternatives. The name and description together unambiguously convey the tool's 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?

No guidance is given on when to use this tool versus alternatives. It doesn't mention any conditions, exclusions, or related tools like schedule_content. The description is purely declarative without usage context, leaving the agent to infer when it's appropriate.

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 are absent, so the description carries the full burden of behavioral disclosure. It only says 'track', which implies recording but does not indicate whether it is asynchronous, what side effects occur on each platform, whether failures are tolerated, or what happens to the data after tracking. No return value or response format is mentioned.

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

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

A single sentence with no redundant words, well-formed and grammatically correct. It is concise but not misleadingly so; however, the brevity sacrifices necessary detail. It is not front-loaded with key information beyond the core action and scope.

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 annotations, no output schema, and four parameters with zero schema descriptions, the description is severely inadequate. It does not explain parameter formats, return values, edge cases, or prerequisites. An agent has almost no guidance for constructing a correct call.

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%, meaning the schema provides no explanations for the four parameters (event_name, contact_id, revenue, properties). The description does not compensate—it mentions 'an event' but does not map that to event_name, nor does it explain contact_id, revenue, or properties. This is a critical gap.

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

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

States a specific action 'track an event' with a clear scope: 'across ALL connected marketing platforms simultaneously.' This distinguishes it from siblings like track_ugc (UGC-specific), track_signal (signal-specific), and hub_send_campaign (sending campaigns). The meaning is clear, though it could be more explicit about the type of event (e.g., conversion, page view).

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

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

No guidance on when to use this tool versus alternative tracking tools such as track_signal, collect_signals, or track_ugc. It does not mention prerequisites, scenarios, or exclusions. An agent has no reason to prefer this over other tracking tools beyond the vague 'ALL connected marketing platforms' scope.

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

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

With no annotations provided, the description carries the full burden. It conveys the mutation ('Create') and the cross-platform scope ('across ALL connected marketing platforms'), but it does not disclose side effects, reversibility, permission requirements, or what happens to existing segments. The cross-platform behavior is the only behavioral hint.

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

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

The description is a single concise sentence with no fluff, but it is under-specified. It front-loads the action but omits necessary context, so it is not appropriately sized for the tool's 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?

Given three parameters, no output schema, and no annotations, the description is minimal and incomplete. It does not explain the purpose of each parameter, expected behavior, or any constraints, leaving much to inference.

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

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

Schema coverage is 0%, and the description provides no detail about the parameters (name, conditions, description). It only reiterates the purpose without explaining what conditions or description mean, leaving the agent without guidance on how to construct a valid segment.

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 (Create), the resource (audience segment), and the scope (across ALL connected marketing platforms). This distinguishes it from CRM create tools and general broadcast tools, though it doesn't explicitly name a sibling or contrast with one.

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

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

No guidance is provided on when to use this tool versus alternatives, such as when to choose hub_create_segment over hub_sync_contact or building a segment through another tool. There is no explicit context, prerequisites, or exclusion 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?

No annotations are provided, so the description carries the full burden. 'Get' and 'Aggregates metrics' clearly signal a read-only operation, which is helpful. It does not discuss potential aggregation latency, data freshness (real-time vs cached), or timeout risk when querying many platforms at once — useful context for a unified aggregator, though its simplicity keeps this from being a major gap.

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

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

Two sentences with zero waste. The core action and scope are front-loaded in the first sentence, and the second sentence adds the platform detail that reinforces the 'unified' claim. Every word earns its place.

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

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

For a zero-parameter, no-output-schema tool this is nearly complete: it states the purpose, scope, and the platforms involved. The only minor omission is the shape of the returned dashboard, but with no output schema and no parameters, what is present is sufficient for an agent to call it correctly.

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

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

The tool takes zero parameters, so the description holds no parameter-documentation burden and baseline is 4. The description adds value by telling the agent what data the dashboard contains (cross-platform aggregate metrics and the specific platform list), which is exactly the context an agent needs to decide whether this tool fits.

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 ('Get'), a resource ('unified analytics dashboard') and precise scope ('across ALL connected marketing platforms'), then enumerates the integration targets (WebEngage, CleverTap, Mixpanel, HubSpot, Braze). This clearly differentiates it from the sibling crm_get_dashboard without needing to open either schema.

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

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

The description makes the usage context explicit by emphasizing 'ALL connected marketing platforms' — an agent can infer this is the cross-platform rollup, in contrast to tool-specific dashboards like crm_get_dashboard. However, it stops short of explicitly stating when not to use it or naming alternatives, leaving some routing to inference.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that it returns connection status and capabilities, but does not disclose whether the operation is read-only, whether it makes external API calls, or any side effects, rate limits, or auth requirements. This is a significant gap for a tool that presumably accesses external marketing platforms.

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, highly concise, and front-loaded with the primary action. Every word adds value, with no bloat or tautology. It efficiently states the scope ('ALL connected') and the return type ('connection status and capabilities').

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 tool with no output schema, the description is reasonably complete: it states the resource, scope, and what is returned. However, it lacks specifics on the format of the return value (e.g., how status is represented) and does not mention any potential failure modes or latency. Given the simplicity, this is acceptable, but a tad more detail on the return structure would improve it.

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

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

The tool has 0 parameters, so schema_description_coverage is trivially high (100%). Per the rubric, 0-parameter tools receive a baseline of 4. The description does not need to explain parameters, and it doesn't—there is no ambiguity.

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

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

The description clearly states the tool's function: check health status of ALL connected marketing platforms. The verb 'check' and the resource 'marketing platforms' are specific, and it distinguishes itself from sibling tools like hub_list_platforms (which lists platforms) and hub_get_dashboard (which gets a dashboard) by focusing on health status and capabilities.

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 no guidance on when to use this tool versus alternatives. It does not mention any conditions, exclusions, or related tools. While the purpose is implied (health monitoring), there is no explicit routing or comparison to sibling tools, leaving the agent to infer usage 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?

No annotations are provided, so the description carries the full burden of behavioral transparency. It discloses what is returned (platform features, supported channels, connection status) but does not explicitly state that this is a read-only operation with no side effects. An agent might incorrectly assume it could modify state. Without a readOnlyHint annotation, this is a notable gap.

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

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

The description is two sentences with no fluff. The primary verb and resource are front-loaded, followed by a concise list of what is returned. Every word earns its place.

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

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

For a zero-parameter, no-output-schema tool, the description explains what the tool returns (features, channels, connection status), which is sufficient for an agent to call it correctly. It doesn't mention pagination or potential large result sets, but for a list of supported platforms that's likely unnecessary. Minor gaps exist but the core 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?

There are zero parameters, so the description does not need to explain parameter meaning. The baseline for no parameters is 4, and the description doesn't introduce any parameter-related confusion. It correctly focuses on the output.

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 verb 'List' and the resource 'supported marketing platforms', which distinguishes it from the many hub_* action tools. However, it doesn't explicitly name any alternative tool, so it doesn't fully leverage sibling differentiation. Still, the purpose is unambiguous.

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

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

The description implies usage: whenever an agent needs an overview of available platforms. But it provides no explicit when-to-use, when-not-to-use, or guidance on alternatives. Given the simple nature of a listing tool, this is acceptable but not explicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool returns enriched data, which implies a read-only operation, but it does not explicitly confirm non-mutating behavior or mention limitations such as rate limits, cost, or error conditions. It adds some value by detailing the type of returned data, which is a positive signal.

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 exactly two sentences with no redundancy, front-loading the purpose and then listing return fields. Every clause adds value, and it is well-structured for quick scanning.

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

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

For a search tool with no output schema and no annotations, the description is notably incomplete. It lacks essential context like query syntax, pagination behavior, meaning of the limit parameter, and error scenarios. The agent has only the general purpose and return field list, which is insufficient for correct invocation.

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

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

Schema coverage is 0% — the description never mentions the 'query' or 'limit' parameters. The agent receives no guidance on how to formulate a query (e.g., natural language vs. keywords), what format is expected, or how the limit parameter behaves. Since the schema itself offers no descriptions, the description fails to compensate for a critical gap, leaving the agent to guess.

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 ('Search for prospects') and specifies the resource type with a distinctive enrichment method ('using Clay data enrichment'), listing concrete return fields (title, company size, tech stack, funding, social profiles). This differentiates it from sibling tools like crm_search_leads which likely operate on CRM data, though it doesn't explicitly contrast them.

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

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

The description gives no explicit guidance on when to prefer this tool over alternatives. It implies its purpose (prospect searching) but doesn't mention exclusion criteria or conditions for using other search tools like crm_search_leads or collect_signals. An agent must infer context from the tool name and sibling list, which is insufficient.

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

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

With no annotations, the description must fully disclose behavior. It only says 'send' and 'routes' without explaining how routing decisions are made, what 'best' means, whether it can fail, or if there are side effects like audience targeting or cost implications. It also doesn't mention prerequisites such as authenticated platform connections. The lack of detail on routing logic is a significant gap for an agent deciding to call this tool.

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

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

The description is concise (two sentences) and avoids fluff. However, it could add a bit more detail without becoming verbose, such as mentioning that preferred_platform can override automatic routing or that segment_name defines the audience. It's under-specified rather than efficiently informative.

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

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

Given there is no output schema, no annotations, and 0% schema coverage, the description is far from complete. It does not explain which parameters are required (campaign_name is required but no mention), how the routing decision works, what happens if the preferred platform is invalid, or what the response looks like. An agent has almost no context to call this 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?

The description provides zero information about the six parameters. Since schema description coverage is 0%, agents must infer meaning solely from param names (campaign_name, channel, subject, content_html, segment_name, preferred_platform). The description doesn't clarify the role of preferred_platform (which directly relates to 'best available platform') or how channel restricts routing. This is a major omission.

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 ('Send a marketing campaign') and the subject (marketing campaigns). It lists potential platforms (Mailchimp, HubSpot, WebEngage, Braze, CleverTap) which distinguishes it from transactional sends like hub_send_transactional. However, 'best available platform' is ambiguous and not fully defined, and it doesn't contrast with other campaign-related siblings like schedule_content or launch_campaign_ad.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention conditions for using hub_send_transactional (for transactional messages) or schedule_content (for scheduled posts). There is no explicit 'when not to use' or preferred scenarios. The only hint is that it's for marketing campaigns, but that's implied, not stated as a selection criterion.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'send a transactional message' but does not explain side effects, error conditions, authentication requirements, or what 'best platform' entails. It does not disclose whether this is a read-only or mutating action, nor any rate limits or performance characteristics.

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 sentence, which is concise, but it lacks structure and front-loading of critical information. It fails to prioritize key details like the single-contact constraint or the channel parameter. The vagueness of 'best platform' makes the sentence low in information density, so the conciseness is not beneficial.

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, no output schema, and no annotations, the description must provide substantial context. It covers almost nothing: no mention of required fields, channel options, deep linking, or the meaning of 'best platform'. An agent would be unable to confidently invoke this tool correctly based on the description alone.

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 undocumented parameters. It provides zero information about contact_id, body, title, channel, or deep_link. The agent cannot infer the meaning of these parameters from the description alone, making parameter usage entirely dependent on the schema (which itself lacks semantic details for non-enum params).

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

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

The description states a specific action ('Send a transactional message') and scope ('single contact'), which distinguishes it from sibling tools like hub_send_campaign or hub_broadcast_event. However, the phrase 'via the best platform for the channel' is vague and fails to clarify what 'best platform' means or how it is determined, leaving ambiguity about the tool's exact behavior.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or conditions that would steer an agent to a sibling tool like hub_send_campaign or hub_broadcast_event. The only implicit differentiator is 'single contact', but that is not explicit.

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

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

With no annotations, the description is the sole source of behavioral info. It discloses that it creates/updates profiles but omits key traits: idempotency, handling of existing contacts, failure behavior (e.g., partial platform failures), rate limits, or required permissions. This is a significant gap for a mutation tool.

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

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

A single sentence is efficient and front-loaded with the primary action and scope. However, it sacrifices needed detail; it's under-specified rather than genuinely concise in a helpful way. Still, the structure is tight and readable.

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 tool with 9 parameters, nested objects, an enum, and no output schema, the description is far too thin. It leaves out how inputs map to platforms, what success looks like, and edge cases. An agent would likely guess incorrectly about parameter 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 description coverage is 0% — the description mentions zero parameters. It doesn't explain the purpose of contact_id, email, tags, attributes, or how they map to platform fields. With 9 params and no other documentation, the description fails to compensate.

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 clear verb ('Sync') and resource ('a contact') and explicitly lists target platforms, distinguishing it from siblings like hub_send_campaign or crm_create_lead. It tells the agent exactly what the tool does and its broad scope.

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

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

The description implies when to use (syncing contact data across platforms) but provides no explicit guidance on when NOT to use it or how it compares to related tools like crm_create_lead or hub_send_transactional. There are no alternatives mentioned or conditions for 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?

No annotations are provided, so the description carries the burden. It does disclose the approval requirement ('REQUIRES APPROVAL') and implies a write/mutation operation ('Launch'). However, it doesn't elaborate on authorization specifics, consequences (e.g., financial commitment), reversibility, or what happens upon approval for a high-stakes action. The single warning adds value but is insufficient for a mutation with no annotation coverage.

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 concise single sentence that front-loads the critical warning and states the core action. No wasted words. However, it may be too terse given the tool's complexity, but terseness alone doesn't harm conciseness if it communicates essentials—which it partially does.

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 is minimal for a tool with 5 parameters (2 required), a mutation, an approval requirement, and no output schema. It doesn't explain return values, parameter formats beyond what's in the schema, platform-specific behaviors, or how it differs from the many sibling campaign-related tools. An agent would have to guess or inspect the schema, which is incomplete. The warning is useful but leaves many operational gaps.

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

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

Schema description coverage is only 40% (targeting and ad_creative have descriptions, but platform, budget_daily, and campaign_name do not). The tool description adds no parameter-specific information, leaving those undocumented parameters without any guidance. It fails to compensate for the low schema coverage, e.g., it doesn't explain that 'targeting' and 'ad_creative' are JSON strings with expected structure, nor what 'budget_daily' defaults to.

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

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

States a specific action ('Launch a campaign ad') and resource (the ad), and mentions integration platforms (Meta, LinkedIn, Google Ads). However, it doesn't distinguish from sibling tools like 'build_campaign' or 'hub_send_campaign', and the enum includes platforms not mentioned in the description (HubSpot, Salesforce), creating slight ambiguity.

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

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

No guidance on when to use this tool versus alternatives. The warning 'REQUIRES APPROVAL' implies a prerequisite but does not explain when this tool is appropriate or why one might choose it over sibling tools like 'build_campaign' or 'optimize_budget'. No exclusions or alternative routing provided.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. It only states the optimization intent without mentioning any side effects, whether it modifies data, what it returns, or any prerequisites. For a tool that likely computes a new allocation, this is a significant gap.

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

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

The description is a single concise sentence with no redundant wording. It gets straight to the point, making it easy to parse. However, it is perhaps too concise, sacrificing essential details for brevity. Still, as far as structure goes, it is clean and 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?

With four parameters, two nested objects, no output schema, and no annotations, the description is insufficient. It does not explain the expected output (e.g., a new budget allocation), the role of the strategy parameter, or any constraints. An agent cannot fully understand how to invoke this tool 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 50%: current_allocation and channel_performance have descriptions, but total_budget and strategy do not. The description does not explain these parameters or their relationships. It only references ROAS, which partially relates to channel_performance, but it fails to compensate for the missing schema details, leaving total_budget and strategy semantically unclear.

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 verb (optimize), the resource (budget allocation across marketing channels), and the basis (historical ROAS data). This is specific and distinguishes it from siblings like optimize_hashtags, which focus on a different resource. No ambiguity remains about the tool's core 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 provides no guidance on when to use this tool versus alternatives. It does not mention any conditions, exclusions, or related tools. The only implied usage is the general context of budget optimization, but there is no explicit direction for the agent to select it over other 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?

With no annotations provided, the description is the sole source of behavioral disclosure. It reveals that the tool returns a mix of trending and content-specific hashtags and respects platform limits, which gives some sense of behavior. However, it does not disclose auth requirements, rate limits, side effects, or the nature of the output beyond a vague 'mix'. It also does not explain what happens if content_text is empty or how 'respecting platform limits' manifests. This is a moderate disclosure, better than none but not comprehensive.

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 short sentences, with the primary purpose front-loaded in the first sentence. The second sentence adds concise, relevant detail about the return mix and platform handling. There is no waste or redundant information. It is appropriately sized for a relatively simple tool.

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 three parameters (one required), no output schema, and no annotations, the description leaves significant gaps. It does not explain the available platforms, the effect of the limit parameter, or the exact return format. It also fails to mention any constraints or error scenarios. An agent cannot fully understand how to invoke it correctly, especially the platform and limit parameters, without additional 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 0%, so the description must fully clarify each parameter. It does not. The description mentions 'respecting platform limits' but never explains that 'platform' is a parameter that determines those limits, nor does it explain the 'limit' parameter meaning. 'content_text' is implied as the post content but not explicitly defined. There is no mention of platform valid values or default behavior. The description adds almost no value beyond the raw schema, making it very weak on parameter semantics.

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

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

The description clearly states a specific verb ('Get') and resource ('optimized hashtags') with an explicit mention of the return mix (trending and content-specific) and platform limits. It is unambiguous about the tool's core function. However, it does not explicitly differentiate from sibling tools like generate_social_posts, which could also generate hashtags, so it falls short of a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives such as generate_social_posts or generate_creatives. It does not state any context, prerequisites, or exclusions. An agent must infer when hashtag optimization is appropriate, with no explicit routing or contrast 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?

With no annotations, the description carries the full burden of behavioral disclosure. It only states that it extracts UTM parameters but does not disclose what happens when no UTM parameters are present, the output format, error handling, or whether the operation is read-only. This is a significant gap for an unannotated tool.

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

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

The description is a single sentence, which is concise and front-loaded with the core purpose. While it is efficient, it is so terse that it under-specifies the tool, though that is more an issue of completeness than conciseness. It earns credit for avoiding verbosity.

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

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

For a simple tool with one parameter and no output schema, the description is incomplete. It does not explain what the tool returns, how to interpret the output, or any edge cases (e.g., URLs without UTM parameters). An agent would need additional documentation to call this 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?

The schema has 0% description coverage, so the description must compensate by explaining the 'url' parameter. It does not provide any additional meaning beyond the parameter name, such as expected URL format, encoding, or required structure. The agent has no guidance on how to supply a valid 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?

The description clearly states the tool extracts UTM parameters from a URL, using a specific verb ('extract') and resource ('UTM parameters from a URL'). It inherently distinguishes itself from sibling tools like build_utm_url, which is about constructing URLs, not parsing them.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, use cases, or exclusions. The description is a single sentence without any usage context, leaving the agent to infer the tool's applicability from the name alone.

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

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

With no annotations, the description carries the full burden. It discloses that the tool returns HTML/layers or a placeholders list if required content is missing, which is useful. However, it does not mention whether the operation is read-only, if it has side effects, or any auth/rate-limit requirements. The output conditionality adds some transparency but not enough for a mutation-like tool (rendering implies creating something).

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

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

The description is two sentences, front-loads the primary function, and avoids unnecessary words. It conveys the core behavior, inputs, and conditional output efficiently 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 tool has 3 parameters, a nested object, and no output schema, the description is incomplete. It does not explain what 'Paper' is, the format of the returned HTML/layers, the structure of placeholders, error conditions, or how content_overrides interact with required brand fields. An agent would need more detail to call this tool correctly in ambiguous situations.

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. It lists the brand tokens (name, primary, background, accent, secondary, font, handle, tagline) and mentions template_name and content_overrides implicitly. This adds meaning beyond the bare schema, but it does not explain the expected format (e.g., hex codes for colors, structure of content_overrides) or the purpose of each token.

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 renders a brand design template into Paper MCP script or JSON layer spec, with a specific verb and resource. It mentions the inputs (template name, brand tokens, content overrides) and outputs (HTML/layers or placeholders). It doesn't explicitly differentiate from siblings like generate_creatives, but the purpose is distinct enough.

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 does not provide any guidance on when to use this tool versus alternatives, nor does it state any exclusions or prerequisites. It simply says what it does. With many sibling tools that might also generate design content, this is a significant gap.

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

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

With no annotations, the description is the sole source of behavioral info. It discloses that a DM is sent via platform API and that templates are in English or Indonesian, but it does not explain side effects (e.g., whether it creates a record, triggers notifications), idempotency, rate limits, or what happens on failure. For a tool that performs a write action, this is a significant gap.

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

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

Two sentences with minimal waste. The core action is front-loaded, and the language/template detail is useful. However, it could be slightly more structured by separating the purpose from the mechanism, but overall it is appropriately concise.

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 3-parameter tool with no output schema and no annotations, the description is too thin. It lacks context on platform limitations, how permissions are verified, and what happens after permission is granted. An agent cannot reliably call this tool without external knowledge about the parameters and the API flow.

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

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

Schema description coverage is 0%, and the description does not explain any of the three parameters (content_url, platform, message). It doesn't even mention them, so an agent has no idea what values to pass or what the message default implies. The description fails to compensate for the schema's lack of 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?

The description names a specific action ('Request permission from a UGC creator to repost their content') and distinguishes it from siblings like curate_ugc and track_ugc through the explicit 'repost permission' framing. However, it does not explicitly call out which sibling it is not, so it lacks the explicit differentiation seen in top-tier examples. The verb and resource 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?

The description states what the tool does but gives no guidance on when to choose it over alternatives. It does not mention prerequisites, context like 'when you need to repost UGC', or any explicit exclusions. An agent would have to infer usage from the name and description alone.

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

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

No annotations are provided, so the description must disclose behavioral traits itself. It only states the purpose (resolving a signal) but does not explain side effects (e.g., whether the signal is updated, deleted, or becomes immutable), any required permissions, or the nature of the operation (mutating). This is a significant gap for a tool that appears to modify state.

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, two sentences with no filler. The core action and purpose are front-loaded, and the outcome values are included. It is efficient but could be slightly more informative without becoming verbose.

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, no annotations, and three parameters with 0% schema coverage, the description is far from complete. It omits behavioral details, parameter explanations (except partial outcome), and any guidance on expected return values or side effects. An agent would struggle to understand the full implications of invoking 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 description coverage is 0%, so the description must explain each parameter. It defines 'actual_outcome' with values, but 'signal_id' is self-evident and 'notes' is entirely unexplained. Without any detail on what 'notes' is for or how it affects the resolution, parameter semantics are insufficiently communicated.

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

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

The description clearly states a specific verb ('Resolve') and a specific resource ('previously tracked signal'), and specifies the outcome values (YES/NO/PARTIAL). It distinguishes itself from siblings like 'track_signal' (which creates signals) and 'collect_signals' (which gathers data), making its role 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 implies usage context ('previously tracked signal', 'close the calibration loop') but does not explicitly mention when to use this tool versus alternatives like 'track_signal' or 'get_calibration_report'. It provides clear context but no exclusions or alternative guidance.

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

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

No annotations are provided, so the description carries the full burden. It discloses the core behavioral traits: it enriches with live market signals, auto-drafts outreach, inserts scored leads into CRM, and degrades gracefully when Serper key is absent. This goes beyond a simple statement and outlines the sequence of actions. However, it does not mention potential side effects beyond CRM insertion, such as duplicate creation, idempotency, or rate limits, but the main behaviors are transparent.

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

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

The description is two sentences, with the core purpose front-loaded. It packs a lot of information efficiently, but the first sentence is a long run-on that could be segmented for readability. There is no wasted verbiage, and the degradation note is useful as a separate second sentence. Overall, it is concise and structured reasonably well.

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

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

The tool is a complex, multi-step operation that mutates CRM data, yet there is no output schema and no annotations. The description explains the process and the degradation, but it does not mention what the tool returns (e.g., list of created leads, scores), whether it is a long-running operation, or any error conditions. For a tool of this complexity with zero structured context beyond the input schema, the description is incomplete in explaining the outcome and potential issues.

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 67%, so the schema already documents two of three parameters. The description adds context about the overall workflow (niche and market usage) but does not add specific syntax or format details for any parameter, and it does not explain the 'limit' parameter, which lacks a schema description. The description marginally reinforces the meaning of niche_query and market_query but does not compensate for the missing limit 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?

The description states a specific purpose: 'Signal-driven prospecting' with a clear workflow (discover, enrich, auto-draft, insert) and references a distinct 'JoeCRM pattern'. It clearly distinguishes itself from sibling tools like crm_create_lead or collect_signals by describing a multi-step end-to-end process, not a single operation. The verb 'run' and the resource 'prospect_loop' are explicit, and the description explains what the tool does without being tautological.

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 comprehensive prospecting with signal enrichment, and notes a fallback behavior when Serper key is absent. However, it does not explicitly state when to use this tool over alternatives (e.g., using crm_create_lead directly, or collect_signals alone), nor does it mention any exclusions or prerequisites such as CRM configuration or API keys beyond Serper. The guidance is inferred rather than explicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states execution and chaining, but does not mention side effects (e.g., sending campaigns may incur costs or contact customers), error handling (despite on_failure/on_success fields in schema), or any permissions or rate limits. This is a significant gap for a workflow that likely performs consequential actions.

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 core purpose ('Execute a multi-step marketing workflow') followed by a concrete example. No fluff or repetition. It is appropriately sized for what it does.

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 (multi-step, nested steps, no output schema, no annotations), the description is insufficient. It doesn't explain return values, error behavior, how to define step transitions, or what constitutes a valid action. An agent would struggle to correctly construct the steps parameter without additional guidance.

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

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

Schema description coverage is 0%, so the description must compensate. It provides an example chain but does not explain the meaning of workflow_id, steps, first_step, or name, nor how to structure the steps array (e.g., what actions are valid, how to connect on_success/on_failure). The example hints at the content but leaves parameter semantics under-specified.

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

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

The description clearly states a specific verb and resource: 'Execute a multi-step marketing workflow.' It also names the exact chain of operations (sync_contact → create_segment → send_campaign), which distinguishes it from individual sibling tools like hub_sync_contact or hub_send_campaign. This is a clear, non-tautological 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 implies usage: it's for chaining multiple operations rather than calling them individually, as shown by the arrow example. However, it doesn't explicitly state when not to use it (e.g., if you only need a single operation) or name alternative tools as a contrast. The context is clear 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals the fallback for Postiz, but does not disclose side effects, error handling, return values, or what happens on success/failure. Since this is a mutation tool (scheduling), the lack of information about irreversible actions or permissions is a significant gap.

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

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

The description is two sentences with no waste. The primary action is front-loaded, and the fallback detail is placed efficiently at the end. Every sentence contributes to understanding the tool's purpose and behavior.

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 5 parameters, no output schema, and no annotations, the description should provide more detail. It explains the parameters and fallback but omits return value information, error cases, platform-specific limitations, and how the direct API path works. An agent cannot fully predict the outcome of calling this tool beyond the scheduling intent.

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

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

Schema description coverage is only 20% (only scheduled_time has a description), so the description must compensate. It lists the parameters and notes that media_urls are optional and scheduled_time uses ISO datetime, but it repeats the schema names without adding constraints like content_text length, hashtag format, or media URL validation. It adds slight value by clarifying optionality, but does not deeply explain any parameter.

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

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

The description clearly states the tool's function: scheduling social media posts, with routing options (Postiz or direct API). It distinguishes from siblings like generate_social_posts (content creation) and get_upcoming_posts (calendar retrieval) through the specific verb 'schedule' and the resource 'social media post'.

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 mentions the fallback to PostizPublisher.publish_post() when platform=postiz, which is a usage condition for routing. However, it does not directly name alternatives or state when not to use this tool; the context implies scheduling use, but no explicit guidance against using it for content generation or listing.

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

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

With no annotations, the description carries the full burden. It discloses the authentication requirement (env var) and the authenticity of data ('ground truth'), which is useful. However, it omits many behavioral details such as output format, pagination, error handling when the token is missing or invalid, and potential rate limits. The description is adequate but not comprehensive for a tool with zero annotation support.

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, tightly written sentence. It front-loads the core action ('Search Facebook Ads Library'), specifies the data returned, and ends with the key constraint (env var). Every word earns its place; there is no redundancy or filler.

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

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

Given the tool's relative simplicity (3 params, no output schema) and the presence of several closely related siblings, the description provides a good high-level context. It clearly states what data is returned, which helps distinguish it. However, it lacks guidance on output structure (e.g., is it JSON, array?) and how to handle pagination or errors, which an agent would need for reliable invocation. A 3 reflects that it is sufficient for basic use but has gaps.

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

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

Schema description coverage is only 33% (only 'brand_name' has a description). The tool description does not elaborate on the 'limit' or 'country' parameters at all, nor does it explain how they affect the search. Since coverage is low and the description adds no parameter-specific context, it fails to compensate for the schema gaps.

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

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

States a specific verb ('Search'), a specific resource ('Facebook Ads Library'), and exactly what data is retrieved ('REAL competitor ad creatives, copy and delivery data'). It also includes a strong qualifier ('ground truth, not VLM guessing') that distinguishes it from sibling tools that might generate or analyze content.

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?

Implies when to use by emphasizing real data vs. VLM guessing, and mentions the required env var (FB_ACCESS_TOKEN) as a prerequisite. However, it doesn't explicitly name alternative tools from the sibling list or state conditions like 'use this when you need actual ad data, not when you need analysis.' Still, the context is clear enough for an agent to infer appropriate 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?

With no annotations, the description carries the full burden. It discloses that the search is parallel, normalizes engagement across sources, and returns a synthesized brief with consensus themes and money outliers. While this gives some insight into behavior, it omits details such as whether the tool modifies any state, handles rate limits, or what happens if sources are invalid, leaving gaps in behavioral understanding.

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 key details. It packs significant information efficiently, though the structure could be improved by separating the output description for 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 absence of annotations, output schema, and parameter documentation, the description should be more comprehensive. It provides a high-level overview but fails to cover input expectations, default behaviors, or the exact nature of the synthesized brief, leaving an agent without sufficient context to call the tool correctly in all scenarios.

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 explain parameters but does not. It mentions source names in prose but doesn't map them to the 'sources' parameter, nor does it clarify the meaning and constraints of 'query' or 'limit_per_source'. The default values are not elaborated, leaving agents to guess semantics.

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

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

The description clearly states the tool performs a 'parallel multi-source signal search' across named platforms (Product Hunt, HN, Twitter, Reddit, Polymarket) and returns a synthesized brief. This verb+resource combination is specific and distinguishes it from unrelated siblings, though it doesn't explicitly differentiate from similar signal tools like collect_signals or resolve_signal.

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 multi-source signal research but provides no explicit guidance on when to choose this tool over alternatives, nor any exclusions or prerequisites. An agent is left to infer the intended context.

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

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

With no annotations, the description bears the full burden of behavioral disclosure. It notes that the tool records a prediction for later calibration and links to resolve_signal, but it does not mention side effects, idempotency, data retention, or any other behavioral traits. For a simple record operation, it is adequate but lacks depth.

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, both front-loaded: the first states the core action and purpose, the second gives the follow-up workflow. No extraneous content—every sentence earns its place.

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

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

Given 7 parameters (5 required), no schema descriptions, no annotations, and no output schema, the description is far too sparse. It does not explain expected value formats (e.g., what a valid signal_type is), constraints on engagement_score, or how to handle topics/metadata. The workflow link helps but cannot compensate for this missing operational context.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameter meanings. It does not describe title, source, signal_type, url, engagement_score, topics, or metadata at all. The only hint is the general phrase 'signal prediction,' which provides no operational guidance for filling 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 states a specific action ('Record a signal prediction') and a clear resource (signal prediction), and explains its role in calibration tracking. It also distinguishes itself from a sibling by referencing resolve_signal for outcome measurement, making the purpose unambiguous.

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

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

It clearly frames the workflow: track a signal now, then use resolve_signal later to compute Brier score. This implies the tool is for initial recording, but it does not explicitly mention alternatives like collect_signals or state when not to use it, leaving some room for inference.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It does not state whether the tool is read-only, whether it has side effects, rate limits, or auth requirements. It only says 'track' performance, implying a read operation but without explicit confirmation.

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 purpose and enumerates the metrics. It avoids unnecessary detail and is easily scannable, earning a high score for conciseness.

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

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

For a tool with two required parameters and no output schema, the description is incomplete. It does not describe the expected response format, how to obtain a repost_id, or valid platform values. An agent would need additional context to call it correctly, especially given the lack of schema descriptions.

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 parameter meanings. It does not explain what repost_id refers to (e.g., a specific ID from another tool) or what values platform accepts (e.g., Instagram, TikTok). The phrase 'across platforms' hints but does not clarify parameter formats or constraints.

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 'Track UGC repost performance' with a specific verb and resource, and lists concrete metrics (reach, likes, comments, saves, shares). It is distinct from siblings like curate_ugc and request_ugc_permission, though it does not explicitly name 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?

No guidance is given on when to use this tool versus alternatives. It does not mention prerequisites (e.g., needing a repost_id), exclusions, or context like 'use this after a repost is live'. The description merely states the function without usage conditions.

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