Toofi Dental Planning MCP

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

The description describes a state-changing operation ('exchange', 'claim'), which contradicts the readOnlyHint=true annotation. Claiming a one-time token inherently consumes it, so the annotation is misleading. This is an annotation contradiction, warranting a score of 1.

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 conveys the action, condition, and inputs without wasted words. Every phrase contributes meaning.

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 provides the essential steps and outcome, and an output schema exists to explain return values. However, it could have mentioned that the claim token is consumed (which would also flag the contradiction) and any failure modes, but given the output schema, this is not a major 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?

The schema covers all 8 parameters with descriptions, but the description adds value by explicitly identifying purchase_id and claim_token as the key exchange inputs and mentioning the resulting key usage ('X-Toofi-Agent-Key or agent_key'). This goes beyond the schema's 'returned by create_agent_checkout_session' notes.

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

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

The description clearly states a specific action ('exchange the purchase id and one-time claim token for the Toofi agent API key') with a clear resource (the API key) and precondition (after Stripe Checkout is paid). This distinguishes it from sibling tools like create_agent_checkout_session, which creates the session that this tool claims.

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 the timing ('After Stripe Checkout is paid') and the required inputs (purchase id and claim token), which implies this is used as the second step after create_agent_checkout_session. It does not explicitly mention alternatives or when not to use it, but the context is clear.

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

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

Annotation contradiction: The description says 'Create a real Stripe Checkout session', implying a state-changing write operation, but the annotations declare readOnlyHint=true. This is a serious inconsistency, making the tool's behavior misleading. The description does not add any additional context about side effects, payment authorizations, or idempotency beyond the contradictory annotation.

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

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

The description is two concise sentences, front-loaded with the core action and outcome. Every word earns its place; no fluff or repetition. This is an example of efficient, high-signal writing.

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 primary purpose and return value, but with 13 parameters and no required fields, more context is needed about the typical flow (e.g., prerequisite of obtaining a quote_id, relationship to claim_agent_checkout_key). The output schema exists, so return details are not required, but the description is minimal and does not fully guide an agent on how to invoke the tool correctly in a broader workflow.

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

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

The input schema provides descriptions for 92% of parameters, including details like quote_id from get_agent_billing_quote and mandate_id for scoped production. The description adds no extra parameter-level meaning beyond the schema. Baseline of 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 clearly states the tool's action: creating a real Stripe Checkout session for buying Toofi internal credits. It includes the resource (Stripe Checkout session) and the specific outcome (returns a claim token for later key retrieval). This distinguishes it from sibling tools like claim_agent_checkout_key and get_agent_billing_quote.

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

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

The description implies a sequence (get quote -> create checkout -> claim key) but doesn't explicitly state when to use this tool vs alternatives. No exclusions or alternative tool names are mentioned. The purpose is clear, but the 'when to use' context is only inferred, not 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=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description adds context about the nature of the output (capabilities, links, safety boundary, billing rails), which is useful beyond the structured annotations and helps set expectations for the 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 a single, front-loaded sentence that wastes no words. It precisely names the verb and the objects, making it easy to parse and act on.

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 discovery tool with an output schema, the description sufficiently outlines the scope of results (capabilities, links, safety boundary, billing rails). It does not mention return value specifics, but the output schema covers that responsibility. The description could be slightly richer about the tool's role as an entry point, but it remains 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 its 6 optional parameters, including their purposes. The description itself adds no parameter-specific semantics, so it relies on the schema. Given the baseline for high coverage is 3, this 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 the specific verb 'Discover' and explicitly names the resource: 'Toofi agent-native dental planning capabilities, links, safety boundary, and billing rails.' This clearly distinguishes it from sibling tools like `get_status` or `list_plans`, which cover specific data rather than overall capabilities.

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

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

The description implies usage as a discovery mechanism for agent capabilities, but it does not explicitly state when to prefer this tool over alternatives or provide exclusion criteria. The title and description make the primary use case obvious, but there is no guidance on prerequisites or when not to use it.

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

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

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds the context that the artifact is 'cached,' which explains why it's safe and idempotent. No additional behavioral traits 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?

Two short sentences front-load the action and include only essential clarification about the naming convention. No unnecessary words.

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

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

For a simple no-required-param demo tool with a full output schema and read-only annotations, the description is sufficient. It could mention that parameters are optional, but the schema already indicates that.

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 all parameters are described in the schema. The description adds no parameter-specific meaning, but the baseline of 3 is appropriate since the schema carries the full burden.

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 the verb 'Return' with a specific resource 'cached English Toofi example PDF artifact,' making the action and scope explicit. It also distinguishes from siblings by noting the underscore naming variant and the English language.

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 (returning the English example PDF) but does not explicitly state when to use it over sibling tools like example_pl or get_example_result. The 'Same as example-en' note is about naming, not usage context.

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

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

