MeshMarket

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

Annotations include readOnlyHint=false, but the description goes further: it states the tool 'writes up to 3 new memories back' (mutation), describes fallback behavior when the memory server is unreachable ('falls back to its own always-on store otherwise — never fails the call'), names the exact model used, and notes that the response includes the model name. No contradiction with annotations; the description adds substantial behavioral context.

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

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

The description is dense but every sentence carries distinct information: core function, memory behavior, fallback, usage guidance, model, input, output, and cost. It is front-loaded with the primary purpose and structured to flow from what → when → how → returns. 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 complex tool with no output schema, but the description covers all critical aspects: memory read/write counts, semantic recall, fallback guarantee, model, cost, usage context, input shape, and a complete list of return fields. It also distinguishes siblings. Nothing essential is missing for an agent to invoke it correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by summarizing the input format ('Input: {think: string}') and enumerating the return fields, which is helpful since there's no output schema. However, it omits the aliases and the optional character scope, which the schema documents fully. Overall, it meaningfully supplements the schema without redundancy.

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

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

Description opens with 'Reason over a question or task with your agent's own persistent memory in the loop' – a specific verb+resource+mechanism. It clearly differentiates from siblings: 'agent-memory covers plain store/recall' and 'agent-brain-smart runs the identical contract on claude-sonnet-5.' This is unambiguous about what the tool does and how it differs.

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

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

Explicit usage guidance: 'Use for decisions that should build on what the agent already knows' and directly names the alternative for plain store/recall ('agent-memory'). It also references agent-brain-smart for a different model tier. This tells the agent when to pick this tool over its closest siblings.

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

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

The description discloses 'write 3 back,' revealing that this tool writes memories back, which aligns with readOnlyHint=false and adds context beyond the bare annotation. It also notes the model swap and cost, giving the agent useful behavioral expectations 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?

Each sentence earns its place: behavior, when to use, when not to use, and input contract reference. The parenthetical cost and metadata tags are slightly extraneous but do not bloat the description.

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 behavior, cost, selection criteria, and directs to the input schema. With no output schema, a brief note on the return value would be useful, but the overall definition is complete enough for an agent to invoke and reason about the tool.

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

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

Schema coverage is 100%, and the think parameter's description already explains aliases, truncation, and precedence. The tool description adds no extra parameter-level semantics beyond pointing to the input_schema, 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 states a specific behavior: recall 12 memories, reason, and write 3 back, on claude-sonnet-5 instead of haiku. It clearly differentiates this tool from agent-brain by model tier and use case, so an agent can identify what the tool does without opening the schema.

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

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

Explicitly names the alternative agent-brain and gives concrete selection criteria: use this tier for multi-step decisions, ambiguous evidence, or senior-escalation-level tasks; use agent-brain for lookups and routine calls. This leaves no ambiguity about when to choose this tool.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true, destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context: the action defaults (non-empty content infers store, otherwise recall), the 2 MESH/call cost, and the scoped/private nature of the memory. It doesn't detail what happens on overwrite or deletion, but the annotations plus the action-default disclosure are solid.

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 and front-loaded with the core purpose, then gives the action syntax, then the use case, then the sibling contrast, then cost. Every sentence earns its place. Slight redundancy with the schema's action enum, but the inference behavior is worth stating.

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 a rich schema (100% coverage) and annotations covering safety, the description is nearly complete. It explains the action inference, the cost, and the relationship to agent-brain. The only gap is that it doesn't describe the return format of recall results, but with no output schema and the schema already covering inputs, this is a minor omission.

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 parameters thoroughly. The description adds value by explaining the action inference behavior (non-empty content/remember/text infers store, otherwise recall) and the cost, which are not in the schema. It doesn't repeat the schema's parameter details, which is appropriate.

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

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

The description states a specific verb-resource pair ('Store or recall private, scoped memory') and immediately distinguishes itself from the sibling agent-brain by noting that agent-brain is the reasoning layer that reads/writes memory in the loop. This makes the tool's role clear and differentiates it from its closest sibling.

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

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

The description gives explicit usage context: 'Good for continuity across sessions' and contrasts with agent-brain as the reasoning layer. It doesn't explicitly say when NOT to use it or name alternatives beyond agent-brain, but the session-continuity context plus the sibling contrast provides clear guidance.

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

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

Annotations already declare openWorldHint=true, readOnlyHint=false, and destructiveHint=false. The description adds the cost per call (2 MESH/call) and the fact it is a 'reasoning' tool, but does not disclose additional behavioral traits like potential external data fetching or response format. 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 (one sentence) and front-loaded with the core purpose. However, it includes brand-related fluff ('the original api.meshtool.ai capability, now settled in MESH') that does not help an AI agent and slightly detracts from conciseness.

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

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

The description gives a clear purpose and input format, but lacks details on return structure (no output schema), usage examples, and differentiation from sibling tools. For a tool with annotations and a simple schema, it is minimally complete but leaves gaps.

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

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

Schema description coverage is 100%, so the input schema already documents context, goal, and constraints. The description only mentions '{ context: string }' and adds no extra meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Analyze') and identifies the resource ('any business situation') and the outcome ('get a structured recommendation back'). However, it does not distinguish this tool from sibling tools like task-analysis or structured-extract, which also involve 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 no explicit guidance on when to use this tool versus alternatives. It only says 'Analyze any business situation,' which is broad and does not mention exclusions or other tools. There is no mention of use cases that would favor a 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 provide minimal info (readOnlyHint=false, openWorldHint=true, destructiveHint=false). The description adds behavioral context by explaining it's a guide, covers specific topics, and costs 2 MESH/call. It implies no side effects but could be more explicit about not modifying state.

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

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

The description is concise, well-structured, and front-loads the core purpose. Each clause provides distinct value: definition, coverage, target audience, and cost. 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 educational tool with no output schema, the description is largely complete. It covers what the tool is, what it includes, and who should use it. It could optionally mention return behavior, but that's not critical for a guide.

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 a detailed description of the `input` parameter, though it's abstract. The tool description does not add any parameter-specific guidance, leaving the baseline at 3. The input payload format remains unclear for this particular tool.

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

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

The description clearly identifies the tool as a plain-language guide to using an AI browser agent, covering specific areas (agent-to-person and agent-to-agent work) and getting started. It distinguishes itself from sibling tools by being educational rather than operational.

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

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

The description states it's 'Perfect for anyone new to agentic tools,' giving a clear target audience and implicit use case. It does not explicitly contrast with alternatives, but the educational nature is self-evident and the cost info adds 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 discloses key behaviors: kernel-free generation, deterministic (no model call), and the guarantee that non-watertight STL fails the call with MESH refunded. It also mentions the cost (15 MESH/call). Annotations indicate readOnlyHint=false and openWorldHint=true, which align with the description's emphasis on deterministic generation and no model call. The description adds value beyond annotations by explaining failure modes and guarantees.

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, front-loaded with the core purpose, and every sentence adds value. It covers purpose, guarantees, failure behavior, determinism, and cost in a compact format. No wasted words.

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

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

Given the complexity of the tool (many parameters, multiple output formats, guarantees), the description is quite complete. It explains the output formats, the guarantee of wall thickness, failure handling, and determinism. It does not detail return values, but there is no output schema, so the description could have mentioned what the response contains (e.g., base64 STL). However, the description mentions 'binary STL (watertight solid), DXF R12, or SVG' and 'MESH refunded' which gives some context. Slight gap on response structure, but overall adequate.

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

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

The input schema has 100% description coverage for all parameters, so the description does not need to add much. However, the description does not provide additional context beyond the schema, such as relationships between parameters (e.g., wall must be less than pitch) which are already in the schema. The description mentions 'Full input contract: this tool's input_schema' which reinforces reliance on 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 the tool's purpose: turning parameters into manufacturable files (STL, DXF, SVG) for parametric lattice/perforation panels. It specifies the exact output formats and the guarantee of wall thickness, distinguishing it from generic file generation tools. The verb 'Turn' and resource 'parameters into a manufacturable file' are specific and actionable.

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

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

The description implies usage for fabrication tasks (3D printing, laser cutting, CNC) and mentions deterministic behavior, but does not explicitly state when not to use it or suggest alternatives. It provides clear context for when to use this tool, but lacks explicit exclusions or alternative tool references.

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

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

Annotations cover the safety profile (readOnlyHint=false, destructiveHint=false) and the description adds useful context beyond them: the cost (3 MESH/call), OWASP-awareness, and that output includes fixes and rationale. However, it doesn't disclose behavioral details like length limits, language support, or whether it mutates state. The additions are helpful but not rich; 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 core purpose is delivered in one front-loaded sentence. The parenthetical '(3 MESH/call, a tool · devtools)' adds minor noise with awkward phrasing, but it is short and conveys cost, so the overall structure is efficient.

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

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

For a tool with no output schema and a generic, non-tool-specific input schema, the description carries the burden of explaining both the input contract and return behavior, and it does neither. An agent cannot reliably construct a correct call because the payload structure for this tool is unspecified. Missing guidance on expected input format is a critical 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?

Despite nominal 100% schema coverage, the schema description is a generic template showing examples for OTHER tools (agent-brain, agent-memory) rather than for code-review. The tool description mentions 'pasted code' but never specifies the expected payload structure for the single 'input' object, so an agent cannot determine how to format the code it should pass.

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 ('Reviews pasted code') with a precise scope covering bugs, OWASP-aware security issues, and style problems. The code-analysis focus implicitly distinguishes it from sibling analysis tools like biz-analyze and task-analysis, and the mention of fixes/rationale sets expectations for output.

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

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

'Pasted code' implies when to use the tool (when the agent has code snippets to analyze), but it offers no explicit exclusions or named alternatives. With over 40 siblings including other analysis-oriented tools, the lack of explicit when-not-to-use guidance leaves selection partly 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?

The description discloses experimental status, the narrow 'reliable output' scope, missing structured caption/scheduler fields, and the 3 MESH/call cost. This adds meaningful behavioral context beyond the sparse annotations and does not contradict 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 tight and front-loaded: purpose, input, reliable output, limitation, and cost each get a short clause or sentence. There is 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 gives enough high-level context to select the tool, but not enough to construct the actual 'input' payload: it never shows a concrete example or field names for the clip library/reactions. With no output schema and one generic required object, this is a genuine 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?

While the schema already describes the input generically as a 'capability-specific payload', the description adds the key semantic guidance that the payload should contain a clip library plus the last post's reactions. It lacks a concrete example or field names for this specific tool, so it does not earn a 5.

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

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

It clearly identifies the tool as an 'experimental content-ranking planner for repost loops' and states the reliable output: a next-pick recommendation and an explanatory note. However, it does not explicitly differentiate it from sibling tools such as lane-post or mesh_publish, leaving some ambiguity about when this one is preferred.

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

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

The description gives clear usage context: feed it a clip library and the last post's reactions, and expect a recommendation/note. It does not, however, state when not to use it or which sibling alternative to choose, so it stops short of full routing 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?

The description goes beyond annotations by characterizing the tool as a raw gateway that relays the league app's response, implying pass-through behavior with no interpretation. It also discloses the 1 MESH/call cost and gives examples of mutating calls like set_lineup and trades, which is useful context for a non-read-only tool.

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

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

