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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds useful behavioral context beyond them: it emits a names-only index plus an estimated token drop measured against the supplied text, and notes include_slim does not affect that measurement.

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?

One front-loaded sentence that leads with the transformation and the resulting artifact, with no filler. It is slightly long and the trailing ellipsis suggests the text may be cut off, but the core content is efficient.

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

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

With full schema coverage, an output schema, and complete annotations, the description need not explain return values or safety. It covers inputs, output shape, and the token-drop metric adequately; the only gap is the absence of sibling-routing guidance.

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

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

Schema description coverage is 100%, so the baseline is 3. The description reiterates the names-only index and token-drop behavior but adds no syntax or format detail about the 'manifest' string or 'slim_tools' beyond what the schema already documents.

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 (reduces/indexes) and resource (a set of MCP tool definitions, grouped by server or flat) and names the exact output artifact: the names-only index, one line per server, no schemas. This distinguishes it from siblings like demo_simplify_tool_schema (slim definitions) and demo_estimate_tokens.

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

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

The description explains what the tool produces and the effect of include_slim, but never states when to choose it over the closest alternatives (e.g., mcptoon_manifest, demo_simplify_tool_schema, demo_estimate_tokens). Usage is implied by the output shape rather than stated.

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, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety and idempotence profile is already clear. The description adds that the payload 'is read as data, never executed' in the schema, but the description itself does not repeat that; it does clarify the output structure (character count, estimated token count, percentage saved) which is behavioral context not in annotations. However, it does not mention rate limits, execution time, or potential errors, so a 4 is appropriate for adding useful output context.

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

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

The description is a single, front-loaded sentence that efficiently conveys the purpose, output, and use case. The trailing ellipsis is odd but does not detract from conciseness. It earns its place without 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?

With one fully documented parameter, rich annotations, and an output schema present, the description needn't explain return values. It adequately completes the picture by stating what is returned and why, though it could explicitly differentiate from siblings like demo_encode_toon. Given the output schema exists, this is nearly complete.

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

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

Schema description coverage is 100%, so the parameter 'payload' is fully documented in the schema as a JSON document serialized as text. The description adds no additional parameter syntax or constraints beyond what the schema provides, so the baseline of 3 applies.

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

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

States a specific verb (encodes), resource (one JSON document), and the exact scope: comparing JSON, TOON, and Compact renderings with character counts, token estimates, and percentage saved. This clearly distinguishes it from siblings like demo_encode_toon or demo_estimate_tokens, which do single-format work, by framing the tool as a comparison against a JSON baseline.

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: 'the way to measure mcptoon's output compression on a payload you actually have.' It does not explicitly state when NOT to use it or name alternatives (e.g., use demo_encode_toon for just TOON output or demo_estimate_tokens for a single token count), so it falls short of a 5 but provides clear context for the payloaud-in-hand use case.

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

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

Annotations already declare readOnly, idempotent and non-destructive, so the safety profile is covered. The description adds real value beyond that by disclosing what is returned (JSON value plus a canonical serialisation) and the intended lossless round-trip purpose, though it omits error behaviour for malformed TOON.

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

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

Front-loads the core action and the returned artifacts, then the routing guidance in a single dense second sentence. Every clause is functional, though the trailing ellipsis and slightly stacked clauses keep it from being maximally 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 single-parameter, idempotent read tool with an output schema present, everything needed to select and call it correctly is covered: purpose, alternatives, and usage conditions. Return values are additionally explained even though the output schema would suffice.

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

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

There is a single parameter with 100% schema description coverage, so the schema already documents the 'toon' input including indentation/tab handling. The description adds no parameter-level detail beyond the schema, which is the expected baseline when coverage is complete.

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 (parses) plus the resource (TOON text) and names the concrete return artifacts (JSON value and canonical serialisation). It explicitly distinguishes itself from encode_toon, so an agent can tell the tools apart without opening any 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?

Gives explicit when-to-use context ('text this server produced or a stored TOON document') and routes to both relevant siblings: encode_toon for producing text and compare_formats for format comparison rather than parsing.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds that the enquiry is about the server's own runtime and that dependency status is reported, which is useful orientation, but it gives no behavioural detail about cost, caching, or freshness of the reported versions.

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

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

