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

Annotations disclose read-only, idempotent, non-destructive behavior, but the description adds nothing beyond them. It does not clarify what a 'gap' represents, whether this is a report, or what the output rows mean.

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?

It is short, but short is not concise when it carries zero information. This is under-specification, not efficient 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?

For a tool with three optional parameters, an output schema, and many closely related siblings, a single noun phrase is completely inadequate. An agent cannot determine the tool's purpose, expected output, or relationship to coverage_summary/coverage_tutors.

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 meaningful descriptions for limit, subject, and min_tutors. The description itself contributes no parameter meaning, but the baseline of 3 applies because the schema already documents parameters well.

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 is exactly the tool name: 'Coverage Gaps', with no verb, no resource, and no behavior. It is a tautology and gives an agent no way to know what the tool computes or how to distinguish it from coverage_summary or coverage_tutors.

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 about when to use this tool versus its sibling coverage tools. No context, prerequisites, or exclusions are given, so the agent must guess from the name alone.

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

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

The description adds no behavioral context beyond the annotations. Annotations already communicate read-only, idempotent, and non-destructive behavior, but the description does not explain what the summary contains, how counts are aggregated, or how the optional filters affect the result.

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?

'Coverage Summary' is technically short, but it is under-specification rather than efficient communication. There is no useful content to front-load, so the structure provides no assistance to an agent.

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 annotations and an output schema, the description does not clarify what the tool computes, when it should be selected, or how it relates to coverage_tutors and coverage_gaps. An agent browsing the sibling list would be unable to confidently choose this tool over similar coverage-related tools.

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

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

Schema description coverage is 100%, so the input schema already explains both parameters: subject restricts counts, and postcode relates to tutor reach. The description itself adds no parameter information, but the high schema coverage makes this acceptable at baseline.

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

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

The description 'Coverage Summary' is a direct restatement of the tool name and provides no verb or specific resource. It does not distinguish coverage_summary from related siblings like coverage_tutors or coverage_gaps.

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

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

The description gives no guidance on when to use this tool, when not to use it, or what alternatives might be more appropriate. Sibling tools such as coverage_tutors and coverage_gaps are not mentioned, leaving the agent to guess the intended use case.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is known. However, the description adds zero behavioral context beyond the title, such as pagination behavior, filtering semantics, or how distance_km and covers_area are computed from postcode.

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 text is short, but this is under-specification rather than conciseness. A helpful description needs at least a verb and a resource phrase; 'Coverage Tutors' is merely a label. No sentence earns its place because there are effectively no contentful sentences.

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

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

The input schema and annotations are relatively rich, but the free-text description leaves the central purpose unstated. An agent cannot reliably distinguish this tool from coverage_summary or coverage_gaps, which is a major gap for a 6-parameter tool. The output schema may explain return values, but it does not compensate for the missing purpose.

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 in the input schema. Because the schema carries the full burden of parameter meaning, the baseline is 3 even though the tool description itself contributes no parameter information.

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 is only 'Coverage Tutors', which restates the tool's name/title and gives no verb or action. It does not say whether the tool lists, searches, computes, or manages tutors. The ambiguity is especially clear next to siblings like coverage_summary and coverage_gaps, which could also plausibly be described as 'coverage tutors'.

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 about when to use this tool versus alternatives such as list_tutors, coverage_summary, or coverage_gaps. The description neither states appropriate conditions nor rules out other tools. It provides no context at all, so an agent must guess from the name alone.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and non-destructive behavior, so the safety profile is covered. However, the description itself adds no behavioral context—it does not describe response behavior, error cases, or what it returns beyond the existing output schema. It neither contradicts nor enriches 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 extremely short, but this is under-specification rather than effective conciseness. It contains no useful information beyond the tool's name and does not earn its place as a standalone description.

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

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

The tool is simple, with one well-described parameter, rich annotations, and an output schema, so structural information is complete. However, the description fails to clarify the domain meaning of 'availability' or the intended relationship to list_availabilities, leaving an agent to rely on name inference.

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

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

Schema coverage is 100%: the single required parameter, availability_id, is described as an 'Availability rule UUID'. The tool description adds nothing about the parameter, so the schema carries the full semantic load and 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 'Get Availability' simply restates the tool name and annotation title. It identifies a verb and resource but gives no detail about what an availability rule is or how it differs from list_availabilities, so it borders on tautology.

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

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

No guidance is provided about when to call this tool instead of list_availabilities or any other sibling. There is no mention of context, prerequisites, or exclusions, leaving the agent to infer usage from the name alone.

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

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

The description adds no behavioral context beyond what annotations already state. Annotations declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, but the description does not add information about outcomes, errors, return behavior, or access requirements.

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, but it is under-specified rather than deliberately concise. It repeats the tool name without adding useful detail, so it does not earn its place as a helpful definition.

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

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

For a tool with one well-documented parameter, strong annotations, and an output schema, this is minimally viable. However, it lacks useful information about how it relates to list_blog_posts and when an agent should choose it.

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

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

The input schema fully documents post_id as a 'Blog post UUID' with 100% coverage. The description adds no additional meaning for the parameter, so the baseline of 3 is appropriate because the schema already carries the semantic weight.

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 operation ('Get') and resource ('Blog Post'), which is specific enough to indicate it retrieves a single blog post. However, it does not explicitly distinguish itself from siblings such as list_blog_posts, and it largely restates the tool name.

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

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

There is no guidance on when to use this tool vs alternatives. It does not mention that list_blog_posts should be used for fetching multiple posts, nor does it describe prerequisites or context for retrieving a single post.

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, so the safety profile is clear; the description does not contradict them. However, the description itself contributes no additional behavioral context such as error behavior, authorization requirements, or external data semantics, so it adds no value beyond 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 extremely short, but this is under-specification, not elegant conciseness: every word ('Get Classroom') duplicates the tool name and title and adds no independent information. There is no sentence structure or lead information beyond the title.

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

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