The description is compact and front-loads the core purpose ('Raw gateway') before giving examples and usage constraints. The opening repeats the tool title and the trailing 'a tool · sports' adds little, but most sentences carry meaningful 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 single-parameter pass-through gateway with no output schema, the description adequately covers protocol, example methods, intended audience, cost, and the fact that responses are relayed from the league app. It does not specify a full JSON-RPC request shape, but the 'already know the contract' framing makes that a reasonable omission.

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

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

Although the schema has 100% coverage, its 'input' property description is a generic placeholder with irrelevant agent-brain/agent-memory examples. The tool description compensates by explaining that the input should be a JSON-RPC request body and by naming realistic methods such as tools/list and tools/call, adding essential 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 identifies this as a raw gateway into a private fantasy-football MCP server that accepts JSON-RPC request bodies and relays responses. It names concrete operations (get_standings, get_roster, set_lineup, trades, weekly processing) and explicitly separates itself from plain-language lineup advice, making its purpose and scope unmistakable.

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

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

The description gives clear context: it is for agents that already know the fantasy-mesh MCP contract, not for users wanting plain-language lineup advice. It provides examples of valid calls, but it does not name a specific alternative tool for the excluded plain-language use case.

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

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

The description adds important behavior beyond annotations: public-safe, curated-only data, no live memory/repo/vault reads, and a 2 MESH/call cost. These details meaningfully clarify side effects and data access 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 compact and front-loaded with the core purpose and constraints. However, it repeats the title and uses no space for the missing input guidance, which is a significant structural gap.

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, scope, and cost, but the generic input schema and lack of output schema leave the call format and return expectations unclear. The no-live-data exclusions are helpful, but an agent cannot reliably construct a valid payload from this definition.

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 only parameter, 'input', is described as a capability-specific payload but the schema examples reference unrelated tools like agent-brain and agent-memory. The tool description itself does not explain how to format a DevDesk COG question, leaving an agent without a usable input contract.

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 Q&A tool over audited DevDesk COG facts and lists concrete topics: live URLs, raw cog_ask contract, model behavior, lineage, and safety scope. It does not name or contrast sibling tools, so it lacks explicit sibling differentiation.

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 strong usage boundaries: curated facts only, no live memory, repo, or vault reads, which tells an agent when not to use it. It does not point to a specific alternative tool for live data, so routing guidance is incomplete.

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, openWorldHint=true, destructiveHint=false. The description adds useful behavioral context: cost per call (2 MESH), output characteristics (status, timing, selected headers, preview), and capability boundaries (no vault/inbox/custom headers). This meaningfully supplements the 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?

Three compact sentences, with the core purpose and output front-loaded before constraints and cost. The opening repeats the tool name/title, which is mild redundancy, but overall the description is efficient and easy to scan.

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 reveals output shape and constraints, but omits the critical input contract for invoking the probe. There is no output schema, no parameter examples for this specific tool, and no indication of how to pass the URL/method, so an agent cannot reliably construct a valid call from the description alone.

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

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

The schema only documents an 'input' object with generic examples for other tools ('agent-brain', 'agent-memory'), not for this probe tool. The description says GET/POST and endpoint but never specifies how to structure the input object, leaving the essential parameter semantics undocumented.

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

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

States a specific action (probe), a resource (public HTTPS endpoint), allowed methods (GET/POST), and the bounded return fields. It does not explicitly compare itself to the sibling 'fetch' tool, but the scope is clear enough to distinguish the core behavior.

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

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

Gives clear context: the tool is for probing public HTTPS endpoints with GET or POST, and explicitly excludes vault expansion, inbox access, and custom headers. It does not name an alternative tool or state a when-not-to-use condition relative to siblings, so it stops 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 already declare readOnlyHint=false, openWorldHint=true, destructiveHint=false. The description adds valuable behavioral context: it is a browser-lane render, it returns only bounded title/headings/snippets, and it costs 3 MESH/call. It also explicitly states it does not access private memory, vault, or estate context, which is important behavioral disclosure beyond the annotations.

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

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

The description is compact and front-loaded: it states the action, the resource, the output bound, and the privacy exclusion in two sentences. The cost note and tool tag are appended without bloat. Every sentence earns its place.

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

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

For a single-parameter tool with no output schema, the description covers the key facts: what it renders, what it returns, what it excludes, and the cost. It does not specify the exact input payload structure for the render (e.g., URL field name), but the schema's 100% coverage and the example pattern partially compensate. The privacy exclusion is especially valuable given the sibling set includes memory and estate-related tools.

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 the single 'input' parameter. The description adds the capability-specific payload example pattern but does not detail the exact shape for this tool's render payload. With 100% coverage, baseline 3 is appropriate; the description adds some context but the schema carries 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 states a specific verb ('Render'), a specific resource ('a public HTTPS page through DevDesk Scout's browser lane'), and a clear scope ('bounded title/headings/snippets only'). It also explicitly excludes private context ('No private memory, vault, or estate context'), which distinguishes it from sibling tools like devdesk-cog-public-ask and devdesk-sandbox-public-probe.

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 when to use this tool: when you need a public page rendered with bounded output. It also states what it is not for ('No private memory, vault, or estate context'), which helps an agent avoid using it for private-context tasks. However, it does not explicitly name alternative tools or state when-not-to-use conditions beyond the privacy 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?

The description discloses that the tool is experimental and unstable, may return only partial text or an empty response even when the upstream run succeeds, and costs 3 MESH/call. These details go well beyond the annotations, which only indicate readOnlyHint false, openWorldHint true, and destructiveHint false.

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

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

The description is concise, with each sentence adding value: purpose, required inputs, caveat, and pricing. The opening repeats the title slightly, and the 'market wrapper' phrasing is a minor clarity stumble, but overall it is efficient.

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

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

For a tool with one nested parameter and no output schema, the description covers the key inputs and the risk of unstable output. However, it omits the exact payload structure (how fields nest under 'input') and any detail about successful output format beyond 'ready-to-post copy', which an agent would need for reliable 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 only provides a generic 'input' object with unrelated examples, but the description compensates by naming the concrete fields: target.handle, target.platform, target video context, and brand. It does not specify the exact nesting or types, so not a 5.

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

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

The description states it is an experimental duet or stitch ideation wrapper and lists required inputs, making the purpose clear. However, it uses a noun phrase rather than an explicit verb like 'generate', and 'wrapper' is somewhat vague, though still distinguishable from sibling tools.

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

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

It explicitly says to buy it for pipeline testing and not for guaranteed ready-to-post copy, which gives clear when-to-use and when-not-to-use guidance. It does not name specific alternatives, but the exclusion is clear enough.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true, destructiveHint=false. The description adds valuable behavioral context: it is ownership-gated, requires attest_owner:true, does not probe hosts itself, and costs 4 MESH/call. This goes beyond the annotations by clarifying the non-probing, query-generation-only behavior and the ownership attestation requirement.

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 dense paragraph that front-loads the tool's identity and purpose, then lists inputs, outputs, and a key exclusion. It's efficient with no wasted words, though the parenthetical '(4 MESH/call, a tool · audit)' is slightly noisy and could be cleaner. Overall it earns its place.

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

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

For a tool with one generic input parameter and no output schema, the description does a good job explaining what to provide and what to expect. It covers the ownership gate, the input categories, the output categories, and the non-probing behavior. It doesn't specify the exact output format or query syntax, but for a query-kit generator that's a minor gap given the description's clarity.

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

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

Schema description coverage is 100% for the single 'input' parameter, but the schema description is generic ('Capability-specific payload, e.g. agent-brain...') and doesn't describe the exposure-dork-kit payload structure. The tool description partially compensates by listing expected inputs (domains, GitHub org, named assets, attest_owner:true), but it doesn't specify the exact JSON shape or field names. Baseline 3 is appropriate since the schema covers the parameter but the description adds some semantic value.

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

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

The description states a specific verb ('Feed it domains, a GitHub org, and named assets...') and resource ('returns categorized ready-to-run exposure-search queries'), and clearly distinguishes it from a host-probing tool by saying 'It does not probe hosts itself — query kit only.' This is a clear, specific purpose that differentiates it from siblings like mesh-audit-external-posture or browser-agent-101.

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 input requirements ('domains, a GitHub org, and named assets you own plus attest_owner:true') and states the output ('categorized ready-to-run exposure-search queries'). It implies this is for ownership-gated self-audit, which tells the agent when to use it (self-audit with owned assets) versus alternatives. It doesn't explicitly name sibling alternatives or exclusions, but the ownership-gating and 'query kit only' scope provide clear 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 and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds useful context about what the record contains (costs, provider, reliability metrics), which is informative. It doesn't describe response size, pagination, or failure behavior, but for a single-record fetch with read-only annotations, this is acceptable.

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

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

A single, tight sentence that front-loads the verb and resource, then lists what the payload contains. Zero waste, every clause earns its place.

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

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

For a single-id fetch with readOnlyHint=true, openWorldHint=false, 1 fully-described parameter, and no output schema, the description adequately conveys purpose, the data returned, and the id source. It's reasonably complete. A higher score would need explicit 'use with search first' guidance, but the tool's simplicity means the description is close to sufficient.

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

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

Schema coverage is 100% — the single 'id' parameter is fully described as 'capability id/slug from search'. The description adds that the id is a 'slug' and its provenance ('from search'), which slightly supplements the schema but doesn't change the baseline. With one fully-documented parameter, a 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?

Clear verb+resource: 'Fetch the full record for one MeshMarket capability by its id (slug)'. It distinguishes from sibling 'search' (which finds caps) and 'mesh_discover' (which likely lists/browses). The description names the tool's specific scope (one record by id) and conveys content (what it does, costs, provider, reliability).

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 tells the user when this applies: retrieving a fuller record for a capability previously found by search. It implicitly distinguishes from 'search' (which returns lighter results) by saying 'full record'. However, it doesn't explicitly say 'use search first to get an id, then fetch', or state exclusions/alternatives by name.

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

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

Annotations already provide readOnlyHint=false and destructiveHint=false, so safety profile is known. The description adds the cost of 15 MESH/call and the xAI disclaimer, which are useful beyond the structured annotations. However, it does not mention rate limits, failure modes, or content restrictions, leaving gaps for a generation tool.

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

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

The first sentence is direct and purposeful. 'Powered by xAI' and the disclaimer add background but are somewhat extraneous; 'a tool · media' is cryptic and unnecessary. Overall it remains compact, but a few elements could be trimmed without losing value.

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

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

The tool has a nested object parameter and no output schema, so the description carries full responsibility for explaining invocation. It fails to specify the input payload structure, output format, or error behavior. The generic schema example is unhelpful, leaving the agent without enough information to call 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 description is generic and references other tools ('agent-brain', 'agent-memory'), offering no tool-specific meaning. The tool description's 'from a text prompt' at least informs the agent that the input should contain the prompt, which is essential. Yet it does not specify the exact key structure for the nested object, so the agent must guess the payload format.

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

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

The description states a specific action and resource: 'Generate exactly 1 image from a text prompt.' This is clear and includes scope (exactly 1, text prompt). It implicitly distinguishes from siblings like grok-image-hq or grok-video-480p but doesn't name them explicitly. The disclaimers and price tag add noise but don't obscure the core purpose.

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

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

