ai-netcafe

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

Annotations already establish read-only and idempotent behavior. The description adds valuable behavioral details: parsing robots.txt per user-agent group (not keyword-matched), checking for specific files, calculating real text without JavaScript, and returning an ordered list of fixes. This goes beyond annotations without contradicting them.

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: the first enumerates the audit components, the second states the output. It is front-loaded with the core purpose and contains 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?

The description fully covers what the tool checks (robots.txt, visibility files, text accessibility) and what it returns (score + fixes). With an output schema present, additional return-value detail is unnecessary. The description is complete for a complex audit tool.

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

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

The sole parameter 'url' is fully documented in the schema with 'Page to audit'. The description doesn't add additional meaning beyond the schema, but with 100% coverage, a baseline of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Audit a URL for AI visibility' with specific resources (robots.txt, llms.txt, sitemap, JSON-LD, canonical). It distinguishes from sibling tools like fetch_page or web_search by detailing the audit's unique checks and output (score + fixes).

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 use case clear: determine which AI crawlers can access a site and what visibility signals exist. It does not explicitly mention when not to use it or name alternatives, but the specificity of the audit itself provides clear context 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?

Annotations declare readOnly=false, destructive=false, idempotent=false, and openWorld=false, so the safety profile is covered. The description adds meaningful context beyond that: it returns measured cost metadata, the beta platform currently covers the user charge ($0.00), and capacity limits still apply – useful operational detail an agent would not get from annotations.

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

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

Three tight sentences: purpose first, then cost/capacity caveat, then a concrete example. Front-loaded and no wasted phrasing, though the pricing detail is somewhat tangential to invocation.

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?

An output schema exists, so return values need not be explained; the description still flags that cost metadata comes back. Cost, capacity limits, and an example cover the essentials for a single-prompt tool, leaving only the model-vs-sibling routing lightly implied.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters (model default, prompt, system, max_tokens). The example URL illustrates prompt and model usage but adds no semantics beyond what the schema provides, so baseline 3 applies.

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

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

States a specific verb and resource: send a prompt to one specific LLM and get the answer plus cost metadata. The phrase 'one specific large language model' implicitly distinguishes it from compare_models, but the contrast is left for the agent to infer rather than named.

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 'one specific' framing hints at when this is appropriate versus a multi-model tool like compare_models, and the note that capacity limits apply signals a constraint. However, no alternative is named explicitly and there is no clear when-not-to-use guidance.

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

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

Annotations offer no safety info (all false), so the description carries the burden. It transparently discloses async behavior ('Async — poll with check_job'), latency ('~1-2 minutes'), deployment details (managed hosting with HTTPS), and listing. It does not mention failure modes or resource limits, which would warrant a 5.

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

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

The description is three sentences long, front-loaded with the primary action and outcome, then usage guidance, and finally an async note with a concrete example. Every sentence earns its place with no unnecessary filler or repetition.

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

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

Given the availability of an output schema, the description appropriately focuses on the lifecycle: what it does, what you get, time estimate, async workflow, and ideal use cases. It covers the key aspects an agent needs to decide and invoke correctly, including an example 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 descriptions cover 100% of parameters, so the baseline is 3. The description adds only a single example invocation for the 'description' parameter and does not elaborate on 'name', 'refine', or 'visibility'. It does not meaningfully enhance the schema's parameter explanations.

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: 'Turn one plain-language description into a LIVE single-page web tool' and details the outcome (code generated, deployed to HTTPS hosting, listed, public URL). It distinguishes itself from siblings by specifying its niche ('Best for tool-style apps') and the async polling pattern with check_job.

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

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

Provides explicit usage context: best for 'calculators, converters, checklists, timers, generators, small games' and instructs to poll with check_job after invocation. However, it does not explicitly say when not to use or name alternative tools like get_app for existing apps, so it 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?

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds critical behavioral context: the polling interval, the terminal statuses, the handling of intermediate responses (retry_after_seconds, next_action), and the preference for structured_result. It also includes a concrete GET URL example, fully disclosing the interaction pattern.

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 information-dense but not verbose, delivering purpose, polling guidance, response handling, and an example in three sentences. Each sentence earns its place, and the example is clearly separated for easy 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?

With an output schema present, return values are already specified, so the description correctly focuses on the asynchronous polling protocol. It covers when to call, how to poll, what to do while pending, what to do on completion, and the exact endpoint format, making it fully self-contained 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?

The schema fully documents job_id (100% coverage), so the baseline is 3. The description enhances this by specifying that the job_id comes from deep_research, translate_pdf, or make_slides, and by showing its placement in the URL example, which adds context beyond the schema's generic 'returned when the task was started'.

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 verb ('Get'), the resource ('the status or result of a job'), and the originating tools (deep_research, translate_pdf, make_slides). This differentiates it from sibling creation tools like make_badge or render_diagram, which are all about generating artifacts rather than checking job status.

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

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

The description provides explicit usage guidance: poll every 15-30 seconds until status is 'done' or 'error', follow retry_after_seconds and next_action while pending, and prefer structured_result when complete. It also indicates the tool is for jobs started by specific tools, which serves as both an inclusion and exclusion 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, and the description adds meaningful context: it performs a live fetch from a real China egress, reports specific metrics, and frames the result as a measurement rather than a guess. No contradictions with annotations. It does not mention rate limits or failure behavior, but annotations cover safety.

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

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