For a one-parameter read-only tool with a rich annotation set and an output schema, the definition is minimally usable: an agent can infer the required argument from the schema and the read-only safety. Yet it lacks any explanation of the resource, selection criteria, or relationship to list_classrooms, so it is not complete enough for confident use in ambiguous contexts.

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 100% of parameters, documenting classroom_id as a 'Classroom UUID', so the description need not repeat it. The description adds no extra meaning such as format examples or how to obtain the ID, but the baseline of 3 applies because the schema documentation is complete.

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

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

The description 'Get Classroom' is a tautology – it restates the tool name and title without adding any detail about what a classroom is, what fields are returned, or how it differs from sibling tools like list_classrooms. It names a verb and resource, but adds no discriminating information, so it only meets the definition of a restatement rather than a purposeful description.

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 call get_classroom versus list_classrooms or other get_* siblings. There is no context about classroom_id being required or scenarios where this lookup is appropriate. This is 'no 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 no behavioral context beyond those annotations, but it also does not contradict them.

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

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

At two words, the description is technically concise but is under-specified rather than efficiently informative. It reads as a label rather than a helpful definition, offering no detail to justify its place in the tool contract.

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 single-parameter schema, the presence of an output schema, and safety annotations, the lack of detail is partially mitigated. However, the description is still too sparse to independently guide an agent, especially with sibling list_invoices available and no clarification of the singular fetch behavior.

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

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

The input schema provides 100% coverage: the only parameter, invoice_id, is described as 'Invoice UUID'. The description adds no additional parameter meaning, but the schema fully documents the parameter, meeting the baseline.

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

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

The description 'Get Invoice' simply restates the tool name and title, adding no new information. It identifies a verb and resource but is essentially tautological, failing to explain what retrieving an invoice entails or how it differs from list_invoices.

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 usage guidance is provided. The description does not specify when to use this tool versus list_invoices or other get_* siblings, nor does it mention that this tool fetches a single invoice by ID.

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

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

The description discloses no behavioral traits beyond what the annotations already state (readOnly, idempotent, non-destructive, openWorld). It adds no extra context such as error behavior, return semantics, or how the openWorldHint affects lookup results.

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

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

The description is extremely short, but this is under-specification rather than genuine conciseness. It consists solely of a two-word restatement of the tool name and offers no structured information.

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

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

Even though the input schema and annotations are helpful, the description fails to explain what a lead is, how it fits into the domain, or how to obtain a valid lead_id. The tool cannot be correctly selected based on this description alone.

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

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

Schema coverage is 100% and the lead_id parameter is described as 'Lead UUID', so the schema already provides complete parameter documentation. The description adds no additional meaning, so the baseline of 3 applies.

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

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

The description 'Get Lead' is a pure restatement of the tool name and annotation title. It names a verb and resource but adds no detail about what a lead is or how this operation is distinguished from the many sibling get_* 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?

There is no guidance about when to use this tool versus alternatives such as list_leads or other get_* tools. No context, preconditions, or exclusions 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 readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, so the safety profile is established. However, the description adds no behavioral context beyond the annotations, such as what the participant represents, whether lookup failures return null, or any relationship to lessons.

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

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

The description is extremely short, but this is under-specification rather than effective conciseness. It repeats the tool name and provides no useful information to the agent.

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?

Although the output schema exists and annotations are rich, the description still fails to explain what a lesson participant is, how this tool differs from similar get_* tools, or any context about the lookup. A simple single-parameter getter could be adequately described in one or two sentences, but this provides none of that value.

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% because participant_id is described as 'Lesson participant UUID'. The description adds no extra parameter meaning, but the schema already fully documents the only parameter, so the baseline of 3 applies.

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

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

The description is exactly the tool name, 'Get Lesson Participant', which is a tautology. It states no verb beyond the name and does not distinguish this tool from the many sibling get_* tools such as get_student, get_session, or get_availability.

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 about when to use this tool versus alternatives like list_lesson_participants or other get_* tools. The description provides no context, prerequisites, or exclusions, so an agent gets no help selecting 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?

The description adds no behavioral information beyond the annotations, which already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false. It does not describe pagination, authorization, or the meaning of openWorldHint in practice. No contradiction exists, but the description contributes nothing beyond what structured annotations provide.

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

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

The description is extremely short, but this is under-specification rather than effective conciseness. It has no structure, no front-loaded context, and no explanatory content; every useful bit of information comes from the schema and annotations, not the description.

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

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

The tool is a simple single-location getter with a well-covered schema, one required parameter, read-only annotations, and an output schema, so the structured data carries most of the burden. However, the description still fails to clarify what a location is in this domain or how it relates to list_locations, leaving a clear gap.

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

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

Schema description coverage is 100% and the only parameter, location_id, is already documented as a 'Location UUID'. The description 'Get Location' adds no additional meaning about the parameter, so it receives the baseline for high schema coverage rather than credit for extra 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 Location' simply restates the tool name and title, making it a tautology rather than an explanation. It does not specify what kind of location is returned, what scope it operates on, or how it differs from siblings like list_locations. This is exactly the restates-name/title case, not a meaningful purpose statement.

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 about when to call this tool versus the many sibling tools. It does not mention that it is the single-item counterpart to list_locations or state any conditions, prerequisites, or alternatives. An agent would have to infer usage entirely from the name and parameter schema.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and non-destructive behavior, so the safety profile is covered. However, the description itself adds no behavioral context beyond 'Get Me', such as what 'me' refers to, how the identity is determined, or what data is included.

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

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

The description is extremely short, but this is under-specification rather than efficient writing. 'Get Me' repeats the tool name and provides no additional structured or contextual information that helps an agent understand the 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?

Even for a simple zero-parameter read-only tool, the description is incomplete because it never defines what 'me' means in the API context. With dozens of sibling tools, this ambiguity could cause an agent to misuse or avoid the tool despite the annotations and output schema being present.

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

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

The tool has zero parameters, so there is nothing for the description to explain about arguments. The empty input schema is fully consistent with the tool's self-referential nature, and the baseline for a parameterless tool 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 'Get Me' merely restates the tool name and does not state what resource or object is returned. It is a tautology that fails to clarify whether this returns the current authenticated user, current session context, or something else.

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 usage guidance is provided. The description does not indicate when get_me should be used instead of sibling tools such as get_student, get_tutor, lookup_user, or get_session, leaving the selection entirely to inference.

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

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