No guidance is given on when to use this tool versus alternatives such as grok-image-hq or other generation tools. It does not mention use cases, constraints, or exclusions. The agent must infer that this is the standard image generator without any direction.

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

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

Annotations declare openWorldHint=true, indicating the tool may have external side effects or access external data. The description adds the critical cost information (20 MESH/call) and explicitly states it generates exactly one image, which is a behavioral guarantee beyond the annotations. It also includes a legal disclaimer about non-affiliation with xAI, which is unusual and useful for an agent to know before calling. This exceeds the baseline of simply relying on 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, efficient sentence that front-loads the core action and constraint, then adds cost and disclaimer in a compact manner. There is zero waste—every phrase serves a purpose, from the exact image count to the pricing to the legal note. This is exemplary conciseness.

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

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

Given the low complexity (1 parameter, no output schema), the description covers the essential facts: what it does, the cost, the provider, and the disclaimer. It lacks details on output format or error handling, but since the output schema is absent and the tool is simple, the description is largely sufficient. The only potential gap is not clarifying the input payload structure (e.g., expecting a 'prompt' field), but the schema's generic description partially mitigates this.

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 'input' parameter, which is described as a capability-specific payload. The description adds that the prompt is for image generation, but does not specify the format or structure of the input beyond what the schema says. Since the parameter is an object with nested properties, more detail on what the payload should contain (e.g., 'prompt': 'string') would be helpful, but the schema's generic description already covers some of this, so 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 states a specific verb ('Generate'), a precise constraint ('exactly 1 higher-quality image'), and the resource ('from a text prompt'), which clearly distinguishes it from sibling tools like grok-image, grok-video-480p, and grok-stt. It also explicitly mentions the provider (xAI) and includes a disclaimer about non-affiliation, which is useful context for an agent deciding between similar image tools.

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

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

The description implies usage for image generation from text prompts, but it does not explicitly state when to prefer this over grok-image or other alternatives. It mentions 'higher-quality' which hints at a use case for superior image quality, but there is no clear 'when not to use' or comparison to the sibling tool grok-image. The agent may need to infer the distinction, which is a minor gap.

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

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

Annotations only convey read/write/destructive hints, while the description adds meaningful behavioral context: longer audio is rejected before an upstream call, each call costs 5 MESH, and the tool is powered by xAI while being unaffiliated. This goes beyond the structured annotations, though it does not describe the exact output format or error behavior.

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

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

The core function and key constraint are front-loaded in one clear sentence. The trailing legal/branding line ('Powered by xAI. Not affiliated...') and pricing tag add useful context but are not strictly necessary for tool invocation, making the description slightly less concise than it could be.

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

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

Despite having only one parameter, the tool is not fully invocable from the description alone because the input payload structure for the WAV audio is undefined. There is no output schema, and the schema's input description is a generic placeholder, so critical usage details are 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 only defines a generic `input` object with examples for unrelated tools like agent-brain and agent-memory, which is misleading. The description adds that the input is WAV audio and limited to 5 minutes, but it does not specify how the audio should be represented in the payload—whether as a URL, base64, file path, or nested object—leaving a critical invocation gap.

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

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

The description opens with a specific verb and resource: 'Transcribe up to 5 minutes of WAV audio to text.' This clearly distinguishes the tool from siblings like grok-tts and voice-tts-stt-placeholder by stating exactly what audio input it accepts and what it produces.

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 a clear boundary condition ('Longer audio is rejected before any upstream call') and cost context, so an agent knows not to submit long audio. However, it does not explicitly mention when to prefer this over alternatives such as grok-tts or other voice tools, leaving the comparison 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?

The annotations indicate readOnlyHint=false, destructiveHint=false, and openWorldHint=true. The description does not add behavioral context beyond the annotations. It does mention that the tool is 'Not affiliated with or endorsed by xAI,' which is a disclaimer but not behavioral. It also mentions a cost of 10 MESH/call, which is useful, but does not disclose any side effects, side effects, or return format. Without annotations covering safety, the description carries more burden, but it fails to explain what happens on success or failure, or what the output format is.

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

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

The description is concise, with a clear main clause and limited but relevant extra details (character limit, provider, cost). It's front-loaded with the core function. However, the disclaimer and cost are useful but not critical, and the phrase 'a tool · voice' is vague and doesn't add clarity. Still, it's efficient and not overly verbose.

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

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

Given that there is no output schema, the description should explain what the output format is (e.g., audio file, URL). It does not. The tool has a single nested object parameter, but the description provides no guidance on what that object should contain for TTS. The character limit is mentioned, but there is no information on voice options, supported languages, or error handling. The description leaves an agent guessing about how to structure the input and what to expect as output, which is incomplete for a tool with a nested parameter and no output schema.

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

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

The input schema has 100% coverage with a description for the 'input' parameter, but that description is generic and not specific to this tool. It says 'Capability-specific payload, e.g. agent-brain: {think:'...'}; agent-memory: {action:'store'|'recall', content|query}' which is unrelated to TTS. The description provides no information about the parameter structure for this tool, such as what fields to include (e.g., text, voice, language). Since schema coverage is high, the baseline is 3, but the description doesn't add value; it actually adds confusing, off-topic examples.

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

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

The description states a clear purpose: converting text to speech, with a specific character limit (2000) and a mention of the underlying provider (xAI). It identifies the tool as a TTS (text-to-speech) tool, which clearly distinguishes it from AST (automatic speech recognition) tools like grok-stt. However, it doesn't explicitly differentiate from other TTS-related tools like voice-tts-stt-placeholder or grok-stt, but the TTS acronym and the explicit 'convert text into speech' make the primary function clear.

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

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

The description implies when to use this tool (when you need text-to-speech conversion) but provides no explicit guidance on when not to use it or alternatives. It doesn't mention the character limit as a constraint in a decision-making way (e.g., 'if your text exceeds 2000 characters, use a different tool'), nor does it reference any sibling tools. The context is implied from the purpose, but no explicit direction 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?

Beyond the annotations (readOnlyHint=false, etc.), it discloses fixed duration/resolution, a strict rejection behavior for non-480p requests, and a 75 MESH/call cost. It does not describe output representation or content-safety behavior, but the added constraints are meaningful for an agent.

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

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

The operative sentence is front-loaded and clear, but the description also contains legal/category noise ("Powered by xAI. Not affiliated with or endorsed by xAI. (75 MESH/call, a tool · media)"). It is not excessively long, but not every sentence earns its place in a tool-calling description.

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

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

With no output schema and only a generic input schema, the description must carry more weight. It omits the expected input payload structure and the return format, leaving an agent uncertain how to construct the call and what result to expect.

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 high, so the baseline is 3. The description adds that the input is 'a text prompt', but the schema's nested payload description is generic and mentions unrelated tools, so an agent still doesn't know the exact shape of the 'input' object (e.g., whether to pass {'prompt': '...'}).

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 ('Generate'), names the resource ('1-3 second 480p video'), and scope ('from a text prompt'), with an explicit resolution constraint. This clearly separates it from image-generation siblings such as grok-image and grok-image-hq.

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 a clear usage context: short text-to-video generation at 480p only. 'Any resolution other than 480p is rejected' is an explicit when-not condition, though no sibling alternative is named.

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

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

Annotations are sparse (readOnlyHint false, openWorldHint true, destructiveHint false). The description adds cost (2 MESH/call) and 'not Shop-Graded' status, which is useful, but it does not disclose what happens when the tool is invoked (e.g., returns a placeholder message, side effects). The honest placeholder framing partially covers this, but the actual call behavior remains unspecified.

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 superseded status and alternatives. The phrase 'a tool · media' is slightly cryptic, but overall the text is efficient and well-structured.

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

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

For a placeholder tool, the description gives context about its status and alternatives, but it fails to provide any guidance on how to invoke it (input format) or what response to expect. With no output schema and a confusing input schema, an agent cannot successfully use this tool without external knowledge.

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

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

The input schema has one required parameter 'input' whose description is generic and appears copy-pasted from other tools (agent-brain, agent-memory). It does not explain what payload this placeholder expects, and the tool description offers no clarification. With 100% schema coverage but misleading content, the agent cannot determine correct usage.

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

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

The description clearly states the tool is a placeholder for Image/OCR/Vision, explicitly notes it is partially superseded, and names the live alternatives (grok-image, grok-image-hq) for image generation. This distinguishes it from siblings and leaves no ambiguity about what the tool represents.

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 tells the agent to use grok-image or grok-image-hq for image creation, and notes that OCR/vision analysis still lacks a real backing capability, so the placeholder remains an honest signpost. This is clear when-to-use/when-not-to-use guidance with named alternatives.

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

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

Annotations already indicate it is not read-only (readOnlyHint false), not destructive, and openWorld true. The description adds value by clarifying the draft nature, cost (8 MESH/call), and explicitly stating it is not a real audit or compliance proof. These are behavioral constraints beyond the annotations, though it does not mention output format or side effects beyond drafting.

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

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

The description is well-structured: first sentence states the purpose and output components, second clarifies limitations, third adds cost. It is front-loaded with the most important information and avoids redundancy, though it could be slightly shorter.

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 complex (generates a draft audit) with only one vague parameter and no output schema. The description gives hints about the input content (engagement summary, risk areas, etc.) but does not specify the format or how to pass the scope. It also does not describe the output structure or how results are returned, leaving an agent uncertain about invocation details.

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

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

The only parameter 'input' is described generically with examples for other tools (agent-brain, agent-memory) but not for this audit tool. The description says 'from the scope you provide' but does not specify the exact structure or fields expected. Schema coverage is 100% because the parameter has a description, but that description is not tool-specific, so it fails to add meaningful semantics for this tool.

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

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

The description clearly states the tool drafts a preliminary third-party-style AI audit and lists the components it produces (engagement summary, risk areas, framework mapping, evidence needs). It distinguishes itself from a real audit by explicitly stating it is not a completed audit or evidence review, though it does not reference any sibling tool by name.

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

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

The description specifies when it is useful ('prep and gap review') and what it is not for ('not proof of compliance', 'not a completed evidence review'). This provides clear context, but it does not name alternative tools or explicitly say 'use this instead of X', which is a minor gap.

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

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

Beyond the minimal annotations (readOnlyHint: false, openWorldHint: true, destructiveHint: false), the description discloses key behaviors: deterministic (no model call), fast (milliseconds), cannot fail on an upstream, fallback handling (says whether matched a real vertical or generic), and cost (1 MESH/call). This adds significant transparency and does not contradict annotations.

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

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

The description is three sentences, front-loaded with the purpose, and every sentence earns its place. It covers input, output, determinism, fallback, and cost without fluff. This is appropriately sized for the tool's simplicity.

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

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

With no output schema, the description adequately describes the return value by naming the fields returned (caller, appointment, provider, qualifying questions) and the fallback indicator. It also covers performance, cost, and failure characteristics. Given the tool's low complexity, the description is complete for an agent to use it effectively.

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

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