A single front-loaded sentence that leads with the verb and resource before listing contents, with no filler. The trailing ellipsis suggests the text is truncated rather than naturally finished, which is mildly awkward but does not hurt selection.

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 parameters, full annotation coverage, and an output schema present, the description does not need to explain return structure, and it correctly stays high level. The one gap is the absence of any routing hint relative to the health/manifest siblings.

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

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

The tool takes zero parameters, so the baseline is 4 and there is nothing further the description could usefully add here. No parameter syntax or format details are expected or missing.

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 ('Describes') and resource ('the running demo server itself') and enumerates the concrete contents: mcptoon version, accepted MCP protocol versions, interpreter/platform versions, and third-party dependency status. It does not explicitly distinguish itself from near-neighbours such as mcptoon_health or mcptoon_manifest, which is the only thing keeping it from a 5.

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

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

There is no when-to-use guidance at all: no statement of when an agent should call this rather than mcptoon_health, mcptoon_manifest, or the demo_* diagnostic siblings. The reader must infer the context from the enumerated contents alone.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds value beyond them by disclosing that it performs no analysis and emits exactly one text content block, which sets expectations for a probe tool. It stops short of stating failure behavior, but the added context is real.

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

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

Two sentences, front-loaded with the core behavior and then routing alternatives, with no filler. It loses a point for the trailing ellipsis that hints at truncation and for a slightly long second clause that mixes purpose and routing.

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 probe with an output schema present, the description covers purpose, usage, alternatives, and return shape; return-value details are delegated to the output schema. Nothing an agent needs to call it correctly is missing.

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

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

Schema coverage is 100%, and the schema itself already documents the verbatim contract, accepted characters, and rejection of empty/blank input. The description adds no syntax or format detail beyond that, so the baseline 3 applies.

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

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

States a precise verb+resource (returns the submitted message back unchanged) plus the exact return shape (one text content block). It also names the sibling tools that do the adjacent work (compare_formats, estimate_tokens), so an agent can place it unambiguously among 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?

Gives an explicit when-to-use ('reachability probe ... confirm the MCP handshake and the transport work before testing anything else') and explicit alternatives with their selecting conditions (compare_formats for size comparisons, estimate_tokens for a token figure). Nothing is left to inference.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so the safety profile is covered. The description adds useful behavioral context beyond them: the output is text, the format is line-oriented, and it is a drop-in substitute for JSON that mcptoon can serve. It does not discuss size/limits or failure behavior, but with strong annotations a 4 is fair.

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?

Efficiently front-loaded: the core function leads, followed by usage conditions and sibling routing in a single flow. The trailing ellipsis indicates the description is truncated mid-sentence, which slightly undercuts an otherwise tight structure.

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

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

An output schema exists, so explaining the return value is unnecessary, and annotations carry the safety profile. The description covers purpose, usage, and alternatives adequately; only the truncated tail and lack of any error/limit behavior keep it from a 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 coverage is 100% with a single required parameter whose escaping/leniency behavior is documented in the schema itself. The description adds no syntax or format detail about the payload beyond what the schema provides, so the baseline 3 applies.

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

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

States a specific verb (converts/encodes) and resource (a JSON document into TOON), and explicitly distinguishes itself from two named siblings: compare_formats and decode_toon. An agent can identify this as the standalone encoder without opening any 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 states when to use it ('when you need the encoded form by itself') and routes to the two alternatives with their distinguishing conditions: compare_formats for side-by-side savings, decode_toon for the reverse direction. Nothing is left to inference.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so the safety profile is covered. The description adds genuine behavioral value by disclosing the exact estimator (character count divided by four, floored) and its consistency guarantee, which the agent couldn't infer from annotations.

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

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

Front-loaded with the action and method in a single efficient sentence. Minor deduction for the trailing ellipsis and for packing the comparability rationale into the same long clause rather than separating it.

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

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

For a one-parameter, read-only, idempotent estimator with a full output schema, the description supplies everything needed: what it counts, how it counts, and why the result is comparable to sibling tools. Return values are covered by the output schema, so nothing essential is missing.

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

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

Schema coverage is 100%, and the single parameter already documents that whitespace and non-ASCII characters count toward the total. The description adds no parameter-level meaning beyond restating "text you supply," 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?

States a specific verb+resource ("Counts the tokens in a text you supply") and immediately qualifiers it with the estimator used. It distinguishes itself from siblings by naming build_tool_manifest and compare_formats, so an agent can tell why this tool exists alongside them.

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

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