The description discloses no behavioral traits beyond what the annotations already declare (readOnlyHint, openWorldHint, idempotentHint, destructiveHint). It adds no context about lookup behavior, response contents, or any side effects.

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

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

The description is extremely short, but this is under-specification rather than effective conciseness. It contains no meaningful structure or front-loaded detail that helps an agent decide to invoke the 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 get-by-id tool with annotations, a fully described parameter, and an output schema, the description is minimally sufficient. However, it lacks any context about the parent entity or when to use this tool, so it is only borderline 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?

Schema description coverage is 100%, and the single parent_id parameter is described as 'Parent UUID'. The description adds no parameter-specific details, 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 'Get Parent' merely restates the tool name, providing no additional specificity beyond what the name already conveys. It does not describe what a parent is, what data is retrieved, or how this differs from other get_* 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?

No usage guidance is given. The description does not state when to use this tool as opposed to get_student, get_tutor, get_session, or other sibling tools, and no exclusions or alternative recommendations 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 readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. However, the description itself adds no behavioral context beyond a generic 'get' – it does not explain what is returned, whether the record is ephemeral, or any additional effects, so it contributes nothing 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?

At two words, the description is technically concise but it is under-specified and doesn't earn its place: it just repeats the title. A useful description could add purpose and usage context with minimal length.

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

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

Even for a simple single-parameter get-by-id tool, the description is not complete. The schema and annotations cover the parameter and safety, but the description fails to explain the domain meaning of a payment or route the agent to the correct sibling tool, leaving an agent to infer when to use get_payment vs list_payments or get_payout.

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%; the only parameter, payment_id, is already documented as 'Payment UUID'. The description does not add parameter meaning, but the baseline of 3 applies when the schema fully covers 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 'Get Payment' merely restates the tool's name and title, making it a tautology. It identifies a verb and resource but provides no detail about what a 'payment' means in this domain or how this tool differs from siblings like list_payments or get_payout.

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

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

The description gives no guidance on when to use this tool versus alternatives. There is no mention of list_payments for retrieving all payments or get_payout for a related financial entity, and no conditions or exclusions are stated.

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

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

The description discloses no behavioral context beyond the word 'Get', and the annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false. No additional context about authentication, error behavior, or side effects is provided, so the description adds no value beyond the structured annotations.

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

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

Two words that merely repeat the tool name are under-specified rather than productively concise. Every token is redundant, and the description does not earn its place by adding information.

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

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

The tool is simple: one required UUID parameter, a read-only/idempotent/non-destructive annotation set, and an output schema are all present. However, the description itself leaves usage context and the relationship to list_payouts implicit, making it adequate only because the surrounding structured data compensates.

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 payout_id fully described as a required string 'Payout UUID'. The description itself adds no parameter insight, but the schema already carries the full burden, so the baseline of 3 applies.

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

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

The description 'Get Payout' is a verbatim restatement of both the tool name and title, making it a tautology rather than an explanation. It names a verb and resource but adds no distinguishing detail to separate it from sibling get_* tools such as get_payment or get_invoice.

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 about when to use this tool versus list_payouts or other payout-related tools. An agent must infer the intended usage entirely from the name and input schema, which is insufficient for confident 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?

The description adds no behavioral context beyond what the annotations already provide. It does not disclose return behavior, possible empty/open-world outcomes, authentication requirements, or any side effects. There is no contradiction with the annotations, but also no additional transparency from the description itself.

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

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

The description is extremely short, but it is under-specified rather than concise. It contains no useful content beyond the tool name, so it does not earn its place as a meaningful definition. A two-word tautology is not effective structure.

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

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

The context signals show an output schema and complete parameter schema, but the description still leaves the concept of 'Result' unexplained. In a large sibling family of get_* tools and domain-specific list_ tools, the description is not sufficient for an agent to understand what entity is being fetched or when this tool is relevant.

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

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

Schema coverage is 100%, and the sole parameter result_id is already documented as a "Result UUID". The description contributes no additional parameter meaning, but because the schema is complete, the baseline score 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 is exactly "Get Result", which merely restates the tool name and title. It does not explain what a Result is or what it represents in this domain, so it cannot be distinguished from the many sibling get_* tools such as get_session, get_payment, or get_student. This is a tautology rather than a meaningful purpose statement.

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 usage guidance whatsoever. The description does not state when to call get_result instead of finder tools like list_results, nor does it note any prerequisites, relationship to other entities, or conditions. The agent is left with no support for tool selection beyond the name.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true, and destructiceHint=false. The description adds no behavioral context beyond the word 'Get', which merely echoes the read-only nature already captured by annotations. It does not mention auth, rate limits, pagination, or return 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?

At only two words, the description is under-specified rather than concisely structured. It repeats the title and provides no additional substance for an agent to 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?

Although the tool is simple and has a single well-documented parameter plus an output schema, the description still lacks semantic context: what a session represents in this domain, how a session_id is obtained, and how this call differs from list_sessions. The agent could guess, but the description alone is incomplete.

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 fully covers the sole parameter with 'Session UUID' and 100% schema description coverage. The description adds no parameter information, but with full schema coverage the baseline of 3 is appropriate.

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

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

The description 'Get Session' restates the tool name and title exactly. It names an operation and resource but does not explain what a session is, what it returns, or how it differs from sibling tools like list_sessions.

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. There are no exclusions, conditions, or mentions of list_sessions or other get_* siblings, so the agent must infer usage from the name and required session_id.

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, so the safety profile is covered. However, the description adds no behavioral context beyond that, such as behavior on missing IDs, permission requirements, or whether the result is a single record or a wrapper object. It neither contradicts nor enriches 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 extremely short and has no filler, but it is under-specified rather than concisely informative. It merely repeats the title, so it does not earn its place as useful content for an agent.

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

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