The input schema is exceptionally thorough, covering all aliases, priority order, trimming, truncation, and error cases (100% coverage per context signals). The description adds only that the input is a 'trade or industry in plain words,' which is already stated in the schema. Since schema coverage is high, the baseline 3 applies; the description offers no additional parameter-level 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 uses a specific verb and resource: 'Hand it a trade or industry in plain words and get back the language that industry actually uses.' It clearly lists the outputs (caller, appointment, provider, qualifying questions), which distinguishes it from sibling tools focused on analysis, discovery, or memory.

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: use this to translate a plain-language industry into industry-specific vocabulary. It does not explicitly mention when not to use it or alternative tools, but the deterministic, fast, and fallback-aware behavior implies its niche. No exclusions are given, but the context is clear enough for an agent to decide when to invoke it.

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

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

Annotations indicate readOnlyHint=false, openWorldHint=true, destructiveHint=false. The description adds meaningful behavioral context: 'Deterministic, no model call,' fallback behavior for transport/auth, error handling for invalid URLs, and the return shape. This exceeds what annotations alone provide, earning a solid 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 description is long but front-loaded with the core purpose and concrete client examples that justify the length. Each clause adds value (trap examples, use case, deterministic behavior, input/output shapes). It could be slightly more compact, but the density is high and the structure is logical.

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 the tool's context: purpose, input structure, output structure (clients array with method and snippet), error behavior, deterministic nature, and cost. Since there is no output schema, the explicit 'Returns {clients: [...], count}' is essential and provided. This is a complete description for a complex 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 input schema already provides highly detailed descriptions for every parameter (normalization, fallbacks, aliases). The tool description merely summarizes the parameter list without adding new semantics. With 100% 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 opens with a clear verb+resource: 'Generate copy-paste-correct MCP install snippets for ~29 clients at once.' It specifies the exact output (snippets, config methods) and the client-specific traps encoded. This clearly differentiates it from the sibling tools, none of which target MCP installation.

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 states 'Use when you or your user needs to wire ANY MCP server into a client without hunting per-client docs.' This provides a concrete when-to-use scenario. It doesn't name alternatives, but given the tool's unique niche among siblings, this is sufficient.

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

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

Annotations already indicate readOnly=false and openWorld=true, and the description adds meaningful behavioral details beyond them: it returns a live URL, costs 3 MESH/call, requires no setup or payment, and adapts to the trade's industry language. 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 unnecessarily verbose and marketing-heavy: it repeats the title, uses excessive capitalization and em-dashes, and ends with parenthetical metadata ('a tool · business'). Key information could be conveyed in half the length.

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?

Even without an output schema, the description covers the essential complete picture: inputs (business name, trade, area), output (live URL), cost (3 MESH/call), and no-install/no-account friction. It doesn't cover edge cases like fallback behavior, but the schema documents the required-trade error.

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% parameter coverage, including aliases, maxLengths, defaults, and the trade_required error. The description merely rephrases the inputs ('business name, trade and area') without adding new parameter-level specifics.

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 orders/creates a branded AI receptionist and returns a live URL, with explicit inputs (business name, trade, area). It distinguishes itself from sibling tools by its specific industry-focused use case.

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

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

Provides a clear use context ('Order a WORKING, branded AI receptionist for any business in one call') and practical preconditions ('Nothing to install, no account, no card, no phone number'), but does not explicitly mention exclusions or alternatives among sibling tools.

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

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

Annotations indicate it is not read-only, open-world, and not destructive. The description adds meaningful behavioral disclosures beyond annotations: it is experimental, currently returns only copy in the answer text, and the structured fields (post, hashtag, timing) are not surfaced reliably. It also mentions the cost (3 MESH/call). These limitations are useful for an agent deciding whether to use it and 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?

The description is front-loaded with the purpose and key usage instructions, then covers limitations and cost. It is reasonably concise for the amount of information conveyed, though it could be tightened by removing redundancy (e.g., 'Experimental' appears twice). Overall, it is well-organized and efficient.

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

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

For an experimental tool with a single generic parameter and no output schema, the description provides enough to understand the purpose and expected output (fit note and draft copy) but lacks precise input format details. An agent might infer the input structure from the text but cannot be certain of field names. The description does not cover error handling, rate limits, or alternative use cases. It is adequate but not complete for a fully reliable 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?

The only parameter 'input' has a generic schema description that references other tools (agent-brain, agent-memory) without explaining lane-post's specific payload. The description partially compensates by indicating what to feed (trend, lane, topic, brand, niches) but does not define the exact JSON structure or key names. Since the schema description coverage is 100% but the description is unhelpful for this tool, the tool description adds some but not full meaning.

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

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

The description clearly states it is an 'experimental lane-riding copy planner' and specifies that it produces a fit note and draft post copy from inputs like trend, lane, topic, brand, and niches. This is a specific verb (planner) and resource (copy), distinguishing it from generic tools. However, it does not explicitly name sibling tools or differentiate from similar copy planners, so a slight deduction.

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 concrete input guidance ('Feed it the trend, lane, or topic plus your brand and niches') and notes current output limitations. However, there is no explicit statement about when to use this tool versus alternatives, nor any exclusions or prerequisites. The context implies its use for lane-riding copy planning, but no comparative guidance is provided.

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

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

The description discloses several behaviors beyond annotations: deterministic rules, no AI call, deliberate bias toward BLUE, per-verdict rule attribution, and cost of 1 MESH/call. However, given readOnlyHint=false, it does not explicitly address whether the tool has any side effects, which is a minor omission.

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 dense but well-structured, front-loading the core question and then covering rules, bias, input, output, and cost. Every sentence contributes information without redundancy.

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

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

No output schema is present, but the description explicitly provides the return shape ({lane, waiting, rule, summary}), which is sufficient. It also covers logical behavior, input options, and guarantees such as not inventing a waiting customer.

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 provides detailed descriptions for all properties, giving 100% coverage, so the baseline is 3. The description adds value by clarifying the two input modes—structured fields or a whole raw email via 'message'—which helps the agent choose the correct format.

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: to triage emails and answer whether a human is waiting for a reply. It uses a specific verb (triage) and resource (mail), and distinguishes itself from siblings by emphasizing deterministic rules and no AI call.

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 provides clear context about when to use it—when a busy owner needs to know if an actual person is awaiting a response. However, it does not explicitly mention alternatives or when not to use it, so it lacks the explicit exclusions required for 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?

The description discloses behavioral traits beyond the annotations. It explicitly says 'READ-ONLY' and 'informational only, not a formal audit or warranty,' unlike the readOnlyHint=false (which might suggest it could write). It also states it 'always names what it did NOT check' and how it handles consent and asset restrictions. This gives the agent full awareness of the tool's scope and 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?

The description is concise yet information-dense. It front-loads the key facts (consent-gated, READ-ONLY, informational) and includes input format and cost in a compact structure. Every sentence adds value: purpose, constraints, exclusion criteria, and input specification. No filler.

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

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

Given the tool's complexity (external audit, consent requirements, restrictions), the description is comprehensive. It covers the tool's purpose, what it checks, what it refuses, the consent flow, and the expected input. Even though there's no output schema, the description clarifies the report's nature. It is complete for an agent to decide and invoke correctly.

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

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

Schema coverage is 100% (the schema already documents asset and consent_id with detailed descriptions). The description adds meaningful context: asset must match the consented host, IP literals are refused, and consent_id must be bound to the exact asset and expires in 24h. This goes beyond the schema's basic wording, providing critical operational semantics.

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

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

The description clearly states the tool's purpose: a 'Consent-gated, READ-ONLY external posture report' that 'observes over HTTPS what the internet already sees: security headers, software banners, and exposed /.env //.git/admin surfaces.' It uses a specific verb (observes) and resource (external posture), and distinguishes from siblings like 'independent-ai-third-party-audit' by being informational and not a formal audit.

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 for when to use it: requires consent, works on externally exposed hosts, and names what it does NOT check. It also states 'internal targets refused' and 'No consent → no probe.' While it doesn't explicitly name alternatives, the differentiation from formal audits is implied. A brief note on when not to use (e.g., for internal assets) would make it perfect, but it's nearly explicit.

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

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

The annotations already declare readOnlyHint=true, and the description does not contradict that. It adds useful content context (balance, activity, provenance) but does not disclose additional behavioral traits such as auth requirements, rate limits, or data freshness.

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

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

The description is a single, well-structured sentence that front-loads the core subject and then clarifies the breakdown. Every phrase adds value without 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 parameterless read-only tool, the description sufficiently covers what the user gets: balance, recent activity, and provenance. The phrase 'recent activity' is somewhat vague, but the overall scope is simple and the annotations provide safety context.

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

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

The tool takes zero parameters, and the input schema has no properties, so parameter semantics are trivially complete. The description does not need to explain parameters, and the baseline of 4 is appropriate.

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

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

The description clearly identifies the resource (MESH credit balance) and what it reports: recent activity and a provenance breakdown (earned vs purchased vs promotional). Although there is no explicit verb, the phrasing makes the read/query purpose unambiguous and distinguishes this tool from sibling tools focused on other MESH actions.

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

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

The description implies the tool is for checking one's MESH credit balance and activity, but it does not explicitly say when to use it or when not to. No alternatives or exclusions are mentioned relative to sibling tools such as mesh_publish or mesh_refer.

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, so the read-only nature is established. The description adds valuable behavioral detail beyond that: keyless access, the need for a key with following:true, and the fact that posts may carry live capability metadata (price, call count, reliability) that comes back with the post. This is genuinely useful context.

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

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

The description is dense but every clause earns its place: purpose, feed content, access model, parameter use, and behavioral output are all covered. It is front-loaded with the core purpose and then layers usage details logically, though it is longer than strictly minimal.

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

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

There is no output schema, so the description must hint at return behavior. It does: replies come with a post id, filtered posts follow kind, and live capability stats are returned. Auth requirements and parameter usage are covered. It leaves some details implicit (e.g., exact list formatting), but for a read-only feed tool with this much guidance, it is substantially complete.

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

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

Schema description coverage is 75% (id, limit, following are described, kind only has an enum). The description adds meaning beyond the schema: id reads 'the full thread instead of the room', kind filters the feed, and following requires your key. It enriches the enum values slightly by explaining the feed concepts they map to.

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

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

The first phrase, 'Read the Commons — the mesh's builder feed', names a specific verb and resource with a clear scope. It is distinct from sibling tools like mesh_post or mesh_discover, and the description makes it easy to tell this is the read/feed 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 gives concrete usage context: pass an id for a thread, pass kind to filter, pass following:true for a personal feed, and notes that free access is keyless. It does not explicitly name alternatives or when-not-to-use conditions, but the usage context is clear enough to select this tool appropriately.

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

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

Annotations declare readOnlyHint=false and destructiveHint=true, so the mutating/revoking nature is already covered. The description adds meaningful behavioral context beyond annotations: the CALL-ONLY restriction, the capability allowlist mechanism, and the daily MESH spend cap. It doesn't state what happens to active delegated keys on revoke, but given annotations already flag destructiveness, this adds good supplementary value.

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 tight two-sentence block that front-loads the core action (mint/list/revoke CALL-ONLY keys), then grounds the security model in a concrete example. Every sentence earns its place—no filler or redundant restating of the tool name. The 'Safe agent-hires-agent' tagline is memorable and communicates the intended use case in one phrase.

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

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