Annotations already mark this as read-only, idempotent, and non-destructive. The description adds 'cached,' implying a fast, pre-generated artifact, and specifies it's a PDF, giving useful context beyond the annotations.

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

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

The description is a single sentence, immediately front-loaded with the action and resource, with no redundant wording.

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 cached artifact retrieval with a full output schema and strong annotations, the description covers the essential purpose. It doesn't explain what the PDF contains, but that is likely covered by the output schema.

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

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

Schema description coverage is 100%, with all six parameters documented. The description does not add any parameter-specific guidance, so the baseline score 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 uses the specific verb 'Return' and identifies the resource as 'the cached Polish Toofi example PDF artifact,' clearly distinguishing it from sibling tools like example_en and example_ru by specifying Polish.

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 indicates this tool is for retrieving the Polish example PDF, and the sibling list shows other language variants, making the context clear. However, it does not explicitly mention when to use this over alternatives or any exclusions.

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

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

The annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds 'cached', which indicates the tool returns a pre-generated artifact rather than dynamically computing one—useful behavioral context beyond annotations. No contradictions with annotations are present.

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 concise sentences, front-loaded with the primary action and resource. The naming clarification is essential and included without unnecessary verbosity.

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

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

For a simple cached example tool, the description combined with the rich annotations, full schema coverage, and output schema provides a complete picture. There is no missing information that would impede correct invocation.

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

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

All 6 parameters have detailed descriptions in the schema (100% coverage), so the baseline is 3. The description itself adds no parameter-specific meaning, which is acceptable given the schema fully documents them.

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

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

The description clearly states a specific action ('Return') and a specific resource ('the cached Russian Toofi example PDF artifact'). It differentiates from sibling language-specific tools by naming Russian, and also clarifies the naming convention relative to the human-facing hyphenated version.

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

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

The description provides context that this is the MCP-safe name for what would otherwise be 'example-ru', implying when to use this tool. It does not explicitly mention alternatives for other languages, but the sibling list and title make the language-specific usage clear.

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

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

The description adds the behavioral trait 'cached', indicating the artifact is pre-generated rather than computed on demand. This goes beyond the annotations, which only declare readOnly, idempotent, and non-destructive hints. No negative traits are disclosed but none are needed given 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?

A single, direct sentence that immediately conveys what the tool does. No filler words, no redundant detail. The structure is optimal for a simple retrieval operation.

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

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

For a simple tool returning a cached artifact, the description covers the core purpose and language. The presence of an output schema and detailed annotations means the description does not need to explain return values or safety. The only minor gap is no explicit mention of whether the PDF is returned inline or as a link, but the output schema likely covers that.

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 describes all 6 parameters (100% coverage), so the baseline is 3. The description adds no additional parameter meaning, but the 'cached' nature implies parameters likely don't affect the returned artifact. Since all parameters are optional and generic context IDs, the lack of parameter-specific detail is acceptable.

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

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

The description clearly states the action ('Return') and the specific resource ('cached Slovak Toofi example PDF artifact'). The word 'Slovak' distinguishes it from sibling example_* tools such as example_en or example_pl, 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?

Usage is implied via the word 'Slovak' in the description and title, indicating it is for Slovak-language examples. However, no explicit comparison or guidance is given for when to choose this over sibling tools like example_en or get_example_result, and there are no exclusions mentioned.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds the context that the artifact is 'cached', which is a useful behavioral trait beyond the annotations. No contradiction or missing major behavioral details.

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

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

The description is a single sentence, front-loaded with the action ('Return') and object, with no wasted words. It is appropriately concise for the simple tool.

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

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

For a simple read-only cache retrieval tool, the description is complete. It covers the purpose, the caching nature, and the intended audience. Output schema exists, so return values are documented elsewhere, and annotations cover the safety profile.

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 six optional parameters, each with its own schema description, so the baseline is 3. The tool description does not add any parameter-specific meaning beyond what the schema already provides.

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

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

The description clearly states the tool returns a cached Ukrainian Toofi example PDF artifact, using 'return' as the verb and specifying the resource. It distinguishes itself from sibling language example tools by explicitly mentioning the 'ua alias', though slight ambiguity with example_uk remains.

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 agent integrators who requested the ua alias, but it does not explicitly state when to use this tool versus alternatives like example_uk or get_example_result. No clear exclusions or alternative references are 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 declare the tool as read-only, open-world, idempotent, and non-destructive. The description adds useful context by stating the artifact is 'cached' and an 'example', clarifying that it returns an existing artifact rather than performing computation. No contradiction found.

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

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