The tool is simple: one required ID, an output schema, and annotations covering safety and idempotency, so much of the necessary context exists outside the description. However, the description itself provides no indication of what distinguishes a student from other entities or when this specific getter should be selected, leaving the agent to rely solely on naming conventions.

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 fully documents the single required student_id parameter with type and a 'Student UUID' description, so schema coverage is 100%. The description adds no additional parameter-level meaning, such as expected format or how to obtain the ID, but the baseline of 3 applies because the schema carries the 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 'Get Student' simply restates the tool name and title, making it a tautology rather than an informative statement of purpose. It contains a verb and resource but no scope, no detail about what is returned, and no differentiation from siblings like get_student_group or list_students.

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 offers no guidance on when to use this tool versus alternatives. It does not mention list_students, get_student_group, lookup_user, or any other sibling, nor does it describe conditions that would make this tool the appropriate choice.

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

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

The annotations already disclose readOnlyHint, idempotentHint, openWorldHint, and destructiveHint, so the safety profile is covered. The description itself adds no behavioral context beyond restating the operation, and it neither contradicts nor enriches 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 short, but it is under-specified: it merely restates the tool name rather than providing a structured, informative definition. It reads more like a label than a description.

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

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

Although the single parameter is well documented and the annotations are rich, the description itself provides no context about the entity, the lookup semantics, or when to prefer this getter over sibling list/get tools. The existing output schema does not compensate for the absence of usage context.

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

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

The schema fully documents the only parameter, group_id, as a student group UUID, so schema description coverage is 100%. The description adds no additional parameter meaning, but the schema carries the semantic burden, yielding the baseline score of 3.

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

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

The description exactly restates the tool name and title ('Get Student Group'), making it a tautology rather than a meaningful definition. It does not say what a student group is, how it is identified, or how it differs from list_student_groups.

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 instead of alternatives such as list_student_groups or get_student. No context, prerequisites, or exclusion criteria 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 readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, but the description adds no behavioral context on top of them. It does not mention what a 'tutor' is, how lookups behave, whether results can be missing, or any other operational 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 technically short, but this is under-specification rather than effective concision. The two words simply repeat the tool name and provide no useful structure or additional information.

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

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

For a simple read-by-ID tool with rich annotations and an output schema, the bare description is minimally usable: the agent can infer that it fetches a tutor by UUID. However, it lacks any context about selection criteria, desired usage, or relationship to the many sibling tools.

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

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

Schema description coverage is 100% for the single parameter, with tutor_id described as 'Tutor UUID'. The description itself adds no parameter-level meaning, but the schema already carries that burden adequately.

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 Tutor' is a tautology that restates the tool name and title without adding any detail. It identifies the resource but does not differentiate this tool from sibling tools such as get_student, get_parent, or get_lesson_participant.

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. Given the large set of sibling tools, an agent cannot determine from the description why it would choose get_tutor instead of another get_* or list_* tool.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safe, non-mutating behavior is clear without the description. The description adds no additional behavioral context such as pagination behavior, default filtering, or consequences of using voided adjustments, so 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 short but wasteful because it repeats the existing title. It is under-specified rather than deliberately concise, and the single sentence does not earn its place by adding information beyond the name.

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 rich input schema, annotations, and output schema compensate for much of what is missing, so the tool is minimally usable. Still, the description never explains what an adjustment is, when adjustment listings are appropriate, or how filters combine with each other, leaving clear gaps for an agent operating outside familiar domain context.

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

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

Schema description coverage is 100%, and each of the 6 parameters already has a meaningful description covering date ranges, pagination, tutor filtering, and voided inclusion. The description adds nothing about parameters, so the baseline 3 applies because the schema does the heavy lifting.

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

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

The description 'List Adjustments' simply restates the tool name and title in human-readable form. It names a verb and resource but adds no scope, no clarification of what an adjustment is, and no differentiation from the many other sibling list_* 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?

There is no guidance about when to use this tool versus alternatives, no mention of required filters, and no exclusions. A user or agent must infer entirely from the name that this is the tool for listing adjustment records, which the schema does not fully convey in prose.

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 contributes no behavioral information beyond the verb 'List'. Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, so there is no contradiction, but the description adds no extra context such as pagination behavior, authorization needs, or availability semantics.

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

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

The description is a single short phrase with no wasted words and the verb is front-loaded. It is concise, though it is too sparse to add much semantic value.

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

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

Structured context is strong due to 100% schema coverage, meaningful annotations, and an output schema. However, the description itself leaves out narrative context about availability semantics, pagination behavior, or when to prefer this tool over get_availability, making it minimally complete but not rich.

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

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

Schema description coverage is 100%, and the schema documents all four optional parameters with clear meaning. The description adds no parameter-level detail, 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 'List Availabilities' uses a clear verb and resource, so an agent can tell it returns availability records. However, it merely restates the tool name and does not distinguish it from sibling tools like get_availability.

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 about when to use this tool instead of alternatives such as get_availability or other list_* endpoints. The description implies a generic listing operation but provides no context, exclusions, or routing hints.

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

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

The annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds no behavioral characteristics beyond that, such as pagination behavior, default ordering, or scope limitations. It is consistent with the annotations but contributes no extra transparency.

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

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

The description is only three words and front-loaded, but it restates the title without earning its place. It is under-specified rather than genuinely concise, similar to a stub.

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

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

The tool is simple, the schema fully documents optional filters, and the output schema exists, so the description needs to convey little about return values. However, with over 60 siblings, it provides no context for when this listing tool is the right choice; it is minimally viable but has clear 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?

Parameter schema coverage is 100%, with all five parameters (brand, limit, offset, status, target) individually documented. The description itself adds no parameter semantics, but the schema fully carries that burden, so a baseline 3 is appropriate.

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

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

The description is exactly the tool title and name: 'List Blog Posts'. It states the operation but adds no detail about scope, filters, or relation to siblings, so it is essentially a tautology rather than an independent explanation.

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 about when to use this tool versus the many sibling list_* tools, nor when get_blog_post would be more appropriate for a single post. The description provides no usage context, exclusions, or alternatives.

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

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

The annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is clear. However, the description adds no behavioral context of its own, such as pagination behavior, status semantics, or open-world implications; it merely repeats the title.

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

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