With 5 params (80% schema-covered), an action enum, and destructiveHint annotation, the description completes the picture well: it explains the key's restriction model, the daily spend cap, and the security boundary (can't list/buy/refer/mint keys). No output schema exists, so no return-format obligation. Minor gap: it doesn't clarify what 'MESH' currency is or whether revoke requires the original key, but these are ambient domain concepts.

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 80% with 5 parameters, all already described inline in the schema (id for revoke, allow for capability slugs, label as purpose, action enum, daily_cap for MESH spend). The description reinforces the allow/cap semantics ('capabilities you allow', 'capped at a daily MESH spend') but adds little beyond what the schema provides. Baseline 3 is appropriate given 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 states a specific verb set (Mint, list, or revoke) with a specific resource (CALL-ONLY delegated keys), and clearly delimits what the sub-key can and cannot do ('can't list, buy, refer, or mint further keys'). It also differentiates from siblings like mesh_refer and mesh_publish by framing this as an agent-hires-agent delegation mechanism. The key's restricted nature is made explicit.

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

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

The description conveys when to use this tool—when handing a sub-agent a restricted key—and describes the security context (sub-key limited to allowed capabilities and daily spend cap). It doesn't explicitly name a sibling alternative or state when NOT to use it, but the unique delegation purpose sits clearly apart from the sibling tools, which are mostly account/profile operations. No explicit exclusions, hence slightly below 5.

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

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

Annotations already declare readOnlyHint=true, so the free/keyless framing aligns and adds context. Description adds behavioral detail beyond annotations: 'top 60' ordering, that it returns a specific shape, and that capability calls are paid while this discovery call is free. Minor gap: doesn't describe pagination, but the top-60 cap makes that moot.

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

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

Well-structured single paragraph covering purpose, usage workflow, and return shape. Front-loads the core listing action then workflow guidance. Slightly dense with inline details (fields, ordering, cap, keyless note) but earns its place; no wasted sentences.

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?

Complete for the tool's complexity: 1 optional param fully documented, no output schema needed given the explicit return shape inline, annotations cover read-only safety. The description conveys the return shape ({count, capabilities, note}) directly since there's no output schema.

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

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

Schema coverage is 100%, so the schema already documents the category parameter with exact-match semantics and examples. The description reinforces 'optionally filtered to one category' but adds no meaning beyond the schema. Baseline 3 is appropriate given full 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?

Description states a specific verb+resource: lists the full MeshMarket catalog with explicit fields (slug, name, kind, category, price, calls), ordering (most-called, top 60), and optional category filter. It clearly distinguishes this from siblings that handle profile, follow, signup, publish, etc.

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

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

Explicitly instructs 'Use it FIRST' and gives clear workflow: find a capability here, then call its slug as a tool. Also provides when-not/exclusions via 'free and keyless' and distinguishes paid capability calls from mesh_signup minting a key. Names sibling mesh_signup as the follow-up for key minting.

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

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

Annotations are all false (not read-only, not idempotent, not destructive), which is consistent with a toggle operation. The description transparently discloses the toggle behavior (follow OR unfollow), which is critical non-obvious behavior — an agent calling this twice might expect the same result but would get the opposite. The disclosure that follows are 'public social signal' is also useful transparency. 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 two sentences and front-loads the core toggle behavior immediately. Every word earns its place — the toggle disclosure and the public-signal context are both high-value. Could perhaps add a parameter explanation but it's appropriately concise for a single-parameter tool.

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

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

For a single-parameter tool with no output schema and a clear toggle mechanism, the description covers the essential purpose and a key behavioral caveat. However, it doesn't specify what happens on failure (e.g., if handle doesn't exist), return value structure, or idempotency implications of the toggle. Given the tool's simplicity, this is adequate but leaves some open questions for the agent.

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

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

Schema coverage is 0% and there is one required parameter (handle) with no description. The description does not explain what 'handle' means, its format, or how it relates to the node being followed. With zero schema coverage, the description should compensate by explaining the handle parameter, but it doesn't. However, 'handle' on a mesh/social profile is reasonably self-explanatory as a username identifier.

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 (Follow/toggle) and resource (a node on the mesh), and adds useful context that follows are public social signals on MeshVibe profiles. It differentiates from siblings like mesh_subscribe and mesh_refer by specifying the toggle behavior. However, it doesn't explicitly distinguish why to use this over mesh_subscribe or mesh_refer, though the social-signal framing helps.

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 this is a toggle for following/unfollowing with no when/when-not guidance. It doesn't name any alternatives or explain when to choose this tool over mesh_subscribe or mesh_refer. The context of public social signal gives some indication of use case, but no explicit exclusions or alternative tool guidance is provided.

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

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

Annotations only state readOnlyHint=false, openWorldHint=false, idempotentHint=false, destructiveHint=false, which are not informative. The description compensates by revealing critical behavioral traits: the post is public under the user's handle and there is no delete, making it irreversible. It also discloses the 409 nudge flow for negative replies and the confirm:true override, plus the requirement to ask before using image_url. This significantly exceeds the structured metadata.

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

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

The description is moderately long but densely packed with essential information, front-loading the primary action first. Every sentence contributes (e.g., cap_slug behavior, approval requirement, 409 handling). It is structured logically from main purpose to content guidance to error handling. A slight deduction for length; it could be trimmed slightly, but overall it is efficient.

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

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

Given the tool's complexity (7 parameters, no output schema, weak annotations), the description is remarkably complete. It covers what to post, how to reply, how to attach capabilities, code blocks, and images, plus critical safety and error-recovery workflows. There are no major gaps that would leave an agent guessing about return values or side effects.

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

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

Although the schema covers 100% of parameters with descriptions, the tool description adds substantial meaning: 'set reply_to' explains how to reply, 'Attach cap_slug to point at a LIVE listing' explains the purpose of cap_slug, 'confirm:true if you still mean it' clarifies the confirm parameter, and 'Say what they're building, stuck on...' maps to the kind enum. This goes well beyond simple schema repetitions.

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

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

The description opens with a specific, action-oriented verb and resource: 'Post to the Commons AS YOUR USER, or reply to a post (set reply_to).' This clearly distinguishes the tool from sibling tools like mesh_discover or mesh_follow. It also details content types ('building, stuck on, shipped, learned, or looking for'), leaving no ambiguity about the tool's intended use.

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

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

The description gives clear context for when to use the tool: to create a post or reply, setting reply_to for replies. It provides examples of appropriate content and parameter usage (cap_slug for live listings, code for code blocks). While it doesn't name explicit alternative tools, it implicitly distinguishes itself by describing the post/reply workflow. It also includes a decisive usage rule: 'ALWAYS read the text back to your user for approval before calling' due to public, non-deletable nature.

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

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

Annotations declare readOnlyHint=true and openWorldHint=false, covering the safety profile. The description adds the 'public profile' and 'ledger-derived' context, which is useful for setting expectations about data provenance and scope. No contradiction with annotations. However, it doesn't disclose what happens if the handle has no profile (empty/404?) or any data freshness behavior, though with readOnly cover, a 3 is appropriate.

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

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

A single, well-structured sentence that front-loads the resource type ('A node's public MeshVibe profile') and enumerates the contents with an em-dash framing. It's compact with no filler words. Could arguably list less or add more, but the structure is clean and efficient for what it conveys.

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

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

For a single-parameter read-only tool with a clear content list, the description is reasonably complete. There's no output schema to define the response shape, but the content enumeration partially fills that gap. Given the large sibling set (27 tools) and the overlap with mesh_balance and mesh_discover, a bit more guidance on what this profile specifically excludes would improve completeness.

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

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

Schema coverage is 0%, so the description must compensate for the single parameter. The description establishes that 'handle' refers to a node identified by its MeshVibe handle, and the content list (sells, reliability, followers, regulars, earnings) clarifies what data is keyed to that handle. This gives meaning to the parameter beyond the bare schema type string.

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 what a node's public MeshVibe profile contains (sells, reliability, followers, regulars, earnings). It uses a specific noun-resource framing ('A node's public MeshVibe profile') and lists concrete content fields. However, it doesn't explicitly distinguish from siblings like mesh_balance or mesh_discover, though the content list does differentiate it reasonably.

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 this is a read/lookup tool for viewing a node's quantitative profile data. It states the data is 'ledger-derived,' suggesting authoritative settlement data. However, there are no explicit when-to-use vs alternatives statements, no mention of when to prefer mesh_balance, mesh_discover, or biz-analyze for relational/commercial insights.

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

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

The description discloses several behavioral traits not captured by annotations: craft privacy ('stays private'), notification side-effect ('followers are notified'), execution model ('house model runs it'), proxy behavior for endpoints, and earning mechanism. This goes well beyond the all-false 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 (5 sentences) but densely informative. It front-loads the core purpose, then uses a clear 'EITHER... OR' structure for the main mode choice, followed by side-effects and prerequisites. No filler.

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

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

Despite no output schema, the description covers essential aspects: what it does, how to invoke it, authentication, privacy, notifications, and earning. It does not mention return values or errors, and skips some optional params like 'kind' and 'category', but overall provides a robust context for an agent.

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

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

The description adds meaning to key parameters beyond the schema: it explains the craft vs endpoint distinction, minimum pricing constraints, and craft privacy. However, it does not describe 'kind' or 'category', leaving some parameters under-explained.

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

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

The description clearly states the action ('List YOUR OWN tool on the exchange') and the benefit ('earn MESH'), distinguishing it from siblings like mesh_discover (browsing) and mesh_signup (key minting). The verb and resource are specific and unambiguous.

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

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

The description provides clear context: publishing a capability for rent, with an explicit prerequisite ('Requires your agent key as Bearer') and a named sibling for key creation (mesh_signup). It also explains the two modes (craft vs endpoint), but does not explicitly contrast with all other mesh_* 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 declare readOnlyHint=true and openWorldHint=false, and the description's content aligns with a read-only operation (fetching your own referral link). The description adds meaningful context beyond annotations by clarifying that spend-only MESH is earned only when a referred node becomes an independently-transacting member, not on signup. However, it doesn't disclose how the referral link is delivered (e.g., embed vs. link), whether there are limits, or any rate concerns, though with a zero-parameter read tool this is acceptable.

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

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

The description is one well-constructed sentence plus a clarifying clause about earning mechanics. It communicates the core purpose efficiently, though the second half about earning conditions is somewhat verbose for what is essentially a link-fetching tool. The purpose is front-loaded and clear, with minimal waste.

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

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

For a zero-parameter tool with readOnlyHint=true and no output schema, the description is reasonably complete. It states what the tool returns (referral link + code), its purpose (vouch other agents), and the earning conditions. The main gap is the absence of an output schema means the agent can't predict the exact return structure, but the description compensates by naming the two expected outputs (link and code).

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

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

The tool has zero parameters. Per the rubric, zero-param tools get a baseline of 4. The description doesn't need to explain parameters since there are none, and it instead clarifies what the tool returns and the semantics of the reward system. No credit lost here.

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 ('Get') with a clear resource ('your referral link + code'), and explicitly states the tool's purpose: vouch other agents onto the mesh. It distinguishes itself from sibling tools like mesh_follow or mesh_subscribe by focusing on referral/rewards. The clarity is strong and immediately actionable.

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 this should be used when the agent needs to share a referral or check how referrals are rewarded. It explains the earning eligibility rule (spend-only MESH only for independently-transacting members, never a mere signup), which is useful context for deciding when referral-sharing matters. However, it doesn't explicitly state when NOT to use it or name alternative tools, though the zero-parameter nature makes misuse unlikely.

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

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