A single, direct sentence states the action and its object with no filler. The description is appropriately sized 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?

This is a simple cached artifact retrieval with no required parameters, rich annotations, complete schema coverage, and an output schema. The description fully supports correct selection and invocation without needing extra behavioral or return-value 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?

Input schema covers all 6 parameters with 100% description coverage, so the schema itself provides full parameter meaning. The tool description adds no parameter-specific details, warranting the baseline score for high schema coverage.

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

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

The description uses a specific verb ('Return') and clearly identifies the resource ('cached Ukrainian Toofi example PDF artifact'). The language qualifier distinguishes it from sibling tools like example_en, example_pl, and example_ru.

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: one would call this when needing the cached Ukrainian example PDF. However, there is no explicit guidance on when to choose this over get_example_result or the other language-specific example tools, nor any when-not-to-use statement.

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 safety profile (readOnly=false, destructive=false, idempotent=true). The description adds valuable context about the async nature (operation ID for polling) and the pipeline steps, going beyond 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?

The description is a single sentence but efficiently packs purpose, process, and output. It is front-loaded with the key verb and resource, and every phrase is useful. Slightly dense but not wasteful.

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 (14 parameters, nested objects), the description gives a solid overview of the workflow and return type, relying on the output schema for return details. It could mention authentication prerequisites, but those are already in the 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 description coverage is 71%, so the schema already documents most parameters. The description adds no parameter-specific meaning and does not compensate for the undocumented parameters, 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 clearly states the tool starts the Toofi headless treatment-plan pipeline, creates a runtime plan, invokes AI generation, and returns an operation ID for polling. This distinguishes it from siblings like generate_treatment_plan_draft and get_dental_plan_operation_status.

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

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

It provides clear context that this is the 'real' production pipeline for generating a patient-facing PDF, implying use for final outputs rather than drafts. However, it does not explicitly state when not to use it or name alternative tools, 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 provide idempotency and non-read-only hints. The description adds behavioral context about signed audit and C2PA-provenanced output surface, which goes beyond annotations. It doesn't mention potential side effects or permission requirements, but given the annotation coverage, this is a solid 4. No contradiction exists.

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

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

The description is a single sentence that immediately states the action and resource, and contains no filler words. Every phrase adds value: patient-facing, Toofi, signed audit, C2PA-provenanced. It is exceptionally concise 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?

Despite an output schema and annotations, the tool has nine parameters and many siblings. The description is too brief to cover when to use it, how it relates to other generation tools, or what a 'Toofi presentation' is. The complex context demands a more thorough description.

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 with all nine parameters described. The description itself doesn't add parameter-specific meaning beyond the schema; the phrase 'from a treatment plan' loosely maps to plan_id/plan_ref but doesn't elaborate. Baseline of 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 clearly states it generates a patient-facing Toofi presentation from a treatment plan, with specifics about signed audit and C2PA provenance. This distinguishes it from sibling generation tools, but it doesn't explicitly name alternatives or explain what a Toofi presentation is, so it falls short of a 5.

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

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

There is no guidance on when to use this tool versus siblings like generate_treatment_plan_draft or generate_dental_treatment_plan_pdf. It lacks any context about prerequisites, exclusions, or preferred scenarios. Usage is only implied by the purpose statement.

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, idempotentHint=true, and destructiveHint=false. The description adds no extra behavioral context such as side effects, idempotency implications, or external service interactions. It does not contradict the annotations but also fails to add value beyond 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, direct sentence that front-loads the action and resource. It contains no unnecessary words and is easy to parse.

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

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

Despite good schema coverage and annotations, the description is too sparse for a tool with 9 optional parameters, openWorldHint, and several related siblings. It does not explain when to use this tool, how it differs from similar tools, or what the openWorldHint implies for execution. The output schema exists, so return values are covered, but usage context is lacking.

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 9 parameters, so the baseline is 3. The description only vaguely mentions 'treatment-plan and clinic pricing inputs' without explaining specific parameters like plan_id, clinic_id, or request_id. It adds minimal semantic value over 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 action 'Generate a Toofi price estimate' and mentions the inputs 'from treatment-plan and clinic pricing inputs.' This is a specific verb+resource statement. However, it does not differentiate from the sibling tool 'get_agent_billing_quote', which could also relate to pricing.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor any prerequisites or conditions. For example, it does not clarify the relationship between 'generate_price_estimate' and 'get_agent_billing_quote', leaving the agent without direction for tool selection.

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

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

Annotations already cover readOnly=false, destructive=false, and idempotent=true. The description adds 'no-memory' (stateless behavior) and 'dentist approval boundary' (workflow constraint), which go beyond the annotations. It does not detail failure modes or side effects, but the idempotency hint mitigates retry concerns.

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

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