Two concise sentences, front-loaded with the action verb, and every word earns its place. 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?

The tool is simple (1 parameter, output schema provided). The description fully explains the tool's purpose, the measurement approach, and the key limitation of alternatives. Return values are already covered by the output schema, so no further detail is needed.

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

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

Schema description coverage is 100% with the 'url' parameter described as 'Full URL to test, e.g. https://example.com'. The description restates the URL-fetching concept but doesn't add new parameter-level detail or format constraints beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states a specific action ('Fetch a URL from a real mainland-China network egress') and the resource/scope ('URL reachability from China'), with measurable outputs (HTTP status, latency, DNS resolution). This distinguishes it from all sibling tools, which are unrelated to network testing.

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

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

The description clarifies when to use the tool: to answer 'is my site/API usable from China?' and explicitly notes that a VPS abroad cannot provide this measurement. While it doesn't name a specific alternative tool, it gives strong contextual guidance and an implicit exclusion.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds substantial behavioral context: it returns a cleaned CSV plus a report of changes ('rows in, rows out, duplicates removed, cells trimmed per column'), and it verifies row arithmetic, explicitly stating it reports inconsistencies instead of returning an unchecked table. This goes well beyond the annotations, which only cover safety.

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

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

The description is detailed but every sentence serves a purpose: listing operations, describing the report, explaining verification, additional transformations, and the use case. It's front-loaded with the main function and not wasteful, though it is a bit long due to the tool's multiple 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?

The description covers purpose, operations, return value, verification, and use case, which is complete for an agent to select and invoke the tool correctly. The output schema and annotations fill remaining gaps (exact return structure and safety profile). No significant missing context, though it doesn't address edge cases like conflicting parameters.

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

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

Schema description coverage is 100%, so all six parameters are already documented in the input schema, including valid ops values. The description reinforces the purpose of split_column and wide_to_long but doesn't add meaningfully new parameter-level semantics beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool's function: 'Tidies a spreadsheet export' and enumerates specific operations (removes duplicate rows, trims whitespace, unifies empty values, splits columns, transposes, unpivots). It distinguishes itself from sibling tools like diff_tables or extract_tables by focusing on cleaning and transforming CSV data for analysis.

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

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

The description provides a clear use case: 'Use when a CSV came out of Excel or an export and needs cleaning before analysis.' It also explains why wide_to_long is useful ('long format analysis tools expect'), but it doesn't explicitly mention when not to use the tool or name alternative tools for exclusions, so it's a 4 rather than a 5.

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

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

Annotations only say readOnlyHint=false and destructiveHint=false; the description goes beyond that by disclosing parallel fan-out, side-by-side return shape, latency and cost metadata, and the beta-platform $0.00 user charge. It stops short of stating rate limits or model-count constraints explicitly, and doesn't mention that 'models' is mutually exclusive with defaults.

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

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

Front-loaded with the core verb and outcome, then cost/latency and finally the example URL. The example is valuable but adds a fourth sentence of length; still, every sentence carries information and none is 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?

With an output schema present, return-shape details are already covered, and the description covers the otherwise-missing behavioral traits (parallelism, metadata, billing). What's left unaddressed is the interaction with the 'models' default vs. explicit list and any per-call concurrency limits, minor for a read-only beta tool.

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

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

Schema coverage is 100% – each of the three parameters already has a description covering defaults and semantics. The description adds no extra parameter detail (no model-id format, no system-prompt merging behavior), so it correctly sits at the baseline for a fully documented 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?

States a specific verb+resource ('run one prompt across multiple LLMs in parallel') with the distinctive scope of fan-out comparison. It clearly contrasts with sibling ask_model (single model), list_models (enumeration), and model_costs (pricing lookup), so an agent can route without opening a 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 framing 'which model should I actually use for this kind of task?' gives a clear task context for when to reach for this tool, and the inline example query demonstrates invocation. It doesn't state explicit exclusions or name alternatives like ask_model for single-model runs, which keeps it short of a 5.

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

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

Annotations only give the generic mutation profile (readOnly=false, destructive=false, idempotent=false), while the description adds high-value behavior: it runs server-side with no client process, it stays silent unless the result actually changes, it requires a workspace token (?w=ws_...) for later management, and costs/capacity limits apply. These auth, notification, and cost traits go well beyond 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?

Purpose and the no-hosting constraint are front-loaded, then kinds are listed efficiently in a single inline enumeration. It is dense but every clause carries information; the beta pricing/capacity sentence is the softest, though still relevant to invocation expectations.

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 an output schema present, return values need not be described, and the description covers what remains: scheduling semantics, the four kinds, notification-on-change behavior, the workspace-token prerequisite, and cost posture. An agent has everything needed to pick a kind and invoke the tool correctly.

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

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

Schema coverage is 100% and the schema already documents notify_url and interval_seconds with their defaults, so the baseline is 3. The description adds genuine value by explaining what each kind consumes as 'input' (URL to watch vs question to re-research) and what kind selection implies, which the bare string-typed kind field does not convey.

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+resource ('Create a task that runs on a schedule in our cloud'), clarifies hosting responsibility ('you do not keep anything running'), and enumerates four distinct kinds with one-line explanations. This clearly separates it from siblings like list_tasks, get_task_runs, and delete_task, which operate on already-created tasks.

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 kind enumeration effectively tells the agent when each mode applies (watch_page vs daily_answer vs watch_reachability vs pipeline), including the cross-reference to create_pipeline for the pipeline kind. However, it never explicitly states when not to use this tool or routes to sibling tools for viewing/managing tasks, so it stops short of full when/when-not guidance.

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

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