Annotations are all false and provide minimal information, so the description carries the full burden. It discloses the one-time key return ('The key is returned once'), the closed-loop nature of credits ('no payment method involved or attachable'), and the privacy-preserving storage of recovery email ('stored as a one-way hash'). These are meaningful behavioral traits 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?

The description is a single dense paragraph, but every sentence earns its place: the core action is front-loaded, followed by essential caveats about key handling, payment, and privacy. There is no fluff or repetition; the structure uses natural emphasis (e.g., 'ONLY if a human is present') to communicate priorities.

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

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

For a tool with no output schema, the description covers the critical details: what the tool produces (agent key + starter MESH), what to do with the key, optional inputs and their conditions, and safety/privacy implications. It fully equips an agent to perform the signup correctly and handle the returned key securely.

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%, giving a baseline of 3. The description adds meaningful context beyond the schema: it explains handle as 'claim a handle', referred_by as 'the ref code of the node that vouched you in', and enriches recovery_email with consent requirements, hash storage, and a prohibition on inventing addresses. This goes beyond the schema's terse descriptions, especially for recovery_email.

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

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

The description clearly states the action: 'Join the mesh — with your user's knowledge: claim a handle and get an agent key + starter MESH'. It identifies the specific resource (the mesh) and the result (agent key + starter MESH). It also distinguishes from sibling mesh_* tools as the account-creation entry point, reinforced by its title 'Join the Mesh (free signup)'.

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 and how to use: 'No authentication needed', and gives the immediate next step: 'The key is returned once — show it to your user and save it, then set it as your Bearer token to start calling capabilities.' It also gives conditional guidance for recovery_email ('ONLY if a human is present and asks for it') and warns against inventing addresses, which tell the agent when not to use that parameter.

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

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

The description adds some behavioral context (HMAC-signed deliveries, LIVE events) and gives example event types. However, it does not mention that the tool supports delete operations (destructiveHint) or that subscriptions are HTTP-based. It doesn't disclose any potential side effects beyond what annotations already state. It also doesn't mention that event types beyond the examples exist, though schema covers 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, directly clear, uses a list for readability, no fluff. Well-structured and front-loaded.

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

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

Given the schema covers parameters and annotations indicate destructive capabilities, the description adds enough context about event types and HMAC security. It could mention the action options or lifecycle, but overall it's adequate for a medium-complexity 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 75%, so most params are described in schema. The description adds event examples but doesn't explain the action or id/url parameters further. It provides minimal added value beyond the schema.

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

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

The description clearly states the tool's function: wiring a webhook to your node's LIVE mesh events, with concrete examples (call.settled, vibe.followed, capability.listed). It distinguishes from sibling mesh_* tools by focusing on webhook subscriptions, making the purpose unambiguous.

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

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

The description implies usage for receiving real-time event notifications but does not explicitly say when to use it over other mesh tools (e.g., polling or direct query). It also does not explain the action parameter (create/list/delete) or when to use each action. The HMAC mention hints at security but no explicit guidance on when to choose this tool.

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

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

Annotations (readOnlyHint=false, openWorldHint=true, destructiveHint=false) already carry the safety profile, so the bar is lower; the description adds genuine value by disclosing a per-call cost ('3 MESH/call') and a grounding trait ('Reasons from fundamentals; never invents patch notes or win rates'). This tells the agent the tool is faithful to provided data and costs resources to invoke. It does not say what external data it draws on, but the annotations cover the remaining safety 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 compact at three sentences and front-loads the purpose before the behavioral caveats. The parenthetical '(3 MESH/call, a tool · gaming)' is minor noise that could live in metadata, but it does not meaningfully hurt readability or information density.

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 complex tool producing five distinct artifacts (counter-picks, bans, build, flex-slot rule, macro plan) with no output schema and a generic, misleading input schema. The description never clarifies how the agent should convey the enemy draft or rank, what the 'flex-slot decision rule' means, or what MESH cost implies for orchestration. An agent would struggle to construct a valid payload from this definition alone.

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

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

Although schema description coverage is nominally 100%, the single 'input' parameter's description is a boilerplate copy from other tools — it gives agent-brain and agent-memory payload examples that say nothing about a draft-coach request. The tool description loosely implies the payload must contain the enemy draft, but no shape, fields, or format are specified for the nested object. This is worse than no parameter description because the provided text is actively misleading.

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

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

The description opens with a specific verb-plus-resource ('Read the enemy Mobile Legends draft') and enumerates concrete outputs: counter-picks, priority bans, a build with a flex-slot rule, and a first-5-minutes macro plan. It is scoped enough to be told apart from its nearest sibling, mobile-legends-value-coach, by the draft-phase focus. The 'Rank- and draft-order-aware' qualifier adds further precision.

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

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

Usage context is implied rather than explicit: the draft focus and rank/draft-order awareness signal it is meant for the draft phase, but no sibling is named and there is no when-not-to-use guidance. An agent could reasonably wonder whether mobile-legends-value-coach covers post-draft or in-game decisions and when to choose one over the other. The description earns a baseline 'implied usage' score but no more.

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, it discloses a per-call cost (3 MESH), an ethical stance (free-to-play friendly), and a refusal behavior (no ban-risk shortcuts). This helps the agent predict constraints and policy without contradicting the readOnlyHint/openWorldHint/destructiveHint flags.

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 and front-loaded with the tool's value proposition, followed by specific use cases and constraints. The opening repeats the title slightly, but every clause adds meaningful content and there is no filler.

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

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

For a coach-style tool with no output schema, the description covers the main topics the agent should expect answers on, plus cost and safety behavior. It does not explicitly state the return format, but the enumerated coaching topics make the output largely predictable.

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 for the single `input` parameter is 100%, so the baseline is 3. The description adds domain context about 'your specific goal' but does not define the expected payload structure, and the schema's examples reference agent-brain/agent-memory rather than this tool, so there is room for improvement.

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 names the resource (Mobile Legends heroes and skins) and the core action (getting them for the least spend), with concrete decision axes: fragments vs Battle Points, rotating-shop timing, draw-event cost, and overspend traps. This is specific enough to distinguish it from the draft-coach sibling by domain.

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 context for when to use the tool: any purchase or value decision around MLBB heroes/skins, including shop rotation and draw events. It does not explicitly name alternatives or exclusion cases, but the value-vs-draft boundary is evident from the sibling list.

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 does not contradict the annotations: readOnlyHint=false, openWorldHint=true, destructiveHint=false. It adds useful behavioral details beyond the annotations by specifying the 5 MESH/call cost, the three return components (assertion, minimal revert, non-vacuity confirmation), and the logical guarantee that the assertion cannot pass vacuously. It does not disclose side effects, failure behavior, or authorization needs, though the annotations reduce that 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 purpose is front-loaded and the return format is clearly stated. However, the indexOf example is a lengthy illustration that may distract, and 'Full input contract: this tool's input_schema' is meta-content rather than useful description. Overall it is reasonably compact but not exceptionally tight.

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 subtle, methodology-heavy tool with no output schema, the description explains the concept and returns but omits the key operational detail: what the caller must put in the generic input object for negative-control. It also lacks an example invocation or explicit conditions for use. Because the input schema is generic and the description merely defers to it, an agent would struggle to call this tool correctly despite understanding the concept.

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% description coverage on its single input parameter, so the baseline is 3 even though the tool description adds no specific input syntax. In practice, the schema's parameter description is generic ('Capability-specific payload') with examples for other tools, not for negative-control, so the agent still lacks the exact payload contract. The description's pointer to the input schema adds no extra 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 first sentence states the exact purpose: prove a fix is real by writing a test that goes RED when the fix is reverted. This is a specific verb + resource and clearly separates the tool's falsification-oriented role from generic test-generation tools. It does not, however, explicitly distinguish it from sibling tools like refutation-pass, which may serve a similar negative-testing function.

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

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

No explicit when-to-use, when-not-to-use, or sibling alternatives are provided. The reader can infer that it is for validating a fix, but the description never states the trigger conditions or excludes cases where another tool would be more appropriate.

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

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

The description states 'Pure transform, instant', implying no side effects or state modification. However, annotations set readOnlyHint=false, suggesting the tool may modify state or perform write operations. This is a contradiction. Additionally, the description adds cost and API dependency details, but the contradiction undermines trust.

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 there is some redundancy: it repeats the tool title and includes clutter like 'Powered by api.meshtool.ai' and '(1 MESH/call, a tool · tooling)'. Still, the description is compact and readable.

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

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

The description covers the transformation scope, input format, cost, and API dependency. However, no output format is specified and there is no output schema. The return value (converted files) is implied but not explicitly stated, leaving a notable gap for a transform tool.

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

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

Schema coverage is 100%, so a baseline of 3 applies. The description only restates the 'files' parameter structure ('{ files: { filename: content } }') and does not add meaning beyond schema for rec_path or media_path. It offers no extra semantic detail to improve parameter clarity.

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

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

The description clearly states the verb 'Convert' and specifies the resource: Mac OBS config files (global.ini, basic.ini, scene JSON) to Windows-compatible versions. This is specific and distinct from the sibling tools, which are unrelated to OBS configuration.

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 provides clear context for when to use the tool: when you have Mac OBS config files and need Windows-compatible versions. It doesn't explicitly discuss alternatives or when-not-to-use, but the use case is unambiguous and the tool's scope is well-defined.

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

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

The description adds key behavioral context beyond annotations by disclosing that there is no live email/SMS functionality and that the tool is a placeholder. It also includes cost context (2 MESH/call). Annotations declare readOnlyHint=false and destructiveHint=false, but the description's 'NOT YET IMPLEMENTED' warning is more informative and does not contradict 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 a single compact block with the critical 'NOT YET IMPLEMENTED' signal front-loaded)Skip — no filler. The parenthetical metadata is slightly extraneous but does not significantly hurt clarity.

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

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

For a placeholder with no output schema, the description covers the essential facts: unimplemented, no live sending, cost, and capability reservation. It does not specify what happens if invoked (e.g., no-op or error) or name alternatives, but the placeholder status makes this acceptable.

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

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

The input schema has 100% description coverage, so the baseline is 3. The description adds no parameter-level guidance, and the schema's example payloads reference other tools (agent-brain, agent-memory), not this placeholder. The description could have clarified that the input payload is irrelevant or unused, but it does not.

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

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

The description states in its first sentence that this is NOT YET IMPLEMENTED and is a placeholder reserving a capability slot, and explicitly says no live email or SMS sending exists. This is unambiguous about what the tool currently is and clearly distinguishes it from actual messaging siblings.

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

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

It clearly signals when not to use the tool: it is not implemented and has no live sending capability behind it. However, it does not name an alternative tool to use instead for email/SMS, so it stops short of full routing 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 only give readOnlyHint=false, openWorldHint=true, destructiveHint=false. The description adds meaningful behavior: the model may return 'no-selection when nothing clearly matches', that it 'rank(s) existing variants', and the cost '2 MESH/call'. It does not clarify side effects beyond cost, but adds useful non-obvious traits.

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 compact 50-word paragraph that front-loads the core action, then adds behavior, a boundary, and cost. Every sentence adds new information, with no fluff or repetition of the title.

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

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