The description is a single sentence that front-loads the tool's purpose and lists all key output facets without filler. It is dense but concise, and every element contributes to understanding the tool's scope.

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

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

The description captures the tool's output shape (visits, estimate, presentation outline, billing metadata, audit receipt, approval boundary) and 'no-memory' behavior. An output schema exists, so detailed return structure is covered there. It could mention failure cases or required inputs, but it is sufficient for tool selection.

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

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

Schema description coverage is 77%, and several parameters have individual descriptions (request_id, clinic_id, patient_ref, chief_complaint). The tool description does not add parameter-specific detail, but the baseline 3 applies because the schema handles most parameter semantics. 'No-memory' hints at request-scoped data but not tied to any parameter.

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

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

The description uses a specific verb and resource: 'Generate a structured no-memory Toofi treatment-plan draft'. It enumerates the draft's contents (visits, estimate, presentation outline, billing metadata, audit receipt shape, dentist approval boundary), which distinguishes it from sibling tools like generate_price_estimate and generate_dental_treatment_plan_pdf.

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

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

The description implies usage when a full treatment-plan draft is required, but it does not explicitly state when to use this tool versus alternatives such as generate_price_estimate or generate_patient_presentation. No exclusions or alternative guidance are 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?

Discloses that the quote is deterministic and enumerates output fields (TTL, payment rails, Stripe command, x402 fields), adding detail beyond the readOnlyHint/idempotentHint annotations. No contradictions.

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

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

One sentence with concrete details, front-loaded with the primary action and object. 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 output schema and annotations, the description provides sufficient core context (determinism and response components) for a simple quote operation. Some explanation of when to use versus checkout tools is missing, but not required for this dimension.

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 78%, so baseline is 3. The description does not add any parameter-level meaning; it only mentions 'agent tool call' conceptually without mapping to specific params like tool_name or units.

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 specifies 'Get a deterministic Toofi internal-credit quote for an agent tool call' with a concrete verb and resource, and lists distinct output components (TTL, payment rails, Stripe checkout command) that differentiate it from sibling tools like get_agent_credit_balance.

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

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

Provides no explicit when-to-use guidance or comparison to alternatives such as create_agent_checkout_session or get_agent_credit_balance. Usage is only implied by the tool name and 'for an agent tool call'.

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, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is fully covered. The description adds scoping context ('agent or clinic mandate') but no additional behavioral details such as authentication requirements or side effects. No contradiction with annotations.

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

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

The description is a single, focused sentence with no filler or redundancy. It front-loads the action and resource immediately, making it highly scannable.

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

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

The tool has an output schema and comprehensive parameter documentation, so the description need not explain return values or parameter details. It captures the core purpose and scope, though a brief usage note would improve completeness; given the rich structured data, the current description 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 description coverage is 100% with all 10 parameters individually described. The description adds no extra meaning to any parameter, but the schema already provides complete documentation, 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 uses the verb 'Get' with a specific resource 'Toofi internal credit balance' and clearly scopes it to 'an agent or clinic mandate'. This distinguishes the tool from the sibling get_agent_billing_quote, which would provide a quote rather than a balance.

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

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

The description provides no guidance on when to use this tool over alternatives like get_agent_billing_quote. There are no explicit when/when-not conditions or exclusions, leaving the agent to infer usage solely from the tool 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 declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds value by clarifying the data is 'public no-PHI' and that it returns a single demo record, which informs the agent about access safety and result cardinality beyond the raw 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, concise sentence that front-loads the core function and key qualifiers. Every word ('public', 'no-PHI', 'demo') earns its place 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?

With strong annotations, a fully described 7-parameter schema, and an output schema, the brief description is largely sufficient. It explains the nature of the data (public, no-PHI, demo) and the result cardinality ('one'), but could have briefly noted the default patient_id behavior, which is already in the 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 description coverage is 100%, so the schema fully documents parameters. The description adds no additional parameter meaning, but the baseline of 3 is appropriate given the schema handles 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 uses a specific verb ('Get') and resource ('one public no-PHI Toofi demo patient'), clearly distinguishing it from siblings like get_patient (real patient) and list_demo_patients (plural). It also specifies the scope (single demo record) and data sensitivity (no-PHI).

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 by highlighting 'public no-PHI' and 'demo', implying it is for safe, non-production use. It does not explicitly name alternatives or exclusions, but the contrast with get_patient and list_demo_patients is implied through the name and description.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds valuable context by noting the plan is public and no-PHI, and that it includes an estimate and dentist approval boundary, enriching the agent's understanding beyond structured hints.

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 with no wasted words. It front-loads the action ('Get') and immediately specifies the key qualifiers (public, no-PHI, demo, estimate, approval boundary).

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 strong annotations, fully documented parameter schema, and presence of an output schema, the description provides sufficient context. It communicates the single-item demo scope and key content features, making the tool understandable without ambiguity.

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

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