The description is short but under-specified: it repeats the tool name and does not earn its place by adding useful information. There is no front-loaded differentiation, filtering note, or behavioral detail; this is omission rather than true conciseness.

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

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

The annotations cover read-only/idempotent behavior, all parameters are documented, and an output schema exists, so the invocation requirements are mostly satisfiable. The main missing pieces are business context and when-to-use guidance, which are addressed in the usage dimension; for a simple list endpoint this is 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 limit, offset, status, and subject_id are already documented. The description itself adds no parameter-level meaning, but with full schema coverage the baseline of 3 is appropriate and no compensation is needed.

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

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

The description 'List Booking Requests' is a verb+resource phrase, but it exactly restates the tool name and title and adds no distinguishing scope or semantics. It also does not separate this from the many sibling list_* tools such as list_sessions or list_leads.

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 instead of alternatives. There is no mention of business context, prerequisites, or exclusions, so an agent has no basis for deciding between this and other list 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?

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered by structured data. The description adds no behavioral context beyond the word 'list', which only restates what the annotations imply. No rate limits, result mutability, or other 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?

The description is minimal but under-specified rather than efficiently informative. 'List Classrooms' is concise in length but provides no substantive content that earns its place beyond repeating the tool name.

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

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

The tool is simple and the annotations plus complete input schema make it minimally callable. However, the description alone does not explain the relationship to get_classroom, whether the list is global or scoped, or what the returned classroom objects represent. This is acceptable for a basic list operation but leaves clear gaps.

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

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

Schema description coverage is 100%, so the input schema fully documents limit, offset, and subject_id with descriptions. The tool description itself adds no parameter-level meaning, but per the rubric the baseline is 3 when 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 'List Classrooms' is essentially a restatement of the tool name 'list_classrooms'. It states a verb and resource, but adds no additional detail about scope, filtering, or what a classroom listing represents, and it does not distinguish itself from sibling tools like get_classroom or list_student_groups.

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 about when to use this tool versus alternatives. The description does not mention pagination, filtering, or distinguish list_classrooms from get_classroom or the many other list_* tools in the sibling set. An agent must infer usage entirely from the name and schema.

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 cover read-only, idempotent, open-world, non-destructive behavior, but the description reveals nothing beyond that. It does not mention ordering, pagination, time filtering behavior, or response characteristics.

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

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

The description is one short sentence, so it is not verbose, but it does not earn its place because it merely repeats the tool name. This is under-specification rather than useful conciseness.

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

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

There is no output schema, so the description should communicate return shape or ordering behavior, but it does not. With four parameters and many sibling list tools, the definition leaves too much for the agent to infer.

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

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

Schema description coverage is 100%, so all four parameters already have meaningful documentation including limit, offset, since, and conversation_id. The description contributes no parameter-level meaning, so the baseline score 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 is a verbatim restatement of the tool name and title (List Conversation Messages), so it is tautological and adds no new semantic content. It states a list operation but does not scope the resource or distinguish it from sibling list 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?

There is no guidance about when to use this tool instead of list_conversations, list_org_inbox, or other siblings. An agent must infer the intended use case entirely from the tool name and input schema.

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

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

The annotations already declare readOnlyHint, idempotentHint, and destructiveHint:false, so the safety profile is known without the description. The description adds no behavioral context of its own — no pagination behavior, no auth requirements, and no clarification of what a 'conversation' comprises.

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 words with zero wasted prose, but this is under-specification, not conciseness. The tool has 3 parameters and ambiguous scope among 60+ siblings, so a minimal restatement does not earn its place as an adequate description.

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

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

As a 0-required-parameter read tool with an output schema and full parameter documentation, the structured data carries most of the load. However, the description is too sparse for an agent to understand what a conversation is here, what the type filter means semantically, or why to choose this over list_conversation_messages and list_org_inbox.

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% — type (direct | triad | group | classroom_feed), limit (default 20, max 100), and offset are all documented in the schema. Baseline 3 applies because the description itself contributes no parameter information and the schema does the heavy lifting.

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

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

The description is 'List Conversations' — a word-for-word restatement of the tool name. It identifies a verb and resource but adds no scope, no conversation-type context, and no differentiation from close siblings like list_conversation_messages or list_org_inbox.

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 contains no guidance on when to use this tool versus alternatives. Nothing distinguishes it from list_conversation_messages or list_org_inbox, and no exclusions, preconditions, or context are stated.

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

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

The annotations already indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. However, the description adds no behavioral detail beyond that, such as pagination behavior, default scope, or that all parameters are optional.

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 only two words, which is under-specification rather than effective conciseness. It has no structure or front-loaded useful content, just a restatement of the tool's name.

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?

Although the schema and annotations are reasonably rich, the description contributes no context about the purpose, filtering semantics, or relationship to sibling tools. An agent selecting among many similar list tools would not be able to distinguish this tool beyond its name.

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 seven parameters are individually documented in the input schema. The description adds nothing about parameters, but the schema already carries that burden, so the baseline score 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 'List Expenses' simply restates the tool name and title, making it a tautology rather than an informative purpose statement. It provides no detail about what the list contains or how it differs from the many sibling list_* 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?

There is no guidance about when to use this tool instead of related tools like list_payments, list_invoices, or list_mileage. An agent receives no contextual cues about appropriate use cases, filters, or exclusions.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true, and destructiveHint=false, but the description itself adds no behavioral context beyond what annotations provide. It does not mention pagination behavior, return shape, authentication needs, or any side effects; it also does not contradict 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 extremely short, but this is under-specification rather than conciseness. It restates the tool name and does not earn its place by adding useful information.

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

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

There is no output schema, and the description does not explain what 'files' refers to, how scope and resource_type interact, or when to choose this over sibling list tools. An agent could invoke the tool mechanically but cannot reliably determine correct parameter combinations or expected results.

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

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

The input schema fully documents all four optional parameters, including allowed values for scope and resource_type, and defaults/max for limit. With near-100% schema description coverage, the description need not repeat parameters; it also adds no extra semantic nuance of its own.

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 'List Files' is effectively a tautology, restating the tool name and title. It identifies a verb and resource but gives no detail about what 'files' means in this system or how it differs from the many sibling list_* 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?