No output schema exists, so the description should convey return semantics; it says a 'best fit or no-selection' is possible but not what that looks like structurally. The tool is simple, but an explicit output shape would make it fully complete. Adequate for most calls.

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 reinforces the three inputs by naming them and gives examples for goal ('maximize trial signup') and profile shape, which adds a small semantic layer but is not essential 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 'Choose which concrete content option to show a specific user and how to frame it' – a precise verb-resource-target combination. It explicitly limits the scope to 'rank existing variants' and adds 'not to invent a whole campaign from scratch', which distinguishes it from creative-generation siblings. This is unambiguous.

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

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

It states when to use: selecting a content option for a specific user based on profile and goal. It provides an explicit exclusion: 'not to invent a whole campaign from scratch'. However, no sibling tool is named as the alternative, so it does not fully meet the 'explicit alternatives' bar.

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 basic annotations (readOnly=false, openWorld=true, destructive=false), the description discloses critical behavioral traits: it 'Checks your processing agreement for payment exclusivity first and fails closed', it runs on claude-haiku-4.5 and names the model in the response, and it costs 5 MESH/call. These details are not present in the annotations and materially inform the agent's expectations.

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 dense but every sentence earns its place: hook, service promise, safety/fail-closed behavior, model info, alternative, input contract, output contract, and pricing. It is front-loaded with the user-facing purpose and flows logically through operational details with no fluff.

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

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

With no output schema, the description explicitly lists the return shape: '{rescue: {diagnosis, plan, workaround, cautions}, exclusivity_checked, model, next}.' It also covers input, alternative model choice, cost, and the fail-closed safety guarantee. For a generative diagnostic tool with nested input, this is highly complete.

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

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

Schema coverage is 100% and the schema already documents each parameter thoroughly (including the exclusivity fail-closed behavior and aliases). The description merely restates the input contract ('Input: {trouble: string, pos?: string, exclusivity?: 'yes'|'no'|'unknown'}') without adding new semantic 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 a specific verb+resource: 'Stuck on a POS integration... get a diagnosis, a step-by-step plan, and whether the owner-direct checkout workaround applies.' This distinguishes it from siblings like pos-rescue-smart (same contract, different model) and direct-checkout (which would actually execute the workaround), making the purpose unambiguous.

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

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

It gives a clear trigger condition ('Stuck on a POS integration...') and names an explicit alternative ('pos-rescue-smart runs the identical contract on claude-sonnet-5'). However, it does not explicitly state when not to use the tool or reference direct-checkout as the execution alternative, so it stops short of a full when/when-not spec.

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

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

Discloses the fail-closed exclusivity gate and the risk of breaching a processing agreement, which complements the openWorldHint and readOnly=false annotations. No contradiction; the model substitution and cost are also stated.

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

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

Two compact sentences carry identity, differentiation, and usage policy; the schema pointer and pricing are included without padding. Every clause earns its place.

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

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

Covers selection criteria, safety policy, and points to the full input contract. It relies on the sibling tool's contract for output details, but with no output schema and a well-scoped parameter schema, an agent has enough to invoke 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?

input_schema covers 100% of parameters with descriptions, so the description only needs to point there, which it does. Repeating 'fail-closed exclusivity gate' ties to the exclusivity parameter but adds no new schema details.

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

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

Description frames it as the higher-tier variant of pos-rescue with the same contract and exclusivity gate, and singles out the sibling it supersedes. The 'rescue' action is not spelled out with a verb, but the use-case language (resisted one fix, spans two systems) makes the purpose evident.

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 choose this tier (after one failed fix, two-system spans, or processing-agreement risk) and instructs to use pos-rescue for first diagnosis. This is textbook when-vs-alternative guidance.

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

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

The description adds meaningful behavioral constraints beyond the annotations: it will not invent legal arguments, draft/complete filings, or file with a court, and it organizes facts the user already has. These statements do not contradict the annotations (readOnlyHint=false, openWorldHint=true, destructiveHint=false). It does not discuss data persistence or external calls, but the key boundaries are disclosed.

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 the core purpose and output list, followed by audience and boundaries, so it is mostly efficient. However, it ends in a truncated fragment ('organizes what you alrea') and includes a stray metadata suffix, which makes the structure feel incomplete and less polished.

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 builder tool that produces multiple tracker components, the description does list the expected outputs and explicitly states what it will not do. But it omits how the input should be structured, what format the tracker takes, and how the result is returned or persisted. With no output schema, the description should carry more of that burden.

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 a single 'input' object with a generic 'Capability-specific payload' description and examples referencing unrelated tools (agent-brain, agent-memory), so it provides little probate-specific meaning. The tool description adds only high-level guidance that the input is the user's own probate/estate dispute facts, without specifying expected structure or subfields. This is adequate but not strongly helpful.

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

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

The description states a specific transformation ('Turns your own probate/estate dispute facts into an organized, plain-English case tracker') and enumerates concrete outputs such as document inventory, key facts, timeline, and next-steps checklist. It also distinguishes itself from drafting/filing tools by explicitly saying it never drafts, completes, or files court documents.

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

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

It clearly scopes the tool to pro se filers and people working with an attorney, and it gives explicit when-not-to-use boundaries: it never invents legal arguments, drafts filings, or files anything with a court. It does not name an alternative tool, but the audience and exclusions are clear enough for an agent to route correctly.

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

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

Annotations state readOnlyHint=false, openWorldHint=true, and destructiveHint=false. The description adds behavioral context: it notes that the wrapper may not reliably produce a structured reproduction bundle, and that output is a high-level note rather than a proof. This is useful transparency about reliability and output nature, beyond what annotations provide. However, it doesn't disclose potential side effects (though readOnlyHint=false suggests possible writes), and given the experimental nature, more disclosure could be expected. The description does not contradict annotations, so a 3 is appropriate.

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

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

The description is concise, with three sentences packed with information: purpose, experimental caveat, output quality, and pricing. It is front-loaded with the core function. However, the last phrase 'a tool · audit' is cryptic and adds little value, and the pricing information might be better in annotations or separate metadata. Slight points deducted for that noise.

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

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

Given the complexity (experimental, one nested object parameter, no output schema), the description clarifies expected delivery (counterexample or reason) and limitations (not machine-checkable), which is critical for setting agent expectations. It does not describe the exact input format beyond the schema, but the schema is self-explanatory with examples. It is complete enough for an agent to decide whether to use it, though a bit more detail on input could push it to 5.

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 a single 'input' object parameter described as a capability-specific payload with examples. The description mentions giving it 'one code claim plus relevant code' but does not detail the exact structure of the input object beyond the schema's generic example. Since the schema already covers the parameter, the baseline is 3, and the description adds a bit of context about what to pass, but not enough to raise it.

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

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

The description clearly states the tool's purpose: it takes a code claim and relevant code to produce a counterexample or reason the claim fails. It identifies the resource (code claim) and verb (refute). It is distinguished from siblings by being experimental and an 'analyst's pass,' not a machine-checkable proof, which sets it apart from more formal tools like code-review. However, it does not explicitly name which sibling to use instead, so it loses a point.

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

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

The description implies when to use: when you have a code claim to refute, and it hints at limitations (not a machine-checkable proof). It does not explicitly state when not to use it or alternative tools, but the context of 'experimental' and the caveat about the output quality give clear usage context. It is better than average but not fully explicit.

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

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

The description is unusually candid: it labels the tool experimental, specifies that the reliable output is a short fit note and draft reply copy in the answer text, warns that structured reply fields are not yet surfaced cleanly, and clarifies that the user still approves and posts. It also discloses the cost. This adds substantial behavioral context beyond the annotations.

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

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

The description is longer than average but each section contributes: purpose, required inputs, output format, user responsibility, wrapper limitation, and cost. The opening repeats the title somewhat and the trailing marketing metadata is minor clutter, but overall it is efficiently organized.

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

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

For an experimental tool with no output schema and a generic input schema, the description covers the essential input requirements, the output the agent can rely on, and the caveat about structured fields. It is not a 5 because it leaves the exact input representation of 'target post' and 'brand or offer' ambiguous.

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

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

The single `input` parameter's schema description is generic and not tailored to this tool. The prose description adds semantic meaning by saying the input must contain the target post plus the brand or offer, but it does not specify the exact object shape, key names, or how to encode the target post, so it only partially compensates.

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

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

The description opens with a specific verb and resource: a reply or quote-post planner for borrowing reach from a larger account. This makes it distinct from broader posting tools and marketing planners in the sibling list, and 'You still approve and post it yourself' reinforces that it is a planning aid, not an actual posting action.

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

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

It clearly states the intended context: use when you want to reply or quote-post to leverage a larger account's reach. It tells the user to provide the target post plus brand or offer, but it does not name alternatives or state when not to use this tool, so it stops 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?

The description adds substantial behavioral context beyond the annotations: it specifies 'Pure pattern matching, no AI call,' meaning deterministic and cheap; it discloses 'Best-effort, not a guarantee,' warning about false negatives; it mentions the cost '(1 MESH/call)'; and it describes the return shape ({scrubbed, redacted, kinds}) despite no output schema. This goes well beyond the sparse annotations (readOnlyHint:false, openWorldHint:true, destructiveHint:false) and provides key transparency for an agent.

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

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

The description is efficiently structured: it opens with a purpose clause, lists covered data types, gives a usage hint, describes input/output, warns about limitations, and notes cost. It is not overly long, but it begins with 'Safety Scrub —' which repeats the title, and the parenthetical '(1 MESH/call, a tool · safety)' is metadata that could be omitted without loss. Still, every substantive sentence earns its place.

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

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

The tool has a nested input object and no output schema, so the description carries significant responsibility. It fully covers the return format ({scrubbed, redacted, kinds}) and even gives an example ('card','ssn'). It also covers behavioral nuances (best-effort, no AI, cost). Minor gaps exist: it doesn't explain aliases (though schema covers them) or behavior when no sensitive data is found (though 'redacted: boolean' implies it). Overall, it is sufficiently complete for the agent to invoke and interpret results.

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

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

The input schema has 100% description coverage: the text parameter is described as 'REQUIRED — the text to scan; card numbers, SSNs, API keys/tokens, JWTs and PEM private keys are replaced with [REDACTED-*] markers.' The tool description only says 'Input: {text: string},' adding no new information beyond the schema. It does not mention the alias parameters (input, content) or the fallback chain, but since the schema documents those, the description doesn't need to. Baseline 3 is appropriate.

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

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

The description clearly states the tool's function: 'Redact sensitive data from text before logging it or sending it to a model.' It specifies the exact data types handled (cards, SSNs, API keys, JWTs, PEM keys) and the output markers ([REDACTED-*]). This distinguishes it from sibling tools, none of which mention redaction or safety scrubbing, and explicitly notes 'Pure pattern matching, no AI call' to differentiate from AI-based tools.

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

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

The description gives a clear usage directive: 'Use whenever user-supplied or scraped text may carry credentials.' It also implies when to use by mentioning 'before logging it or sending it to a model.' However, it does not explicitly name alternative tools or state when not to use it, so it falls short of the highest bar for usage 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?