Annotations already indicate destructive and idempotent behavior, but the description adds useful context: it also removes run history and stops the task, implying termination of active runs. No contradiction with annotations.

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

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

The description is a single, direct sentence that immediately conveys the action and scope. No wasted words.

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

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

For a simple delete tool with one parameter, output schema, and annotations covering safety, the description is complete. It explains the action and the additional effect on run history, leaving no critical gaps.

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

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

Schema coverage is 100% with task_id described as 'From list_tasks.' The description adds no additional parameter meaning, so the baseline of 3 applies.

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

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

The description clearly states the verb 'remove' and the resource 'scheduled task', and further specifies scope by mentioning 'run history'. This distinguishes it from siblings like create_task and list_tasks.

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 explicit when-to-use or alternative guidance is provided. The description implies usage for stopping and removing a task, but does not state exclusions or reference sibling tools. The schema hint 'From list_tasks' is a minor prerequisite hint, but the description itself lacks 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds behavioral context beyond these by explaining the exact matching semantics and that it reports which column differs and both values. No contradictions with annotations.

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

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

The description is two sentences, front-loaded with the core purpose, then followed by usage guidance. Every sentence earns its place, with no filler or repetition.

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

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

The tool has an output schema, so return values are already specified. The description provides all necessary operational context: the matching algorithm, output categories, and appropriate use cases. It is fully complete for the tool's complexity.

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

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

Schema description coverage is 100%, with each parameter clearly described (e.g., 'Column that identifies a row', 'Link to the first CSV'). The tool description does not need to add parameter-level detail since the schema already does the heavy lifting.

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

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

The description clearly states the verb 'Matches rows across two CSVs on a key column' and specifies the exact three outputs (keys only in A, only in B, and mismatches with column names and values). It also distinguishes itself from the sibling reconcile_ledger by explicitly noting it needs no amount column.

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

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

The description explicitly says 'Unlike reconcile_ledger this needs no amount column' and lists appropriate use cases ('name lists, inventory counts, permission tables, and any "these two exports should match" check'). This provides clear when-to-use guidance and names an alternative.

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

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

Annotations already mark the tool readOnly and idempotent. The description adds valuable behavioral context by disclosing the LCS algorithm and emphasizing that results are deterministic ('not guessed by a model'). This goes beyond the structured annotations without contradicting them.

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

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

Two sentences, front-loaded with the primary outcome, then the use case and rationale. Every sentence contributes essential information with zero 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?

For a simple two-string tool with full schema coverage, rich annotations, and an output schema, the description provides complete context: what it returns, how it computes it, and when to use it. No additional explanation of return values is needed given the output schema.

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

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

Schema coverage is 100%, with each parameter explicitly described as 'first (before) text' and 'second (after) text'. The description reinforces the directional comparison but adds little new parameter-level meaning beyond the schema already provides.

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

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

The description opens with 'Returns which lines were added and which were removed, with line numbers', clearly specifying the verb and output. The phrase 'computed with a longest-common-subsequence, not guessed by a model' and title 'line by line' differentiate it from sibling tools like diff_tables and from ad-hoc LLM comparison.

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

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

Explicitly states when to use: 'Use to compare two versions of a config, a document, or any command output'. It also names the alternative to avoid: 'instead of asking an LLM to eyeball two blobs and hoping it notices', which gives both a positive use case and a clear avoid-this-approach.

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

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

Beyond the annotations (read-only, idempotent), the description discloses important behaviors: arithmetic validation (net+tax=gross), independent batch total checking, flagging of misread rows with exact differences, and deliberate omission of batch totals for mixed currencies. It also explains CSV encoding for Excel compatibility. No contradictions with annotations.

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

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

The description is compact, front-loaded with purpose, and every sentence adds value: purpose, validation details, edge-case handling, and output format. No fluff or repetition of schema/annotations.

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 a single parameter, high schema coverage, and the presence of an output schema, the description fully covers input format, validation logic, edge cases, and output encoding. It provides enough context for an agent to select and invoke the tool correctly without needing 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?

The schema already provides full coverage for the 'urls' parameter. The description adds meaning by specifying accepted input types (PDF or page images) and reinforcing the 20-item limit, which goes slightly beyond the schema but is not redundant.

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: take up to 20 invoice URLs and return a ledger-ready table with specific fields (number, date, seller, buyer, net/tax/gross, currency). This distinguishes it from siblings like extract_statement or extract_tables, which target different document types.

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

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

The description implies the use case (invoice extraction) and provides constraints (up to 20 URLs, PDF or page images, mixed-currency behavior). It does not explicitly name alternative tools or state when not to use it, but the context is clear enough for an agent to decide.

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

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

Beyond the annotations (read-only, idempotent, non-destructive), the description reveals valuable behavioral traits: the reconciliation cross-check formula, the output formats (JSON + CSV), and the exact failure feedback (difference and row where running balance breaks). This gives the agent a strong grasp of what to expect.

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

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