There is no guidance on when to use this tool versus alternatives like list_lesson_plans, list_homework, list_classrooms, or list_availabilities. The description provides no context, prerequisites, or exclusion criteria.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds no behavioral context whatsoever, such as what records are returned, pagination implications, or how scope interacts with homework data. 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 under-pecified rather than concise: 'List Homework' is two words with no structure, front-loading, or earnt information. Every sentence should earn its place, but there are no sentences with substance.

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

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

No output schema exists, and the description leaves the core domain concept of 'homework' undefined. While the schema clarifies filters and annotations confirm safety, the agent cannot infer what the tool returns, how homework relates to classrooms/groups/students, or why it exists alongside many similar list_* tools.

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

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

The input schema fully documents all 5 parameters with types and descriptions, so schema coverage is high. The description contributes no additional parameter meaning, and per rubric the baseline of 3 applies when the schema already handles parameter semantics.

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

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

The description is the tautological phrase 'List Homework', restating the tool name without any specification. It fails to distiniguish this tool from sibling 'list_*' tools such as list_questions or list_files, offering no differentiation for agent selection.

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

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

No guidance is given about when to use this tool versus alternatives. There are no scenarios, exclusions, or sibling comparisons, leaving the agent without a basis to choose it over other list_* tools in the same family.

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

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

Annotations declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, and the description does not contradict them. However, it adds no behavioral context of its own, such as pagination behavior, default ordering, or what filters are available beyond the schema.

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

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

The description is extremely short with no filler, which is concise in length, but it is under-specified: it restates the name and provides no structured explanation. This is under-specification rather than earned conciseness.

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

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

For a tool with six optional parameters and numerous sibling list_* and get_* tools, this definition provides no guidance on when this tool is appropriate or how it relates to siblings. The output schema can inform return shape, but the description leaves the agent without usage context.

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

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

Schema description coverage is 100%, so the input schema fully documents all six optional parameters. The description adds no additional parameter semantics, so the baseline of 3 applies.

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

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

The description is a verbatim restatement of the tool name and title, offering no information beyond the resource being listed. While 'List Invoices' does include a verb and resource, it is a tautology rather than a clarifying statement.

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 explanation of when to use list_invoices versus the related get_invoice or other list_* tools. The sibling list includes many similar list operations, but the description provides no distinguishing context or exclusions.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. However, the description adds no behavioral context beyond the annotations—no mention of filters, pagination, date-range behavior, or response format.

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?

At only two words, this is under-specification rather than conciseness. There is ample room for a single sentence explaining scope or key usage considerations, and the description currently earns no structural credit.

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 six optional filter parameters, an output schema, and many sibling list tools, yet the description provides no context for how to invoke it correctly. An agent cannot tell whether this returns all leads, how pagination works, or how it relates to get_lead.

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 six parameters already has a meaningful description. The tool description adds no parameter-level information, but because the schema carries the full burden, a baseline score 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 'List Leads' is a tautology that restates the tool name and title verbatim. It identifies the verb and resource but adds no detail that distinguishes it from other list_* siblings such as list_students or get_lead.

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

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

There is no guidance on when to use this tool versus alternatives like get_lead for a single lead or other list_* tools. The description does not mention the filtering, pagination, or scoping options available in the schema.

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 traits beyond what the annotations already declare (readOnlyHint, idempotentHint, etc.). It does not mention pagination, filtering semantics, or any side effects, so the agent gains no additional insight from the description.

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

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

The description is extremely concise with no filler, but it is more of a title than an informative description. It is under-specified because it repeats the tool name without providing contextual value, so while it is short, it does not fully earn its place.

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

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

Given that the tool has six optional filters and is part of a large sibling set, the description alone is insufficient to reliably guide invocation. Annotations and output schema help, but the lack of usage context and filter-combination guidance leaves a notable gap.

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

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

Schema description coverage is 100%, so all six parameters are documented with descriptions. The tool description adds no parameter-specific meaning, but the schema already carries the burden; 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 a verb (List) and a resource (Lesson Participants), making the tool's basic purpose unambiguous. It does not explicitly differentiate from sibling tools like get_lesson_participant, but the plural 'participants' and 'list' verb imply a collection 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?

There is no guidance on when to use this tool versus alternatives such as get_lesson_participant or list_sessions. The description does not mention any conditions, exclusions, or scenarios where one sibling should be preferred over another.

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

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

The annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. However, the description itself adds no behavioral context beyond the name—no mention of pagination behavior, default ordering, or what the returned list represents.

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

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

The description is short, but acceptable conciseness requires a sentence to add information. 'List Lesson Plans' is only three words and repeats the tool name, so it does not earn its place.

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

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

Even though an output schema exists and annotations cover safety, the description is too sparse for a tool with five optional filters and many list siblings. It does not explain whether filters are combinable, what the default scope is, or whether the result is limited to the current user’s context.

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

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

Schema description coverage is 100%, so all five parameters are documented in the input schema. The description adds nothing to the parameter semantics, but per the rubric the baseline is 3 when the schema carries the full load.

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 'List Lesson Plans' is essentially a tautology of the tool name list_lesson_plans and the annotation title. It states a verb and resource but adds no differentiating detail about what counts as a lesson plan or how this tool differs from the many sibling list_* 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?

No guidance is provided about when to use this tool versus alternatives like list_sessions, list_lesson_participants, or list_homework. The description also fails to mention whether filtering is required or optional in practice.

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 contributes no behavioral information beyond what the name implies. Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false; the description adds no pagination, scoping, or side-effect context, so it adds no transparency value beyond the structured metadata.

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

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

Two words are maximally short, but this is under-specification rather than effective conciseness. The phrase duplicates the title and uses its space on no useful distinctions, while the underlying tool has meaningful filters and pagination worth mentioning.

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 five optional parameters and a large sibling list, the two-word description is inadequate for an aent to understand when to choose this tool and what behavior to expect. The schema and annotations cover some technical details, but purpose, scope, and usage routing remain unexplained.

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 fully documents all five optional parameters with descriptions, so the description does not need to repeat them. However, the description also adds no extra semantic context about filtering or pagination behavior, leaving the schema to carry 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 'List Locations' merely restates the tool name/title and adds no explanatory scope. It identifies the action and resource, but does not differentiate this list operation from get_location or the many other list_* siblings in the toolset.

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 about when to use this tool versus alternatives such as get_location or other list endpoints. The sibling list implies a broader category, but the description leaves the agent to guess the appropriate use case.

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

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