Beyond the annotations, the description explicitly discloses that the tool is advisory, has no calendar side effects, and costs 2 MESH/call. This adds meaningful behavioral context even though it stops short of describing what the proposed agenda/time-slot output looks like.

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

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

A single focused sentence front-loads the action and constraint, with cost and category tucked into a small parenthetical. No filler or repetition.

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

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

For an advisory planning tool the description covers purpose and safety well, but no output schema exists and the input schema's generic payload description does not specify scheduling-specific fields. An agent would still have to guess the exact shape of the 'input' object.

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

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

The input schema has one documented property, but the example payloads reference unrelated tools (agent-brain, agent-memory). The tool description adds 'from a text description of constraints,' which hints at the intended input, but the exact structure of the scheduling payload is left undefined.

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

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

The description opens with a specific action ('Drafts') and concrete deliverables ('meeting agenda and time-slot suggestions'), and immediately distinguishes the tool from calendar-mutating actions with 'does not touch a real calendar.' This is unambiguous and sufficient to separate it from the sibling set.

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

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

It clearly frames when to use the tool: when you have a text description of constraints and want advisory scheduling suggestions. It states an important exclusion ('Advisory only — does not touch a real calendar'), though it does not name alternative tools or spell out when not to use it.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is established. The description adds value by noting 'free, no key needed' — a behavioral affordance (no auth required) not captured in the annotations. It also scopes the search domain (Exchange capabilities for rent), which helps the agent understand what results to expect. Description is consistent with annotations.

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

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

Two sentences, no wasted words. Every phrase earns its place: the purpose, the domain scope with concrete examples, and the key affordances (free, no key) are all packed efficiently. This is a model of conciseness for a simple single-parameter tool.

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

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

For a simple search tool with one well-documented parameter, readOnlyHint annotation, and no output schema, the description is largely sufficient. It covers what's searched, the content domain, and access requirements. The only gap is query semantics (how matching works) and what result format to expect, but these are minor for a search tool of this simplicity.

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

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

Schema coverage is 100%, with the single 'query' parameter described as 'what you're looking for'. The description's mention of 'memory, reasoning, safety, images, commerce' adds domain vocabulary that hints at valid query types, giving slight value beyond the schema. However, it doesn't clarify match semantics (fuzzy vs exact, keyword vs natural language) which would help an agent formulate queries 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 what the tool does: search the MeshMarket exchange for rentable capabilities. It specifies a verb (search), a resource (MeshMarket exchange), and the scope (capabilities agents can rent across memory, reasoning, safety, images, commerce). The main gap is that it doesn't explicitly differentiate from siblings like mesh_discover or merchant-discovery, though the exchange-specific search intent is reasonably distinct.

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

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

The description implies when to use it ('search for capabilities agents can rent') but provides no explicit exclusions or alternative recommendations. Context like 'free, no key needed' gives useful usage context, but there's no statement about when NOT to use this versus mesh_discover, mesh_delegate, or other discovery tools in the sibling set.

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

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

The description adds behavioral context beyond annotations by disclosing the cost (2 MESH/call) and external dependency (api.meshtool.ai), which aligns with openWorldHint=true. It does not contradict readOnlyHint=false as the operation is stateless extraction; the main side effect is monetary cost, which is mentioned.

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

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

The purpose is front-loaded and clear, but the description contains redundant elements: 'Input: { text: string, shape: object }' duplicates the schema, and trailing metadata like 'a tool · extraction' adds noise. It is still relatively compact, but not every sentence earns its place.

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

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

The description adequately conveys the output behavior (returns structured data in the user-provided shape) even without an output schema. It mentions cost, external API, and typical use cases. It lacks details on error handling or edge cases, but for a simple extraction tool this is sufficient.

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

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

Schema coverage is 100%, so the description does not need to compensate much. It restates the input format (text, shape) but adds minimal extra meaning such as 'any JSON shape you describe' and use-case examples. This provides slight value beyond the schema, but not enough to exceed the baseline.

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

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

The description clearly states the tool's purpose with a specific verb ('Pull') and resource ('structured data out of free text'), and lists representative use cases (classification, field extraction, scoring). It is distinct from sibling tools like 'search' or 'fetch' by emphasizing customizable JSON shape 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?

The description gives clear context for when to use the tool (extracting structured data from free text into any JSON shape). It does not explicitly name alternatives or exclusions, but the use case is evident and the 'any JSON shape' phrasing highlights its flexibility. This exceeds a vague statement but stops short of explicit 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?

The description adds substantial context beyond the sparse annotations: it names the serving model ('Runs claude-haiku-4.5'), states the cost ('5 MESH/call'), notes that the response names the model, and details the return structure. It also characterizes the tool as 'reasoning'. No contradiction with annotations; readOnlyHint=false is not contradicted by the output-producing behavior.

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

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

The description is a single sentence but packed with essential information: purpose, output format, model, cost, and I/O shape. It uses em-dashes and parentheticals efficiently, with the core purpose leading. Every clause earns its place, and there is 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?

With no output schema present, the description fulfills that responsibility by listing the returned fields: {analysis: {summary, steps, risks, verdict}, model}. It also covers cost, model, and input shape, providing enough context for an agent to invoke correctly. The detailed schema complements the description, making the tool well-specified for its 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?

The tool description only restates 'Input: {task: string}' while the input schema's description is far more detailed, covering coercion, trimming, truncation to 4000 chars, whitespace rejection, and fallback keys. Since schema coverage is 100% and the schema already provides rich parameter semantics, the description adds no extra meaning beyond a basic restatement. Baseline 3 is appropriate.

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

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

The description clearly states the tool's function: 'Hand a task, get a structured plan back — typed steps, risks, and a go/caution/no-go verdict.' It also specifies the output structure and the model, making the purpose specific and unambiguous. While it doesn't explicitly distance itself from sibling tools like 'task-orchestrate', the unique output type (steps, risks, verdict) distinguishes 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 implies usage context ('Hand a task, get a structured plan back') but provides no explicit 'when to use' or 'when not to use' statements. It does not mention alternative tools or exclusions for scenarios where another tool would be more appropriate. This is implied guidance at best, not explicit alternative naming.

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/destructive hints, and the description adds useful context: it is powered by an external API and costs 3 MESH per call. However, it does not disclose whether the tool executes the plan or only returns it, nor any side effects on state, memory, or external systems.

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 quite short and front-loaded with the core purpose, but includes redundant 'Task Orchestrate —' and marketing-ish 'a tool · reasoning' text. The external API and pricing info are useful but could be more tightly integrated.

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

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

Given no output schema, the description does not explain what the execution plan looks like or how the agent should use the result. It also lacks guidance on how this relates to sibling tools like task-analysis or agent-brain, leaving the agent to infer integration and output expectations.

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 fully documents parameters. The description only restates 'Input: { task: string, tools: array }', adding no extra semantic detail about parameter usage, formatting, or relationships.

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+resource: 'Break a multi-step task into an execution plan any agent can follow.' This clearly conveys the core function. However, it does not differentiate from the sibling tool 'task-analysis', which may serve a similar planning/analysis role.

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

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

There is no explicit statement about when to use this tool versus alternatives, nor any exclusion criteria. The phrase 'multi-step task' only implies usage context, but no clear when/when-not guidance is provided.

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

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

Annotations already indicate readOnlyHint=false and openWorldHint=true, so the description does not need to repeat those. It does add behavioral context by stating it preserves tone/register and flags ambiguous terms with alternate readings, which is valuable. However, it does not disclose any side effects, rate limits, or what happens in error cases. Given the annotations, the description adds some context but not deeply.

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

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

The description is a single, efficient sentence that front-loads the purpose and adds key behavioral details. The parenthetical about cost and type is compact and does not waste space. No extra fluff.

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

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

Given the tool's complexity (nested object input, no output schema), the description is incomplete. It fails to specify the input format, expected fields, or how to handle multilingual requests. The agent may know 'translate' but cannot call it correctly without guessing the payload structure. The schema description is misleading and does not compensate.

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

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

The schema has one property 'input' with a generic description that gives examples for other tools (agent-brain, agent-memory), not for translate. The tool description does not explain what the input payload should contain (e.g., source/target languages, text to translate). This is a major gap: the agent cannot determine how to structure the input from either the schema or the description, so parameter semantics are essentially undocumented.

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 ('Translates'), the resource ('text'), and the specific scope ('between languages'). It adds distinctive details about preserving tone and register and flagging ambiguous terms, which goes beyond a generic translation tool and distinguishes its behavior from a plain translator.

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

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

The description implies usage context through details like preserving tone and flagging ambiguities, suggesting it is suited for nuanced translation tasks. However, it does not explicitly state when to use this tool versus alternatives, nor does it mention any exclusions or when not to use it. There are no sibling translation tools to differentiate from, so this absence is less critical, but the guidance remains implicit.

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

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

The description adds meaningful behavioral context beyond the annotations: the tool is superseded, is only a routing signpost, is not Shop-Graded, and has a 2 MESH/call cost. It does not fully explain what happens if called, but for a placeholder that is acceptable given the explicit supersession warning.

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-loads the critical SUPERSEDED status, and every sentence adds necessary routing or deprecation information. There is no wasted text.

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 placeholder tool, the description is complete: it states that it is superseded, identifies the correct replacements, clarifies its routing-signpost role, and even includes cost and grading status. The rich sibling list and schema further support agent decision-making.

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

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

The schema fully documents the single 'input' parameter with examples, so the description does not need to add much. The description adds no parameter-specific meaning, which is fine at the baseline given 100% schema coverage.

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

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

The description explicitly states this tool is a superseded placeholder that exists only as a routing signpost, not a working TTS/STT tool. It clearly names the live alternatives (grok-tts, grok-stt), so an agent can immediately tell what this tool is and is not.

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 routing guidance: use grok-tts for text-to-speech and grok-stt for speech-to-text instead. It also notes the placeholder is not Shop-Graded, which helps an agent decide whether to invoke it at all.

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

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

Annotations (readOnlyHint, openWorldHint, destructiveHint) do not reveal that this is a placeholder. The description adds critical transparency by stating 'no live web search or fetch exists behind it yet', which is essential behavioral information beyond what annotations provide. This clearly tells the agent the tool performs no operation.

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

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

The description is extremely concise and front-loads the most critical fact ('NOT YET IMPLEMENTED') in the first sentence. Every sentence provides necessary information about the placeholder nature and no content is wasted.

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 placeholder tool with no output schema and a single generic parameter, the description is largely complete: it clearly states the tool is not functional. However, it could improve by explicitly pointing agents to a working alternative (e.g., 'use search instead'), so it is not a perfect 5.

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

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

Schema description coverage is 100% for the single parameter, so the baseline is 3. The description does not add any meaning to the 'input' parameter beyond the generic capability payload example already in the schema.

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

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

The description explicitly states 'NOT YET IMPLEMENTED' and 'Placeholder listing reserving this capability slot', clearly conveying that this tool is a placeholder rather than a functioning web search. It does not explicitly compare against siblings like 'search' or 'fetch', but its purpose is unambiguous and not a tautology.

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

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

The description provides no guidance on when to use this placeholder tool versus alternatives such as 'search' or 'fetch'. It merely states it is not implemented, leaving agents without direction to avoid it or choose a working substitute.

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