The input schema provides 100% coverage with descriptions for all 7 optional parameters. The description does not add parameter-specific details, relying on the schema. This matches the baseline for 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 clearly states the tool retrieves one public no-PHI demo treatment plan with estimate and dentist approval boundary. It uses a specific verb and resource, and differentiates itself from siblings like get_plan and list_demo_plans by emphasizing 'demo' and 'one'.

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

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

The description implies usage for demo scenarios through the word 'demo' and 'public no-PHI', but does not explicitly state when to use it versus production alternatives or list tools. It offers no exclusion criteria 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 already declare read-only, idempotent, open-world, and non-destructive behavior. The description adds valuable context beyond those hints: the data is 'public no-PHI' and the result includes 'provenance surface fields.' This meaningfully enriches the agent's understanding of what the tool returns and its data sensitivity.

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 is specific and free of filler. Every phrase earns its place by conveying the tool's scope (one, public, no-PHI, demo) and output focus ('provenance surface fields').

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 rich annotations and full schema coverage, the description is adequately complete for a simple read-only getter. It does not need to explain return values because an output schema exists. Minor gap: it could state that this is the preferred alternative to generate_patient_presentation for demo data, but overall it 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 description coverage is 100%, so the baseline is 3. The description itself does not detail individual parameters, but the phrase 'with provenance surface fields' hints at the purpose of the many correlation/id parameters (e.g., request_id, mandate_id). This is a slight semantic bonus but does not exceed the baseline substantially.

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

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

The description clearly states the action ('Get'), the resource ('one public no-PHI Toofi demo patient presentation shape'), and the distinguishing qualifiers ('demo', 'provenance surface fields'). This differentiates it from sibling tools like generate_patient_presentation, which implies creation rather than retrieval.

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: this is for retrieving a public, no-PHI demo presentation shape. It implies use for demo scenarios and suggests non-production data. However, it does not explicitly name alternatives or state when not to use it, so it stops short of full exclusionary 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 cover the safety profile (readOnly, idempotent, non-destructive). The description adds the polling behavior ('Poll... until completed'), which implies a long-running or blocking operation, but does not disclose timeout, error handling, or response behavior. This adds some context beyond annotations but not rich detail.

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 with a front-loaded verb and no filler. Every word contributes to the purpose and outcome.

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 (15 parameters, nested objects) and the presence of a rich output schema and annotations, the description sufficiently covers the high-level purpose and polling behavior. It could mention potential blocking nature more explicitly, but overall it is complete enough with the existing structured metadata.

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 93%, and the schema already provides meaningful descriptions for key parameters (e.g., 'Toofi plan id returned by generate_dental_treatment_plan_pdf'). The description adds no parameter-specific semantics, so the baseline 3 applies.

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

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

The description clearly states the verb 'Poll', the resource 'a Toofi headless treatment-plan operation', and the success condition 'until AI planning is completed and ready for presentation/PDF delivery.' This distinguishes it from generic status tools like get_status by specifying the operation type and goal.

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

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

The description implies the tool is used after an operation has been initiated, but it does not explicitly name the initiating tool (e.g., generate_dental_treatment_plan_pdf) or mention alternatives/exclusions. It provides context ('poll... until AI planning is completed') but lacks explicit when-to-use guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context beyond annotations: the artifact is 'stable' and 'public' and explicitly notes that no generation occurs at call time, which signals instant, side-effect-free response.

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

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

Two sentences, front-loaded with the primary action and unique value. Every word earns its place: 'stable public PDF artifact', 'shows what Toofi produces', and 'No generation is run at call time' all convey essential 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?

For a simple read-only demo tool with 0 required parameters and a full output schema, the description is sufficient. It explains what the tool returns, the example content, and the key behavior (no generation), making it complete for an agent to decide when and how to invoke it.

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

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

Schema description coverage is 100%, so the schema already documents all 8 parameters including the language enum. The description doesn't add parameter-level detail, but it isn't required given the schema's thoroughness. 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 uses a specific verb ('Return') and identifies the exact resource ('stable public PDF artifact') plus its content (a patient-facing treatment-plan presentation for a missing tooth 11/root 11 example). This clearly distinguishes it from sibling tools like generate_dental_treatment_plan_pdf or example_* variants by emphasizing it's an artifact showing Toofi's output.

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

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

The description provides clear context: it returns a pre-existing public PDF without running generation, implying it's for demonstration/reference rather than actual generation. It doesn't explicitly name alternatives like generate_dental_treatment_plan_pdf, but the contrast with 'No generation is run at call time' makes the intended use case evident.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive safety, so the description carries little burden. It adds only the 'mandate rails' concept, which hints at authorization requirements without specifying 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?