Annotations declare readOnlyHint=true and destructiveHint=false, so the read-only safety profile is already covered. The description adds no behavioral context beyond that—no pagination behavior, default ordering, authorization requirements, or response shape—making it purely redundant.

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 words is under-specification rather than effective conciseness. It omits all necessary context and front-loads nothing useful for an agent parsing the definition.

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 six parameters and no output schema, this description is completely inadequate. It does not state what mileage records represent, how the filters combine, or what the list returns, so an agent cannot reliably determine whether this tool fits a request.

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

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

The input schema provides descriptions for all six parameters (to, from, limit, offset, status, tutor_id), achieving 100% schema coverage, so the baseline of 3 applies. The description itself adds no parameter semantics; the schema carries the meaning.

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

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

The description 'List Mileage' is a tautology—it merely restates the tool name. It does not specify what mileage records are, what domain they belong to, or how this tool differs from sibling list tools such as list_expenses or list_payments.

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

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

There is no guidance on when to use this tool versus alternatives. No contextual cues, exclusions, or mentions of sibling tools or filters that would help an agent select it appropriately.

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

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

Annotations declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, but the description itself discloses no behavior—no mention of pagination, ordering, default statuses, or that results may be open-world. It adds zero context beyond the annotations, so it does not help an agent anticipate 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?

At four words, it is not concise but under-specified. There is no substantive information beyond the name, so the brevity is a defect rather than a virtue.

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 and rich annotations, much is covered elsewhere, but the description still fails to explain what an 'Org Inbox' contains or how this listing differs from the many other list_* tools. For a tool with optional filters like status, some context about use cases is expected.

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 limit, offset, and status, so the baseline is 3. The description adds nothing about parameters, but the schema fully compensates.

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

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

Description is 'List Org Inbox', which restates the tool name with spacing. It conveys a listing operation on an org inbox but offers no details that distinguish it from the many sibling list_* tools. This is a tautology rather than an informative definition.

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

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

No guidance is provided about when to use this tool versus alternatives, nor any prerequisites or context. The description contains no if/then or comparison to siblings. Agents are left to infer that 'Org Inbox' is the resource.

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

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

No contradiction with the annotations (readOnlyHint=true, idempotentHint=true, destructiveHint=false) — the description is consistent with a safe read-only listing. However, the description itself contributes zero behavioral context beyond what annotations already convey; it doesn't mention pagination defaults, ordering, or what set of parents is returned. The HIGH calibration example earned a 3 by adding scope constraints; this one adds nothing.

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?

At two words, the description is under-specification rather than conciseness. It contains no front-loaded distinguishing fact, no exclusion, and no behavioral note — there is nothing here that earns its place beyond restating the tool name.

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 surrounding structured context is rich: output schema exists, both parameters are documented, and annotations fully describe the safety profile. For a simple paginated list tool, an agent can likely invoke it correctly. Yet the description itself is the weakest link — with ~60 mostly read-only list_* siblings, the tool is only minimally identifiable, so 3 (minimum viable) rather than higher.

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

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

Schema description coverage is 100% — both limit and offset are fully documented in the input schema with defaults and max values. Per the baseline rule for high coverage, the description need not add parameter detail; it also doesn't, so it neither helps nor hurts. Score 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 'List Parents' is a near-verbatim restatement of the tool name 'list_parents' — a tautology that adds no information beyond the name itself. While it does convey a verb and resource, it fails to differentiate this tool from the many list_* siblings like list_students, list_sessions, and list_tutors, and says nothing about scope or content of the listing.

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. With get_parent among the siblings, there is no mention of the list-versus-get distinction, and no context such as 'use for bulk operations' or 'use get_parent for a single record.' The agent is left to infer usage entirely from naming convention.

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 establish the safety profile (readOnlyHint=true, idempotentHint=true, destructiveHint=false), which lowers the bar, but the description contributes no behavioral context whatsoever beyond the name. Notably, openWorldHint=true suggests the result set may be non-exhaustive or scope-dependent, yet the description never clarifies this or any pagination/filtering behavior. There is no contradiction between description and annotations.

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

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

Two words with zero excess, but this is under-specification rather than conciseness. There is no front-loaded scoping constraint, behavioral note, or routing hint — the description earns none of its potential explanatory value.

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

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

The structured data is rich — full parameter coverage, safety annotations, and an output schema — so call mechanics and return values are covered. However, with 7 optional parameters and no required fields, the description never states the default scope of an unfiltered call, and the domain distinction between payments, payouts, and invoices is never addressed, leaving a meaningful gap for agent decision-making.

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

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

Schema description coverage is 100% — all 7 parameters (to, from, limit, offset, status, tutor_id, student_id) carry meaningful descriptions in the schema itself. The description adds no parameter-level meaning, so the baseline 3 applies with the schema doing 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 'List Payments' is a verbatim restatement of the tool name 'list_payments' — a tautology that adds no meaning beyond the name itself. It identifies a verb and resource but provides zero differentiating information against related siblings such as get_payment, list_payouts, list_invoices, or tutor_earnings.

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

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

No guidance is provided about when to use this tool versus alternatives. With over 60 sibling tools including other list_* operations and finance-related tools like list_payouts and tutor_earnings, the description leaves the agent with no basis for selecting this tool, and states no exclusions, prerequisites, or routing conditions.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, but the description adds no behavioral context beyond this. It does not mention date filtering, pagination behavior, or ordering, though these are inferable from parameters.

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

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

The description is extremely short, but this is under-specification rather than effective conciseness. It provides no meaningful content, so its brevity does not serve the agent.

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 list tool with five parameters and a large sibling set, the description is far too sparse. It lacks guidance on filtering semantics, relationship to payment vs invoice listing, or when pagination parameters matter. The annotations and schema cover safety and parameter names, but not usage context.

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

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