It gives clear context for use: the numbers are meant to be comparable with savings reported by build_tool_manifest and compare_formats, implying it is the verification/consistency tool. However, it never states when-not to use it or names a direct alternative to prefer, so it stops short of fully explicit routing.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so the safety profile is covered. The description adds genuinely useful context that paths are resolved specifically in this process's environment, which hints at environment dependence, but nothing about ordering or side effects on sync.

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

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

A single front-loaded sentence conveying the resource and the returned path semantics with no filler. The trailing ellipsis suggests the text is truncated, so it is not fully 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?

With an output schema present, the description need not enumerate return fields, and it does describe the shape of the result (targets plus resolved paths). For a no-arg, read-only listing tool this is close to sufficient, the only shortfall being absent usage 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, so there is nothing for the description to disambiguate. Schema coverage is 100% and no parameter meaning is left unstated.

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 and resource (reports the AI agent configuration targets that mcptoon's sync command can write) and adds scope via the resolved path detail. It is clear what the tool returns, but it never names or distinguishes itself from siblings like mcptoon_manifest or demo_describe_runtime.

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

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

There is no when-to-use or when-not-to-use guidance, and no alternative tool is mentioned. An agent must infer from the name alone that this is the discovery step before running sync.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=false, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds useful context about the committed/archived nature and the specific benchmark contents, but does not disclose additional behavioral traits such as data freshness guarantees or caching 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 front-loaded sentence that immediately states the return value and then details the dataset sizes, encoding, and formats. Every clause carries useful content, and there is no filler or redundant restatement of the title or annotations.

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

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

For a no-parameter, read-only tool with rich annotations and an output schema, the description supplies exactly the domain context an agent needs: what benchmark is reported, which tool-definition counts are covered, which encoding is used, and which formats are compared. The output schema handles return structure, so no further description of return values is required.

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

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

The tool has zero parameters, so there is no parameter semantics to explain. With an empty schema and 100% schema description coverage, the baseline score of 4 applies; the description adds no parameter information because none is needed.

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

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

The description gives a specific verb ('Returns'), resource ('this project's committed token measurements'), and precise scope: 5, 50, and 255 MCP tool definitions, encoded with tiktoken cl100k_base, across raw JSON, TOON, SLIM, and Compact formats. The word 'committed' and 'archived' distinguishes it from live-estimation siblings like demo_estimate_tokens and demo_compare_formats without needing to name them.

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

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

The description explains what data is returned but gives no when-to-use guidance, no conditions for choosing this tool over alternatives, and no exclusions. Sibling tools like demo_compare_formats and demo_estimate_tokens exist, yet the description does not route the agent between them.

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

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

Annotations already declare readOnlyHint, idempotentHint and non-destructive, so the safety profile is covered; the description adds genuinely new behavior by defining what the 'slim form' actually keeps (name, type, required marker) and that char/token deltas are computed against the input. It stops short of describing edge-case handling or failure modes.

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

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

Front-loaded with the verb and resource, and every clause carries information. The single long sentence is dense but not padded, and no filler precedes the point.

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

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

An output schema exists, so the return contract need not be spelled out, yet the description helpfully flags that the delta metrics come back with the slim definition. For a single-parameter transformer with full schema coverage and rich annotations, nothing an agent needs to invoke it correctly is missing.

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

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

Schema coverage is 100% and its description already specifies that the input is a serialised JSON object requiring a non-empty 'name', with bare strings rejected. The description adds nothing beyond that, so baseline 3 applies.

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

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

States a specific verb (rewrites/slims) plus the exact resource (a single MCP tool definition, name/description/inputSchema) and the form produced. An agent can tell this apart from siblings like demo_compare_formats or demo_encode_toon without opening any 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?

Usage is implied by the transformation described, but the description never says when to reach for this tool versus the sibling format/diff tools (demo_compare_formats, demo_encode_toon, demo_build_tool_manifest). No prerequisites or exclusions are stated.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive, and closed-world, so the safety profile is covered. The description adds concrete validation behaviors (per-entry problem reporting, transport-choice preview) that go somewhat beyond annotations, but it does not disclose whether the tool errors on invalid input or how thoroughly it validates beyond structure.

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?

One dense sentence that front-loads the pre-save validation purpose before listing problem categories. The ellipsis suggests the description may be truncated or incomplete, which slightly hurts structure.

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

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

The tool is structurally simple (one string parameter, output schema present), annotations cover the safety profile, and the description explains what gets checked and how problems are reported. Nothing essential to correct invocation is missing.

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

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

Schema description coverage is 100%, so the single config parameter is already fully documented. The description implies the input is a draft config being checked, which aligns with the schema but adds no syntax or format details beyond 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?

States a specific verb (checks) and resource (a proposed mcptoon server configuration) with clear scope (before saving). Distinguishes from siblings like mcptoon_servers (which presumably lists existing servers) by making the draft-validation purpose unmistakable.

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

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

Implies when to use it: 'before you save it' gives clear timing context for validating a draft. It doesn't name a specific alternative or say what to do if problems are found, but the pre-save context is strong enough for an agent to select it 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 already declare readOnlyHint, idempotentHint, openWorldHint=false and destructiveHint=false, so the safety profile is fully covered. The description adds genuinely useful behavioral context the annotations do not: this is a diagnostic/introspection call that reveals configuration and load state, and that it is the correct first step in a missing-tool investigation. It does not discuss cost or failure modes, but the read-only nature makes those minor.

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, zero waste. The enumerated outputs come first, then the diagnostic guidance, so the agent gets the gist immediately. Every clause carries 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?

An output schema exists, so return values need no explanation, yet the description still names the salient fields. A parameterless, closed-world, read-only diagnostic tool is fully specified here; nothing an agent needs in order to invoke it correctly is missing.

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

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

Zero parameters, so there is nothing for the description to disambiguate — baseline 4 applies. The description correctly implies the call takes no arguments, matching the empty schema.

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

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

States a specific verb+resource ('Self-check of this gateway process') and enumerates exactly what it reports: version, config path, servers configured, tools indexed, uptime. This clearly distinguishes it from siblings like mcptoon_manifest and mcptoon_servers, which expose registry contents rather than process health.

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

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

Gives an explicit trigger ('Read this first when a tool you expect is missing') and names the diagnostic distinction it resolves (empty config vs. server that failed to load). The condition for choosing this tool over any sibling is unambiguous.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world behavior, so safety is covered. The description adds real behavioral context beyond that: the default response contains names only, and enabling descriptions costs tokens, letting the agent reason about output size.

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

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

Three short sentences, front-loaded with what the tool returns, then the recommended usage, then the optional parameter. Every sentence carries information and nothing is padded.

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

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

With an output schema present, return values need not be explained, and annotations cover the safety profile. The description covers scope, defaults, and cost; only minor details (e.g., how grouping keys are structured) are left implicit.

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

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

Schema description coverage is 100% and both parameters are already documented there, so the baseline is 3. The description largely restates the include_descriptions effect ('one-line summary per tool' / default false) and adds nothing about the server filter's matching 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?

States a specific verb and resource ('List the upstream tools this gateway currently exposes') plus the grouping scope ('grouped by server') and the default output shape (names only). It is clearly distinguishable from sibling tools like mcptoon_servers, which enumerates servers rather than exposed tools.

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

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

Explicitly tells the agent to read this compact view 'instead of pulling every full schema,' which is real when-to-use guidance, and it explains when to pass include_descriptions (one-line summaries) versus keeping the small default. It stops short of naming a specific alternative sibling tool or stating exclusions.

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

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

Annotations already cover safety (readOnly, idempotent, openWorld=false, non-destructive). The description adds genuine behavioral context beyond that: it discloses what state is examined (load status) and surfaces a diagnostic condition ('configured but published nothing') that an agent would not know to look for from annotations alone.

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

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

Two tight sentences with zero filler; the purpose is front-loaded and the usage sentence adds distinct value rather than restating the first.

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

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

With an output schema present, return values need no explanation, and the description covers purpose, usage, and the optional narrowing parameter. Nothing an agent needs to call this correctly is missing.

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

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

Schema description coverage is 100%, and the schema already documents the single optional 'server' parameter including alias resolution. The description only implies an all-by-default scope, adding nothing the schema does not already say, 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?

States a specific verb and resource ('report the MCP servers configured behind this gateway') and enumerates the reported fields (transport, tool count, load status). An agent can distinguish this from siblings like mcptoon_manifest and mcptoon_health without opening any 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?

Gives clear usage context: 'see what is actually reachable before calling a tool' and spot servers that published nothing. No explicit when-not or named alternative sibling, but the diagnostic framing makes the use case unambiguous.

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