Single sentence of 11 words, front-loaded with the primary action and resource. No filler; every word either specifies the operation or scopes its context.

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

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

Despite having 9 optional parameters and an output schema, the description is minimal. It doesn't clarify parameter grouping or how to choose between this and sibling tools, but the schema and annotations cover most structural needs.

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 each of the 9 parameters is already described. The description doesn't add further semantic detail about parameters, maintaining the baseline for 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 uses specific verb 'Get' with resource 'one clinic patient', distinguishing from list_patients and get_demo_patient. The qualifier 'clinic' separates it from demo context, though 'mandate rails' is jargon but doesn't obscure 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 explicit when-to-use or alternatives are named, but 'through Toofi agent-native mandate rails' implies a mandate-scoped context. It doesn't provide exclusions like 'use list_patients for multiple patients'.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior; the description adds only the 'agent-native mandate rails' context, which is vague and does not disclose processing details, error behavior, or permission nuances. No contradiction with annotations, but minimal additional value beyond 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, front-loaded sentence with a clear verb and object. It is appropriately concise for a simple get operation, avoiding unnecessary detail.

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

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

For a tool with 9 optional params and an output schema, the description is minimal. It does not explain 'mandate rails' or clarify parameter selection, but the existing schema and annotations cover safety and basic return structure. The description leaves some ambiguity about the mandate model, making it only minimally 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 each parameter already has descriptive text. The description itself adds no parameter-specific meaning, but the baseline of 3 is appropriate given the schema fully documents all 9 optional parameters.

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

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

The description clearly specifies the action ('Get'), the resource ('one Toofi treatment plan'), and the scope ('one'), distinguishing it from sibling tools like list_plans and get_demo_plan. Though 'agent-native mandate rails' is jargon, it still conveys a specific retrieval operation.

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

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

The description gives no explicit guidance on when to use this tool vs alternatives (e.g., get_demo_plan, list_plans). The phrase 'mandate rails' hints at a context but does not state when to prefer this over other plan-retrieval tools or what conditions must hold.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is known. However, the description adds no additional context about what the status includes, how it is scoped, or any side effects. It provides no value 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 very short ('Get Toofi agent workflow status.'), so it is concise in terms of word count. However, it is under-specified for a tool with 9 parameters and many siblings, and the brevity reduces its usefulness.

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 (9 parameters, no required fields, many siblings), the description is insufficient. It does not explain the intended usage context, how the parameters relate to each other, or when to prefer this over similar status tools. The presence of an output schema helps, but the description still leaves significant gaps.

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

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

The schema descriptions cover all 9 parameters (100% coverage), so the baseline is 3. The tool description itself does not add any parameter-level meaning, relying entirely on the schema for 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 'Get Toofi agent workflow status' clearly identifies the verb (Get) and resource (Toofi agent workflow status), making the tool's purpose understandable. However, it does not explicitly distinguish this from the sibling tool 'get_dental_plan_operation_status', which could lead to confusion about which status-tool to 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?

There is no guidance on when to use this tool versus alternatives such as get_dental_plan_operation_status or list_plans. The description is a single sentence with no context about typical use cases, prerequisites, or exclusions, leaving the agent to infer usage from the schema 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?

The description adds no behavioral information beyond the annotations. It doesn't disclose that the tool runs in dry-run mode by default (from the schema) or describe the mapping process or side effects. With annotations lacking such specifics, the agent is left uninformed about important execution 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, focused sentence with no filler, front-loading the core action and target.

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 an output schema and substantial annotations, the description is too sparse for a 9-parameter tool. It omits the crucial dry-run default behavior and the meaning of 'map', making the description inadequate for a complete understanding of 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?

The schema provides descriptions for 89% of parameters, so the baseline is 3. The description does not add any parameter-specific meaning, such as explaining the relationship between csv_text and file_url, but the schema already covers the basics.

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 imports and maps a clinic price CSV into Toofi pricing configuration, using specific verbs and resources. It differentiates from sibling tools like generate_price_estimate or get_agent_billing_quote, which deal with pricing outputs rather than CSV imports.

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

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

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention scenarios, prerequisites, or exclusions, leaving the agent without context for choosing it over other pricing-related tools.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds no additional behavioral details such as constraints, ordering, or pagination. It adds slight context with 'signed' and 'provenance records' but not beyond the annotations' coverage.

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

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

A single, complete sentence that immediately states the action and object. No filler, no repetition of schema information, and the most important information is front-loaded.

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

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