Schema description coverage is 100%, so all five parameters are already documented in the schema. The description adds no additional semantic meaning, so it relies entirely on the schema, which is sufficient for a baseline score.

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 'List Payouts' is a tautology that simply restates the tool name and title. It identifies the resource but does not distinguish this tool from siblings like list_payments or get_payout.

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 list_payments or get_payout. No context is provided about which scenarios call for listing payouts as opposed to retrieving a single payout.

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. Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, so the safety profile is covered, but the description itself says only 'List Questions' and provides no context about pagination, defaulting behavior, or what data is returned. There is no contradiction, but also no added transparency.

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

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

The description is short but under-specified rather than concise. A single sentence that merely restates the title does not earn its place because it adds no information. A helpful description could be one sentence with scope and filtering intent without losing brevity.

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 structured context partially compensates: annotations describe the safety profile, the input schema documents all filters, and an output schema exists for return shape. However, the description itself lacks any usable guidance for tool selection among the large sibling list, and it does not clarify what 'questions' means in this system. The overall definition is workable but leaves important selection context to inference.

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

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

Schema coverage is 100%: all five parameters have meaningful descriptions, and the source parameter explicitly explains catalogue versus own authored questions and the omit behavior. Since the input schema already carries the semantic weight, the description need not repeat parameter details. It does not, so baseline 3 is appropriate.

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

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

The description 'List Questions' exactly restates the tool name and title, so it is tautological. It gives no scope, no filtering semantics, and no way to distinguish this tool from the many other list_* siblings (list_sessions, list_students, list_results). A minimally useful purpose statement would mention what questions are listed or how the catalogue relates to the org's own questions.

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 about when to use this tool versus alternatives. It does not name sibling tools, state when the source filter should be used, or mention any exclusions or prerequisites. The useful usage context in the source parameter description is part of the input schema, not the tool description, so it does not count here.

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 provide read-only, idempotent, open-world, and non-destructive hints. The description adds no behavioral context beyond the word 'List', such as pagination defaults, ordering, or any filtering semantics, so it provides no value beyond the structured annotations.

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

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

The description is three words and contains no filler, making it very concise and front-loaded. However, it is so minimal that it relies heavily on the name and schema, though this is not penalized heavily here because conciseness itself is strong.

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

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

The tool is simple, has well-documented optional parameters, no required inputs, and an output schema, so the description is adequate for basic invocation. It lacks domain context about what a 'rate band' is or how it differs from rate cells, but this is a moderate gap given the low complexity.

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

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

Schema description coverage is 100%, with limit and offset both clearly documented in the schema itself. The description does not need to repeat parameter details, so the baseline score 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 action and resource: 'List Rate Bands'. It is not a tautology, but it does not differentiate this endpoint from closely related siblings such as list_rate_cells or list_tutor_tiers, so it falls short of the top score.

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

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

There is no guidance on when to use this tool versus alternatives like list_rate_cells or when pagination is necessary. The description gives no context about the intended scenario or exclusions, leaving the agent to infer usage from the name alone.

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

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

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, and the description does not contradict them. However, the description adds no behavioral context such as pagination behavior, filter interaction, or result size limits beyond what the schema already states.

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

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

The description is extremely short, but it is under-specification rather than concise writing. It simply repeats the tool name and does not use its few words to convey any additional information.

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

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

The schema and annotations are rich, and the optional filters are well documented, but the description fails to explain the domain concept of a rate cell or when this tool should be invoked. Because the output schema exists, return-value details are not required, but the core purpose and selection context remain unclear.

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 each parameter has a meaningful description, including defaults, examples, and filter semantics. The description itself adds no parameter information, but the schema fully carries that burden, 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 is simply 'List Rate Cells', which restates the tool name without adding any meaning. It does not explain what a rate cell is or how this tool differs from related siblings like list_rate_bands or list_tutor_tiers.

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. Given the large sibling list containing several similar list_* tools, the agent receives no routing context.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. However, the description adds no behavioral context beyond that—no mention of pagination behavior, default ordering, date-range semantics, or relationship to other endpoints. With annotations present, the bar is lower, but the description contributes nothing.

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 only two words and is under-specification rather than valuable conciseness. It is not front-loaded with meaningful information—there is no real content to structure. A short description can be effective, but this one provides no useful detail.

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

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

Given 7 parameters, an output schema, and a large sibling set, the description is completely inadequate. It does not explain what results are, how filters interact, what the output represents, or when to prefer this over get_result. The presence of an output schema covers return shapes, but the description fails to provide any operational context.

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

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

Schema description coverage is 100%, so all 7 parameters have descriptions in the input schema. The tool description adds no parameter information, but since the schema fully documents parameters, 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?

Description is 'List Results', which merely restates the tool name with capitalization. It identifies the verb and resource but adds no specificity about what a 'result' is or how this tool differs from get_result and other list_* siblings. This is a tautology rather than a meaningful purpose statement.

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

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

No guidance is given about when to use this tool versus alternatives like get_result for a single result, or how to choose among the many filter parameters. The description provides no context, exclusions, or preferred usage scenarios.

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 context beyond what the annotations already state. The readOnly, idempotent, and non-destructive hints are present in annotations, but the description itself does not explain filtering behavior, output shape, or any side effects.

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

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

The description is extremely short and front-loaded, but it is under-specified: it essentially restates the tool name and provides no additional useful content. This is under-specification rather than effective conciseness.

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

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

The schema and output schema cover the mechanics, but the description lacks the context needed to decide when this tool is appropriate among dozens of sibling list tools. It does not explain what session feedback represents, how it relates to tutor reviews, or when filters should be used.

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 parameters are already well documented. The description adds no extra meaning, but it does not need to because the schema already explains each parameter's purpose.

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

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

The description states a clear verb and resource: it lists session feedback. However, it does not differentiate this from nearby sibling tools such as list_tutor_reviews or list_sessions, so it is clear but not distinct.

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

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

No guidance is provided about when to use this tool versus alternatives. There is no mention of typical scenarios, exclusions, or how session feedback differs from related list operations.

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