Two sentences: the first states the primary action and output, the second details the reconciliation check and failure reporting, followed by a clear limitation. Every sentence contributes, and the key info is front-loaded.

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

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

With one parameter, robust annotations, and an output schema present, the description covers the necessary context: the input, the processing logic, the return behavior, and an explicit limitation. There are no significant gaps for agent selection and 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?

The schema already fully describes the only parameter (`url` with description). The description adds minimal extra meaning—only implying the URL must point to a text-layer PDF—but the baseline of 3 is appropriate given the high schema coverage.

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

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

The description uses a specific verb ('Turn... into') and names the exact resource: 'a bank statement or transaction PDF'. It clearly distinguishes from sibling tools like extract_tables by focusing on bank-specific reconciliation rather than generic table extraction.

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 implicitly tells when to use: for bank statements requiring a reconciled transaction table, and explicitly states the constraint 'Text-layer PDFs only (scanned images not yet supported)' as a when-not. However, it doesn't explicitly name alternatives for scanned PDFs or generic table extraction.

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

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

Beyond the annotations (readOnly, idempotent, non-destructive), the description adds valuable behavioral traits: 'Rows the model was unsure about are flagged rather than guessed' and the limitation 'Text-layer PDFs only.' This gives insight into output quality and compatibility without contradicting annotations.

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

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

The description is three sentences, front-loaded with the core function, followed by the fields explanation, then constraints and behavioral note. Every sentence adds value with no redundancy or wasted words.

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

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

For a tool with two parameters and an existing output schema, the description covers purpose, parameter usage, limitations, and uncertainty handling. It is complete enough for an agent to invoke the tool 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?

The input schema already covers both parameters with 100% coverage, so the baseline is 3. The description adds some context for the fields parameter by explaining its purpose (aligning differently-named headers), but does not introduce new syntax or format details 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 extracts tables from a PDF into structured rows (JSON + CSV), specifying the resource (PDF) and output format. It distinguishes from siblings like pdf_to_markdown or extract_statement by emphasizing structured tabular data and the option to force a fixed column set.

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

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

The description provides clear context on when to use the tool, especially for aligning documents with inconsistent headers by passing fields. It also sets a constraint with 'Text-layer PDFs only,' implying it should not be used for scanned/image PDFs, but it does not explicitly name alternative tools.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the bar is low; the description nonetheless adds the single most decision-relevant trait, that rendering is server-side only and SPA or empty-text pages return nothing useful. It stops short of auth needs, rate limits, redirects, size/truncation caps, or error behavior for non-HTML responses, which is why it is not a 5.

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

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

Three sentences plus an example, front-loaded with the purpose before limitations and routing. The sample request URL is slightly noisy for a single-parameter tool, but it does demonstrate the call shape, so it mostly 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?

An output schema exists, so return-value documentation is unnecessary, and the description covers purpose, the JS limitation, and alternatives. It is nearly complete; minor gaps remain around non-HTML payloads (notably the sibling pdf_to_markdown) and any truncation or error semantics.

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

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

Only one parameter with 100% schema coverage, so the baseline is 3. The description adds one meaningful qualifier the schema lacks — the URL must be public/reachable — but gives no syntax guidance beyond the bare example URL, which the schema already implies.

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+resource ('Fetch a public URL') plus the exact output form ('clean LLM-ready Markdown from the server-rendered response'). It also carves out the boundary against web_search and pdf_to_markdown by explaining that JS-rendered pages are out of scope, so an agent can route without opening sibling schemas.

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

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