With 9 optional parameters, an output schema, and rich annotations, the description is sufficiently complete. It clearly defines the tool's scope, and the schema handles parameter details. A minor gap is not explaining how the optional parameters combine as filters, but this is not critical.

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

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

Schema description coverage is 100%; all 9 optional parameters are individually documented in the schema. The description adds no additional parameter-level meaning, so the baseline 3 applies.

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

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

The description uses the specific verb 'List' with a clear resource: 'signed Toofi agent invocation receipts and provenance records.' This precisely identifies the tool's function and differentiates it from sibling list tools like list_plans or list_patients.

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

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

The description states what the tool does but provides no explicit guidance on when to use it versus alternatives, nor any exclusions or context. Usage must be inferred from the name and description, placing it at 'implied usage.'

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds that patients are 'public no-PHI', which is useful data-sensitivity context but not a rich behavioral trait like auth requirements or side effects. With annotations covering safety, a score of 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, front-loaded sentence of 12 words that clearly states the action and purpose. Every word earns its place with no redundancy or filler.

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

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

Given the simple list operation, the presence of an output schema, and comprehensive annotations, the description is nearly complete. It explains the tool's purpose and data type (demo, no-PHI). A minor gap is not explicitly mentioning the distinction from production tools like list_patients, but the 'demo' label makes it sufficiently clear.

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?

All 6 parameters have full descriptions in the schema (100% coverage), so the description does not need to repeat parameter info. The description adds no parameter-level meaning, which aligns with the baseline of 3 for high schema coverage.

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

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

The description uses a specific verb ('List') and clearly identifies the resource ('public no-PHI Toofi demo patients') with a stated purpose ('so agents can inspect patient response structure'). This distinguishes it from siblings like list_patients and get_demo_patient.

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 demo/inspection scenarios and explicitly notes that data is public and contains no PHI, which differentiates it from production tools. However, it does not explicitly name alternatives or state when not to use it, though the 'demo' label provides 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 readOnly, openWorld, idempotent, and non-destructive behavior. The description adds valuable context: 'public' (visibility) and 'no-PHI' (privacy guarantee), which goes beyond the annotations. It does not contradict the annotations, and the added information is material for compliance.

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

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

The description is a single, information-dense sentence. It front-loads the verb and resource, and every word adds value ('public', 'no-PHI', 'Toofi', 'demo', 'treatment plans'). 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 simple listing tool with a full output schema, strong annotations, and 100% schema coverage, the description provides all necessary context: domain (Toofi), environment (demo), privacy level (no-PHI), and visibility (public). No gaps are evident.

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 all six parameters have clear descriptions. The tool description itself adds no parameter-specific meaning, 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 uses a specific verb 'List' and identifies an unambiguous resource: 'public no-PHI Toofi demo treatment plans.' This clearly distinguishes it from sibling tools like list_plans (production plans) and get_demo_plan (single plan retrieval).

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

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

The phrase 'public no-PHI Toofi demo treatment plans' implies this is for demo contexts, differentiating from non-demo listing tools. However, it lacks explicit guidance like 'use list_plans for production plans' or exclusions, so it earns a 4 rather than a 5.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint:false, which cover the safety profile. The description adds the vague phrase 'mandate rails', which suggests authorization constraints but does not explain what that entails. No contradiction with annotations, but the behavioral disclosure beyond annotations is minimal and unclear.

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

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

The description is a single concise sentence, front-loaded with the core action. However, the phrase 'through Toofi agent-native mandate rails' is jargon that adds little and could confuse. It is efficient but slightly flawed due to unnecessary vague wording.

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 9 optional parameters, an output schema, and rich annotations, the tool is reasonably specified structurally. However, the description does not explain the mandate context, when certain parameters are needed (e.g., mandate_id optional in demo mode), or how this differs from sibling tools. Thus it is adequate but incomplete for an agent to fully leverage it.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds no semantic value to parameters; it does not explain how 'mandate rails' relates to fields like mandate_id, clinic_id, or agent_id. Baseline of 3 applies because the schema carries the full burden.

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 core action: 'List clinic patients' — a specific verb with a resource. It implies distinction from demo tools like list_demo_patients via the word 'clinic', but does not explicitly name alternatives. The trailing phrase 'through Toofi agent-native mandate rails' is vague but does not obscure the primary 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 provided on when to use this tool vs. alternatives such as list_demo_patients, get_patient, or list_plans. The description does not mention context, exclusions, or required conditions like mandate scope. The word 'clinic' hints at production use, but this is not explicit.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior, so the bar is lower. The description adds the 'agent-native mandate rails' phrase, which implies the operation is scoped by mandates (clinic_id, mandate_id, principal_id), a useful behavioral context. However, it does not disclose other traits like pagination, ordering, or error behavior – though the output schema may cover return values.

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: 'List Toofi treatment plans through agent-native mandate rails.' Every word earns its place; there is no filler or repetition of structured data. It is appropriately concise for a read-only listing operation.

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 (9 optional params, output schema, robust annotations), the description is adequate but incomplete. It does not explain what 'agent-native mandate rails' means or distinguish from sibling listing tools (list_demo_plans, list_patients). The phrase could confuse an agent without domain knowledge. The output schema covers return values, but usage context is missing.

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

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

The input schema provides 100% coverage with descriptions for all 9 parameters, including purpose and optionality. The description adds no parameter-specific meaning beyond the schema. Per the rubric, baseline 3 applies when schema coverage is high, and the description does not need to compensate further.

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 and resource: 'List Toofi treatment plans' – this is specific and distinct from siblings like get_plan (single plan) or list_demo_plans (demo data). The added phrase 'through agent-native mandate rails' hints at the access scoping, though it is jargon-y. No explicit sibling differentiation, but the core purpose is unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that get_plan retrieves a single plan or that list_demo_plans is for demo data, nor does it state any prerequisites (e.g., mandate context). The agent must infer usage from the tool name and sibling list, which is insufficient.

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

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

Annotations already state read-only, open-world, idempotent, and non-destructive behavior. The description adds the 'No PHI' constraint, which is a meaningful behavioral trait beyond annotations, and hints at output semantics with 'pricing anchors'.

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

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

The description is two short sentences: the first states the core mapping function with a strong verb, and the second adds the essential PHI note. No wasted words or 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?

With an output schema present and comprehensive parameter descriptions, the description provides sufficient context for an agent to understand the tool's role. The PHI note adds valuable safety context, though it could elaborate on what 'pricing anchors' means in practice.

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 all 11 parameters including aliases clearly documented. The description does not add parameter-specific details beyond the natural-language query concept, so the baseline score is appropriate.

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

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

The description uses the specific verb 'Map' and clearly identifies the source (natural-language dental procedure query) and target (structured Toofi procedure catalog entries and pricing anchors). It also adds 'No PHI' as a privacy boundary, distinguishing its purpose from other dental 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 use for converting natural-language queries into structured catalog entries but provides no explicit when-to-use guidance or comparison with sibling tools like generate_price_estimate. It neither excludes nor recommends alternatives, so usage is only implied.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, which safely cover the behavioral profile. The description adds minimal extra context beyond restating the schema preview purpose, so it meets the baseline but doesn't enrich behavioral disclosure.

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, clear sentence that front-loads the main purpose. It is free of redundant information and earns its place without unnecessary detail.

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

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

For a simple read-only preview tool with no required parameters and an output schema provided, the description is sufficiently complete. It clearly explains what is previewed, though slight elaboration on its relationship to plan generation could improve contextual grounding.

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 high (86%), and the input schema provides detailed descriptions for most parameters. The description does not add any meaning beyond the schema fields, so the baseline of 3 is appropriate.

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

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

The description clearly states 'Preview the structured Toofi treatment-plan draft response schema' with a specific verb ('Preview') and resource ('response schema'). It distinguishes itself from sibling tools like generate_treatment_plan_draft which actually generate plans, whereas this tool exposes the schema.

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

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

The phrase 'for agent-native clinical workflows' gives some context about intended usage, but there is no explicit guidance on when to use this tool versus alternatives, such as naming generate_treatment_plan_draft as the complementary tool. It lacks clear exclusions or alternative comparisons.

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 some safety info (idempotent, non-destructive), but the description adds little beyond the verb 'Start'. It does not explain what the workflow entails, whether it creates a long-running operation, or what side effects are expected. No contradiction with annotations, but the behavioral disclosure is shallow.

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

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

The description is a single concise sentence with the action front-loaded. However, the trailing phrase 'under agent-native clinical planning rails' is vague and detracts from clarity, though it does not bloat the description significantly.

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 9-parameter complexity and the domain (dental clinical workflows), this description is too sparse. It does not explain how the markup workflow connects to existing plans, whether a plan must already exist, or what 'clinical planning rails' mean. The output schema may cover return values, but the description alone leaves major context 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?

All 9 parameters are fully described in the input schema with clear definitions, so the description carries no additional parameter semantics. The baseline of 3 applies because the schema fully compensates for any missing parameter explanation.

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 ('Start') and the resource ('Toofi panoramic X-ray markup workflow'), making the purpose unambiguous. It also stands apart from all sibling tools, which are predominantly get/list/generate actions, and the title reinforces the intent.

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 guidance is given on when to use this tool versus alternatives. The description does not mention prerequisites, conditions, or situations where this tool should be avoided. The phrase 'under agent-native clinical planning rails' is jargon and offers no usable direction.

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