Gives explicit when-to-use ('after web_search to read a reachable public source, or to ingest a static page for analysis'), explicit when-not ('does not execute browser JavaScript'), and names concrete alternatives for the failure case (web_search, a browser, or the site's API). Nothing about selection is left 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?

Annotations already establish read-only and idempotent behavior. The description adds value by disclosing the specific categories of information returned and providing a concrete example. It does not mention any side effects, which is consistent with the read-only annotation.

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, information-dense sentence followed by a useful example. It avoids redundancy and front-loads the core purpose.

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

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

With a single parameter, full schema coverage, and an output schema present, the description sufficiently covers what the tool does, how to call it, and what to expect. The example and parameter sourcing guidance make it complete for this simple tool.

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

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

The schema already fully describes the slug parameter, including its source (list_apps). The description reinforces this with the example URL, but doesn't add new semantic meaning beyond the schema's 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?

The description clearly states it returns full details of one hosted application, listing specific content (what it does, usage, benchmarks, repo, URL). This distinguishes it from siblings like list_apps (which lists apps) and build_app (which builds).

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

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

The description implies usage after list_apps, as the slug parameter is explicitly sourced from list_apps. It gives an example HTTP request showing how to invoke it. However, it doesn't explicitly state when not to use this tool vs checking jobs or building apps, though the context makes it fairly obvious.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds billing context ('User charge is $0.00') and hints at result-change detection, which is genuine extra information, but it does not describe pagination, ordering, or retention limits on run history.

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

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

Two tight sentences with the core payload described first and the cost note last; nothing is padded. The cost sentence is slightly tangential but still useful information for the caller.

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 an output schema present, the description need not explain return structure, and it correctly focuses on purpose. Annotations cover safety and the schema covers parameters, leaving only minor gaps around run ordering, retention, and when to prefer list_tasks.

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

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

Schema description coverage is 100%: both limit (max 20, default 5) and task_id (source tools named) are documented in the schema itself. The description adds no parameter detail, so the baseline 3 applies.

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

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

The description names a specific resource ('recent runs of one scheduled task') and enumerates what each run yields (return value, change status, cost metadata), which clearly separates it from list_tasks and create_task. It stops short of explicitly naming the sibling it is not, so it is clear but not fully differentiated.

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

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

Usage is implied: call this to inspect a task's run history. There is no explicit when-to-use statement, no mention of prerequisites (a valid task_id), and no exclusion or alternative such as list_tasks for enumerating tasks.

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?

While annotations already indicate readOnlyHint and destructiveHint, the description adds valuable behavioral context: auto-detection of direction and safe error handling (returns parser message instead of silently producing wrong output). This goes beyond the structured data.

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 four sentences, each serving a purpose: action, auto-detection, error behavior, and use cases. It is front-loaded and free of redundancy.

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

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

For a simple conversion tool, the description covers the operation, auto-detection, error handling, and example use cases. With output schema present and annotations covering safety, nothing significant is missing.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning by explaining that 'to' is optional because auto-detection handles the direction, and it clarifies that 'text' contains the content. This supplements the schema effectively.

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 'Converts JSON to YAML or YAML to JSON' with a specific verb and resource. It also distinguishes itself from sibling tools like validate_json by focusing on conversion rather than validation.

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 explicit use cases: 'Use when a config, a CI file, or a Kubernetes manifest needs to be in the other format.' It does not explicitly mention alternatives, but the context is clear and sufficient 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?

Annotations already declare readOnly/idempotent, but the description adds crucial context: the signature is NOT verified, the response explicitly says so, and decoding should not be treated as proof. This goes beyond basic annotations and is valuable for safe usage.

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

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

Three sentences: the first states the core function, the second adds the critical limitation, and the third reinforces safe usage. No wasted words and information is front-loaded.

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

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

Given the simple one-parameter schema and presence of an output schema, the description fully covers the tool's behavior including output contents (timestamps, seconds remaining) and the security caveat. It is complete for a debugging tool.

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

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

The schema already provides 100% coverage with a clear description for the single token parameter. The description does not add further parameter-level detail, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool decodes JWT header and payload, reports timestamps and seconds remaining, and explicitly notes the signature is not verified. This is specific and distinguishes it from any other sibling tool.

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

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

The description explicitly says decoding is fine for debugging a token you already hold, and warns never to treat values as proof, directing verification to a service with the secret. This provides clear when-to-use and when-not-to-use context without needing a named sibling.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds useful context about the apps being pre-configured (no local setup/API key needed) and provides an example URL. While it doesn't detail return structure, the output schema exists, so the description sufficiently complements the annotations.

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

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

Three sentences plus an example URL. Each sentence serves a distinct purpose: describing the tool, giving example use cases, and excluding cases where other tools should be used. No filler or repetition.

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

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

This is a simple list tool with one optional parameter, an output schema, and full annotations. The description covers purpose, usage context, and exclusions comprehensively. Nothing significant is missing.

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 100% coverage for the single optional 'category' parameter, including examples. The description doesn't add parameter-specific detail, but given perfect schema coverage, the baseline of 3 is appropriate.

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

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

The description clearly states the tool lists open-source AI applications hosted at AI NetCafé, with pre-configured setup. It distinguishes itself from task-specific sibling tools by naming alternatives like compare_models, translate_pdf, deep_research, and make_slides, making its purpose unambiguous.

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

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

The description provides explicit guidance: 'Use this to find a tool for a task like...' and 'Do not call this first when the request already clearly matches...' This tells the agent exactly when to use this tool and when to use more direct alternatives.

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

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

Annotations already declare read-only, idempotent, non-destructive semantics, so the safety profile is covered. The description adds genuinely useful context beyond that: rates are platform cost metadata only and user charges are $0.00 during the beta, which prevents misreading the numbers as billable amounts.

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 front-loaded sentences that each carry information, with the pricing clarification placed right after the rate mention. The trailing 'Example — GET https://...' is a minor waste for an MCP tool that is not invoked over raw HTTP.

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?

An output schema exists, so return-value detail is unnecessary, and the description still previews the payload (rates plus health metadata) and the pricing caveat. Only the relationship to sibling cost/compare tools is left unaddressed.

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

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

Schema description coverage is 100% and the tier enum is fully documented in the schema, so the description's phrasing about 'healthy tiers available without a user key' only lightly reinforces it. Baseline 3 applies when the schema does the heavy lifting.

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

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

States a specific verb and resource (list models) plus what is returned: reference rates and health metadata, scoped to the free beta. It does not name the obvious siblings model_costs or compare_models, so an agent must infer the distinction rather than being told it.

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

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

The description explains beta/pricing context but gives no explicit when-to-use guidance and never mentions the competing tools (model_costs, compare_models, ask_model) that a listing request could also serve. The reader must infer that this is the discovery entry point.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds useful context about the response contents (next run times, run counts, platform cost) and a beta pricing note, but discloses nothing about pagination, ordering, or limits.

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

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

Two short sentences, with the core listing behavior front-loaded. The beta pricing sentence is arguably extraneous to tool selection but is brief and does convey cost-relevant context.

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

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

For a zero-parameter, read-only list tool with an output schema and full annotation coverage, the definition supplies enough to call it correctly. It need not describe return structure since an output schema exists.

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 per the rubric the baseline is 4. There is nothing for the description to disambiguate, and it does not introduce confusion about 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?

States a specific verb and resource ('Show scheduled tasks') and even enumerates the returned facets (next run times, run counts, cost metadata). It does not, however, distinguish itself from the sibling get_task_runs, which an agent could plausibly confuse with a task-listing tool.

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

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

There is no statement of when to use this tool versus get_task_runs (run history) or create_task/delete_task. The listing intent is inferable from the name, but no explicit context, prerequisites, or alternatives 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?

Annotations already declare read-only, idempotent, non-destructive. Description adds valuable context: column union behavior, blanks for missing columns, row-count verification, and the failure mode it prevents. No contradiction.

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

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

Four sentences, each packed with purpose, behavior, and usage. No filler, front-loaded with the main action.

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

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

For a merge tool with output schema and comprehensive annotations, the description fully covers behavior, edge cases, and usage scenarios. Includes row-count verification, making the output trustworthiness explicit.

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

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

Schema covers both parameters with descriptions (100% coverage). Description adds the 'up to 20' limit and implies either urls or texts can be used, providing extra constraint context. Baseline 3 elevated to 4 for this addition.

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

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

Clearly states it combines up to 20 CSVs into a single table, with specific details about column unioning and row-count verification. Distinguishes from sibling tools like diff_tables by focusing on merging rather than comparison.

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

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

Provides explicit use cases ('monthly exports, per-store sheets, or any set of files with the same subject but drifting headers'). Lacks explicit exclusions or named alternatives, so not a 5, but clear context is 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?

Annotations already establish it as a safe, idempotent read (readOnly, idempotent, non-destructive, non-open-world). The description adds genuinely useful context beyond that: the $0.00 free-beta charge, the CC BY 4.0 licensing, and the caveat that a call's cost depends on the model's emitted-token count rather than published list prices.

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 purpose is front-loaded, but the sentence is long and meandering with parenthetical em-dash asides, marketing-inflected claims, and a trailing raw example URL. Only the standard_bench/production_mixed distinction and the 'choose a model before bulk work' instruction clearly earn their 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?

An output schema exists, so return-value detail is not needed. The description supplies the dataset distinction, the comparability caveat, and the model-selection intent, making it largely complete for a single-param read tool, though it could more explicitly route against compare_models.

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

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

There is a single optional parameter (days) with 100% schema description coverage, so the schema already documents 'Measurement window in days (default 30).' The description adds no format or boundary detail beyond the schema, warranting the baseline 3.

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

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

The description names the resource precisely — 'Measured platform cost metadata for one call on each model' — and distinguishes the two datasets (standard_bench vs production_mixed). However, the operative verb is implicit and it doesn't clearly differentiate itself from the sibling compare_models, so an agent must infer the boundary.

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

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

It gives explicit context: use standard_bench measurements 'to choose a model before bulk work,' and warns that production_mixed is 'NOT comparable across models.' That is clear when-to-use guidance, though it never names compare_models or list_models as alternatives to route between.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds useful behavior beyond annotations: exact text-layer extraction, vision model for images, cost differences, and reading order handling. It exceeds the baseline and does not contradict any annotation.

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 tightly written sentences. The first sentence states the core action and scope, the second clarifies behavior and cost. No filler or repetition, and the most important information is front-loaded.

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

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

Given an output schema exists and annotations are present, the description covers input types, formatting preservation, multi-column handling, and cost/processing differences. It lacks explicit mention of file size limits or language support, but the provided information is sufficient for most use cases.

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 defines the single 'url' parameter with 100% coverage and a clear description. The tool description does not add further parameter-specific detail beyond what the schema provides, so it meets the baseline but not more.

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 converts PDFs or scanned images into Markdown with formatting preservation and reading order. The verb 'convert' and specified output make the purpose unambiguous, and it distinguishes itself from sibling tools like extract_tables or translate_pdf.

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

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

Provides clear context on when to use the tool (for text-layer PDFs vs scanned images) and notes cost differences, but does not explicitly name alternative sibling tools or exclusion criteria. This is more specific than generic guidance but stops short of explicit 'use this instead of X' instructions.

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

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

Annotations already cover read-only and non-destructive behavior. The description adds a prerequisite (needs a workspace/key for durable memory) and explains the type of context it retrieves (decisions, fixes, preferences). The example GET request also illustrates the call style. No contradiction with annotations.

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

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

The description is concise and front-loaded with the core purpose. It includes an example and a key prerequisite in two sentences, with no redundant information. Every sentence serves a purpose.

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

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

The description covers the tool's purpose, when to use it, a usage example, and an authentication prerequisite. With full parameter documentation, an output schema, and annotations, the description is sufficiently complete. It also positions the tool well relative to its siblings.

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 provides detailed descriptions for all three parameters (limit, query, project), so the description adds little beyond restating that filtering is optional and showing an example that uses 'query.' With 100% schema coverage, the baseline is 3, and the description does not significantly enrich parameter meaning.

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

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

The description opens with 'Retrieve previously stored memories,' a specific verb and resource. It also specifies optional filtering by search query and project, and gives a concrete use case (restoring context at the start of work). This clearly distinguishes it from sibling tools 'remember' and 'forget.'

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

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

The description explicitly says to call it 'at the start of work on a known project' to restore context, which is clear when-to-use guidance. It does not explicitly name alternatives, but the phrasing and sibling names imply that 'remember' is for storing and 'forget' for deleting. The example and note about needing a workspace/key add practical context.

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

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

The description goes well beyond the readOnly/read-only annotations by explaining the integer-cent precision ('0.1 + 0.2 never invents a phantom difference') and the built-in arithmetic proof ('the listed differences are re-added and must equal the gap'). These are valuable behavioral details not present in annotations.

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

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

The description is front-loaded with a clear purpose and then provides useful details. The final sentence about VLOOKUP, while informative, is slightly rhetorical and could be seen as non-essential, but overall the structure is clean and purposeful.

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 moderate complexity (6 params, output schema present, rich annotations), the description fully covers the behavioral contract: what inputs do, how matching works, what the output looks like (three lists), and the verification step. No significant gaps remain.

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

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

Input schema covers all six parameters with descriptions (100% coverage), so the baseline is 3. The description adds semantic meaning by explaining that the 'key' parameter is for row matching and 'amount' is compared in integer cents, plus clarifies the relationship between url/text inputs for each side.

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: 'Reconciles two sets of records' and details the matching and comparison logic, returning three specific lists. The title also frames it as an alternative to VLOOKUP, distinguishing it from sibling tools like diff_tables or merge_tables.

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

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

The description provides explicit when-to-use scenarios: 'Use for month-end close, platform payouts vs orders, or any "these two numbers should agree and do not" problem.' It does not explicitly mention alternative tools or when-not-to-use, but the VLOOKUP comparison implies the manual alternative.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=false, idempotentHint=true, destructiveHint=false, covering safety. The description adds behavioral detail about the return output: every match with position and capture groups, including named groups. This goes beyond annotations and provides useful context without contradicting them.

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, each earning its place. The first states the core action and output; the second gives a concrete usage scenario. No redundant phrasing or padding.

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 modest complexity, the description covers purpose, usage, and returns. An output schema exists to document the return structure, and annotations cover side-effect safety. The description is sufficient for an agent to select and invoke correctly.

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

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

The input schema provides descriptions for all three parameters (pattern, text, flags) with 100% coverage, including notes like 'without surrounding slashes' and default for flags. The description does not need to add much parameter-level detail, so a baseline of 3 is appropriate. It does hint at escaping concerns, but that's usage guidance, not 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 starts with a specific verb ('Runs') and identifies the resource ('regular expression against sample text') and outcome ('returns every match with its position and capture groups'). The title 'Does this regex match — and what does it capture?' reinforces the purpose and distinguishes this from sibling tools like diff_text or extract_*.

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

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

Explicitly states when to use: 'Use before wiring a pattern into code, instead of guessing whether the escaping survived the trip through JSON and the shell.' It provides clear context and a concrete use case, though it does not name an alternative tool explicitly. This is sufficient guidance for an AI agent.

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

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

Annotations confirm this is a non-read-only, non-idempotent, non-destructive write, and the description adds context annotations can't carry: a bounded per-caller/workspace memory pool and no API key requirement. It also warns against secrets/raw logs, which is genuine behavioral guidance. It doesn't cover what happens on pool exhaustion or whether repeats duplicate, keeping it at 4.

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 purpose and constraints are front-loaded, followed by a concrete call example. Three sentences and an example is slightly generous but each element (guidance, exclusion, example) earns its place.

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

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

With an output schema present, the description need not explain returns, and it covers auth, capacity, exclusions, and an invocation example. It omits update/duplicate/idempotency behavior for a non-idempotent write, which is the remaining 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 coverage is 100%, so the baseline is 3. The description adds value by mapping its four example categories onto the enum values (decision/preference/bugfix/discovery) and by tying the project param to later recall scoping, giving semantics beyond the raw schema text.

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

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

The description names a specific verb ("Persist") and resource ("durable memory") and enumerates what qualifies as a memory (architecture decision, preference, bug fix, discovery). It gestures at the sibling recall tool ("scope recall later") but never explicitly states how this differs from it, so it stops 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?

It gives clear positive context (durable items worth persisting) and a negative rule ("Do not store secrets or raw logs"), which is real when-not guidance. It stops short of explicitly naming the recall counterpart as the retrieval alternative, so it's a strong 4 rather than a 5.

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

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

With annotations already declaring readOnlyHint=true and idempotentHint=true, the description adds useful context by stating the result is a hosted SVG/PNG URL and mentions 'self-hosted Kroki', indicating the underlying service. The example also illustrates the endpoint usage. It does not cover auth or rate limits, but the annotations reduce the burden.

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 plus an example, with the core purpose stated first. The example includes a realistic URL but is not overly verbose. Every clause adds information: supported formats, output type, and usage pattern.

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 simple, and the description covers the essential aspects: what it does, supported formats, output format, and an example. The schema provides full parameter details, annotations cover safety, and an output schema exists. The description is sufficient for an agent to select and invoke the tool correctly.

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

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

The schema already has 100% description coverage for all three parameters, so the baseline is 3. The description adds value by providing a concrete example of the query-string format (source=...&format=png) and clarifying the supported diagram types. This helps an agent understand parameter syntax 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 opens with 'Turn diagram-as-code into an image' which clearly identifies both the action (rendering) and the object (diagram source text). It explicitly names supported languages (Mermaid, PlantUML, Graphviz/DOT, etc.), distinguishing it from sibling image-generation tools like text_to_image or make_chart. The purpose is unambiguous and specific.

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

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

The description clearly implies the tool is for diagram-as-code languages, giving context for when to use it. However, it does not explicitly contrast with alternatives or state when not to use it. An agent can infer use cases from the listed formats, but there are no direct exclusions or alternative 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?

Annotations already declare readOnly/idempotent, but the description adds determinism ('same input always produces the same output') and exact error locations (line/column), going beyond structured metadata. This is valuable 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?

Three sentences, each valuable: purpose, determinism, and use case. Front-loaded and no redundancy.

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

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

Description covers purpose, usage, determinism, and error behavior. Output schema covers return shape. For a conversion tool with rich annotations, it's sufficiently complete.

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

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

Schema covers all parameters at 100%, so baseline is 3. The description adds a useful list of supported dialects for read/write, aiding parameter selection, though it doesn't add much beyond that.

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

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

Clearly states a specific verb ('Convert') and resource ('a SQL statement from one dialect to another') and lists many supported dialects. It distinguishes itself from sibling formatting tools by focusing on SQL dialect conversion.

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

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

Explicitly states when to use ('when migrating queries between databases or debugging dialect-specific syntax'). It doesn't mention exclusions or alternatives, but the sibling tools are unrelated, so the context is clear.

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

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

Beyond the read-only/idempotent annotations, the description discloses important behavior: it returns specific violations rather than a boolean, and explicitly states the scope (required + types only) while disclaiming full JSON Schema support. This adds substantive context not captured by annotations.

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

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

Four sentences, each with a distinct purpose: what it does, what it returns, its limitations, and when to use it. No wasted words; the information is front-loaded and efficiently delivered.

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 simple (2 params, one required) and has a full output schema, so the description does not need to explain return values. It covers the essential behavioral aspects (parsing, optional key/type checks, violation reporting, and scope limitations) adequately for an agent to use 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 schema already provides 100% coverage for both parameters, with descriptions for 'text' and 'schema' including details about required[] and properties[].type. The description adds only a mild restatement of the schema's functionality ('required keys are present with the right top-level types'), not significantly new meaning, so it meets the baseline of 3.

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

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

The description uses a specific verb ('Checks that text parses as JSON') and clearly states the resource (text) and optional key/type validation. It distinguishes itself from siblings like json_yaml by specifying it validates JSON and explicitly scopes to required keys and types, not full JSON 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 gives an explicit use case ('Use before feeding generated JSON into something that will fail on it') and a clear limitation ('not full JSON Schema'), implying when not to use it. However, it does not name an alternative tool for full schema validation, so it falls short of the full when/when-not/alternatives guidance.

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

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

Annotations already mark it read-only and idempotent; the description adds that it aggregates dozens of engines with no tracking and returns titles, URLs, and snippets, providing useful behavioral context without contradicting the annotations.

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

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

The description is two sentences plus a concise example, front-loading the action and including only essential output and usage information.

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

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

For a simple two-parameter search tool with an output schema and read-only annotations, the description covers what it does, when to use it, what it returns, and an example, making it complete for an agent to invoke correctly.

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

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

Both parameters are fully described in the input schema (query and max_results), so the schema carries the semantic burden; the description does not add extra parameter-level detail beyond noting an example query.

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 searches the live web via SearXNG meta-search, names its output (titles, URLs, snippets), and distinguishes it as a no-tracking aggregator, making its purpose distinct from sibling tools like fetch_page or deep_research.

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

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

It explicitly instructs to use when current information or sources are needed, giving clear context. However, it does not name alternatives or exclusions, so it falls short of full when/when-not guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds valuable behavioral traits not visible in annotations: deterministic, calls no model, costs nothing, and never runs out of quota. No contradiction with annotations.

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

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

Four dense sentences, front-loaded with the core purpose in the first sentence and supported by recipes, cost/quota guarantees, and when-to-use guidance. Every sentence earns its place; no filler or repetition.

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

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

Given the simple context (single required string parameter, rich annotations, and an output schema), the description is complete. It covers the tool's behavior, return value highlights, performance/cost characteristics, and usage context without leaving important 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?

The input schema already describes the 'task' parameter with examples, and schema coverage is 100%. The description adds the nuance 'plain language (any language)' and emphasizes that example calls are generated, providing modest additional meaning beyond the schema.

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

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

The description clearly states the tool's purpose with a specific verb+resource: describe a task and get back exactly which tools on the server do it, with ready-to-run example calls. It explicitly distinguishes itself from sibling tools by positioning itself as the meta-guide that prevents 'reading the whole catalogue and guessing.'

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

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

Provides explicit when-to-use guidance: 'Call this FIRST when you are not sure what this server offers.' It also clarifies the intended use case (plain-language task discovery) and contrasts with the alternative of scanning the catalogue manually, which is sufficient for a meta-tool.

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