Lim

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

readOnlyHint=true already establishes this is a safe read, and the description adds the single-vs-list mode distinction. It does not disclose pagination behavior (skip/limit clamping), sort semantics, or return shape, so it adds modest value over the annotation.

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

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

A single front-loaded sentence with zero waste; the primary discriminator (id) precedes the alternative (query).

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 6-parameter tool with a nested query object and no output schema, the description leaves the filter syntax, sort conventions, field projection and pagination entirely to the schema. It is minimally adequate but does not round out the picture an agent needs.

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

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

Schema coverage is 83%, above the 80% threshold, so the schema already documents id, skip, sort, limit and query. The description's id-vs-query note largely restates the id schema description, adding little new meaning and nothing for fields or the nested query object.

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

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

States a specific verb ('Find') and resource ('LimAccount records') plus the two operating modes (single by id, filtered list). Differentiation from the many query_lim* siblings comes only from the resource noun, which is adequate here since the siblings share the same pattern, but the description does not explicitly distinguish itself.

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

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

Explicitly tells the agent how to choose between the two behaviors: pass id for one record, or query for a filtered list. There is no statement of when not to use it or which sibling to prefer, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds the single-vs-list duality, but that is also spelled out in the id parameter schema ('omit to query many'), so incremental behavioral value is modest; pagination, clamping, and return shape are left to the schema or unstated.

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

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

A single well-formed sentence that front-loads the resource and packs both operating modes into one dash-separated clause. No wasted words; slightly terse but efficiently structured.

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

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

With 6 parameters, a nested query object, no output schema, and 83% schema coverage, the description covers the two main modes adequately. But it is silent on the fields parameter (undocumented in schema) and does not hint at the MongoDB-style query semantics that the schema only partially explains.

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

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

Schema description coverage is high (83%), so the schema already documents id, skip, sort, limit, and query. The description reinforces the id/query distinction but adds no format or syntax detail beyond the schema, fitting the baseline of 3 when structured data carries the 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?

States a specific verb (Find) and resource (LimAd records), and clarifies the two operating modes: single-record fetch via id versus filtered list via query. It does not explicitly distinguish itself from the many sibling query_lim* tools, but the resource name and mode split make its purpose unambiguous.

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

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

Provides mode-selection guidance ('pass id for one record, or query for a filtered list'), which is a form of usage instruction. However, it offers no when-to-use/when-not context relative to the ~45 sibling query tools and no prerequisites 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, so the safety profile is covered. The description adds that the tool has two operating modes, which is useful, but discloses nothing about pagination behavior, clamping, or result shape beyond what annotations and schema already convey.

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

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

A single sentence with zero waste, front-loading the resource and the two-mode distinction. Nothing is padded or repeated.

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 read-only, flat query tool with a well-documented 6-parameter schema and no output schema requirement, the description plus schema gives an agent enough to invoke correctly. The one gap is absence of pagination or return-shape hints, which is minor here.

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 83%, so the schema already documents id, skip, sort, limit, and query with meaningful detail. The description reinforces the id/query dichotomy but adds no syntax, format, or edge-case guidance beyond the schema; baseline 3 applies.

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

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

States a specific verb (Find) and resource (LimAdSenseSite records) and clearly splits behavior into two modes: single-record lookup by id versus filtered list via query. The resource name itself distinguishes it from the ~50 query_lim* siblings, but there is no explicit contrast drawn with any of them.

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

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

The description implies the selection rule between the two modes (pass id for one, query for a list), which is useful context. It does not state any when-not conditions, prerequisites, or alternatives, so usage is only implied rather than guided.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds no behavioral context beyond that: nothing about pagination interaction between skip/limit, what happens when an id is not found, or the cost/shape of a broad query against a 500-record cap.

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

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

A single front-loaded sentence with two clauses that each carry distinct information. No filler, no restatement of 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?

With 6 parameters, a nested MongoDB-style query object, and no output schema, the description covers the two access modes but says nothing about the returned record shape, pagination semantics, or error cases. Adequate as a pointer, but thin for a tool of this 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 coverage is 83%, so the schema already documents skip, sort, limit, query, and fields in detail, including clamping and defaults. The description only restates the id/query distinction the schema already makes, adding no format or syntax detail beyond it. 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?

States a specific verb (find) and resource (LimAIChat records), and explains the two operating modes (single record by id vs filtered list). It does not explicitly contrast itself with siblings, though the resource name in a family of query_lim* tools is inherently distinguishing.

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

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

Gives clear selection criteria: pass id for one record, omit it and use query for a filtered list. This tells the agent which branch to take, though it offers no exclusions or guidance on when a different tool would be preferable.

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

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

Annotations already declare readOnlyHint=true, so safety is covered. The description adds the dual-mode behavior (single vs. filtered list), which is genuinely useful context, but says nothing about pagination, sort defaults, or what happens when both id and query are supplied.

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

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

One sentence, zero waste, and the mode-selection rule is front-loaded. Nothing to trim.

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 read-only query tool with rich schema descriptions and an existing readOnlyHint, the description covers both invocation modes adequately. Only remaining gap is behavior when id and query are combined, or interaction with skip/sort.

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 83%, so the schema already documents id, skip, sort, limit, query, and fields. The description only echoes the id/query distinction the schema already spells out, adding no format, syntax, or defaulting detail beyond it.

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

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

States a specific verb (Find) and resource (LimAiDownload records) plus the two access modes. This distinguishes it from the ~70 sibling query_lim* tools only by the resource name, which is inherent to the family pattern rather than an explicit differentiation sentence.

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

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

Explicitly tells the agent the two modes: pass `id` for a single record, pass `query` for a filtered list. No guidance on when to prefer one mode over another or on combining the two, but the mode selection is unambiguous.

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

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

Annotations declare readOnlyHint=true, so the safety profile is already covered. The description adds only the cardinality behavior (one record via id, filtered list via query); it does not mention authentication, rate limits, pagination behavior, or return format details beyond cardinality.

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

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

One short sentence with no wasted words, and the primary usage pattern is front-loaded. It is appropriately sized for a query tool whose schema carries the parameter 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 readOnly annotations, high schema coverage, and no output schema, the description provides enough orientation for the main call patterns. It does not mention pagination, sorting, or field selection, but those are documented in the schema, so the gap is minor.

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 83%, so the schema already documents most parameters (id, skip, sort, limit, query). The description repeats the id/query mode distinction but adds no syntax or format detail beyond the schema; the undocumented 'fields' parameter is not covered.

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

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

The description states a specific verb ('Find') and resource ('LimAiMcp records') and distinguishes the single-record vs filtered-list modes. It does not explicitly name sibling tools or explain what LimAiMcp is, but the resource name differentiates it from the other query_lim* siblings.

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

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

It tells the agent how to select between id and query ('pass id for one record, or query for a filtered list'), but offers no guidance on when to use this tool versus other query_lim* tools or any prerequisites. This is implied usage rather than explicit when/when-not guidance.

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

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

Annotations already declare readOnlyHint=true, so safety is covered. The description adds no behavioral traits beyond what the schema already documents (id vs query semantics, pagination limits, sort). No rate limits, auth requirements, or return-shape context are provided.

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

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

A single tight sentence with the core behavior front-loaded. Every clause earns its place and there is no filler.

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

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

For a read-only query tool with strong schema coverage and no output schema needed, the description tells the agent the two main invocation paths. It omits pagination/sort guidance, but the schema already carries that, so nothing critical is missing.

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

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

Schema description coverage is 83%, so the schema already documents id, skip, sort, limit, and query with concrete detail (ranges, defaults, examples). The description adds nothing beyond what the schema provides, so the 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?

States a specific verb (Find) and resource (LimApiKey records) and explains the two operational modes: single record by id or filtered list by query. It does not explicitly differentiate from the many sibling query_lim* tools, though the resource name in the tool name effectively does that.

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

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

Gives clear routing guidance between the two modes of this tool: 'pass id for one record, or query for a filtered list.' It does not name an alternative tool or state when-not to use it, but within a uniform query_lim* family the mode guidance is the relevant selection 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?

readOnlyHint=true already tells the agent this is a safe read, so the description's burden is lighter. It adds the id-vs-query branching behavior, but says nothing about defaults, clamping, result ordering, or result volume — some of which the schema covers, but the description does not reinforce.

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

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

A single well-formed sentence that front-loads the resource and immediately presents the two decision branches. No filler, nothing redundant.

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 optional parameters, a nested query object, and no output schema, a one-sentence description leaves gaps: nothing about how results are returned, what happens with no filters (full collection scan?), or how sort/fields interact. Adequate to call the tool, thin for calling it well.

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 83%, so parameters are largely self-documenting and the baseline is 3. The description restates the id/query split that the schema already specifies and adds no meaning for skip, sort, limit, or fields.

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

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

States a specific verb ('Find') and resource ('LimAuthLink records') and splits the two operating modes (single-record by id vs filtered list). It is clear what the tool does, but it offers no differentiation from the dozens of identically-shaped query_lim* siblings other than the entity name itself.

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 mode-level guidance: pass 'id' for one record, use 'query' for a filtered list. It says nothing about when to reach for this tool over a sibling query tool, nor about pagination or prerequisites; usage is implied rather than instructed.

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 readOnlyHint=true annotation already establishes this as a safe read, and the description adds nothing beyond it: no pagination behavior, no default limits, no auth requirements, no note about how large result sets are handled. It essentially restates the operation shape the annotations and schema already imply.

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

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

A single front-loaded sentence with zero filler that immediately communicates the two operating modes. It is efficient, though arguably too terse for a tool with a nested MongoDB-style filter object.

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, a nested query object, and no output schema, the description is minimally adequate: the schema documents most parameters, so an agent can call it, but the description leaves query-shape examples, sorting/paging interaction, and default behavior entirely to the schema.

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

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

Schema description coverage is 83%, well above the threshold where the schema carries the parameter burden. The description's mention of 'id' and 'query' merely duplicates what the id and query schema descriptions already say, adding no syntax or format detail 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?

States a specific verb ('Find') plus the resource ('LimBan records') and names the two access modes (by id, or filtered list). It distinguishes itself from the many query_lim* siblings only by the resource noun, which is adequate here since each sibling targets a distinct collection.

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

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

The description explains the id-vs-query branch ('pass id for one record, or query for a filtered list'), which is genuine usage guidance for choosing a parameter. However, it offers no when-to-use context, prerequisites, or comparison against any alternative 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 only annotation is readOnlyHint=true, which the description implicitly aligns with ('Find'). Beyond that, it adds no behavioral context: no mention of pagination behavior, default field projection, sorting implications, or what the response contains. The description is largely redundant with the schema's own parameter descriptions.

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

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

A single, well-structured sentence that front-loads the core action and then the two usage modes. There is no filler or repetition.

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

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

Given six parameters, a nested query object, and no output schema, the description is minimal. It covers the primary id-vs-query distinction, but leaves the agent to infer return shape, pagination behavior, and the role of fields/sort/skip/limit entirely from the schema. Adequate but not fully complete.

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

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

Schema coverage is 83%, so the baseline is 3. The description references 'id' and 'query' but only restates their roles, which are already documented in the schema. It adds no syntax, format, or interaction details beyond what the schema provides.

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

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

The description states a specific verb ('Find') and resource ('LimBroadcast records'), and explicitly covers the two operational modes (single record via id, filtered list via query). The resource name distinguishes it from the many sibling query_lim* tools, even without naming alternatives.

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

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

It clearly says to pass 'id' for one record and 'query' for a filtered list, giving concrete guidance for the two modes. It does not mention when to avoid this tool or name alternative siblings, but the mode-based guidance is explicit and sufficient for selection.

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

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

readOnlyHint=true already declares the safety profile, and the description is consistent with it. It adds the dual-mode behavior (single fetch vs list), but says nothing about pagination, clamping, auth, or result shape beyond what the schema already encodes.

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

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

A single front-loaded sentence with zero filler that communicates the two call modes immediately.

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

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

With no output schema and nested objects (query, fields), the description does not describe the return shape or how fields projection behaves. It is minimally adequate because the schema carries most parameter detail at 83% coverage.

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 83%, so the schema documents most parameters (limit clamping, sort prefix, query filter example). The description only restates the id/query distinction with no added syntax or semantics, so the baseline 3 applies.

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

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

States a specific verb (Find) and resource (LimBuid records) and describes the two operating modes. It does not differentiate from the dozens of identically-shaped query_lim* siblings beyond the resource name, so an agent must rely on the name to pick the right one.

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

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

The description implies mode selection ('pass id for one record, or query for a filtered list'), which is useful, but it names no alternatives, no when-not conditions, and no prerequisites for using either mode.

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?

readOnlyHint=true already tells the agent this is a safe read, so the bar is lower. The description adds the single-vs-list behavior split, but says nothing about default limits, clamping, cost, or result shape beyond what the schema already documents.

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

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

A single tight sentence, front-loaded with the action and immediately presenting the two mutually exclusive modes. Zero filler.

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

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

No output schema exists, and the description does not describe the returned record shape, pagination semantics, or the nested query object's capabilities. For a 6-parameter query tool with a nested filter object, this is adequate but leaves real 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 83%, so the schema already explains id, skip, sort, limit, and query with examples. The description only restates id and query behavior and adds nothing for the undocumented 'fields' parameter or the sort/limit interaction.

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

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

States a specific verb (find/query) and resource (LimBusinessListing records) and distinguishes the two retrieval modes (single by id vs filtered list). Sibling differentiation is inherent in the entity name shared across the query_lim* family, so no explicit contrast is needed.

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 mode selection guidance ('pass id for one record, or query for a filtered list'), which is genuinely useful. However it offers no when-not guidance, no mention of when to prefer pagination/filtering over full scans, and no routing to any alternative 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?

readOnlyHint=true already declares this is a safe read, so the description carries a lighter burden. It adds the id-vs-query mode distinction but says nothing about pagination, default limits, or result shape beyond what the schema already provides.

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

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

A single front-loaded sentence that states the resource and both access modes with zero filler. Every clause earns its place.

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

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

For a read-only query tool with strong schema coverage and annotations covering safety, the description is nearly complete - it explains the two modes clearly. It omits pagination/sort context, but that is well covered by the schema, so the gap is minor.

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 83%, so the schema documents nearly all parameters, including the limit default and clamping behavior. The description only reinforces id and query usage, adding marginal meaning beyond the structured fields - 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?

States a specific verb ('Find') and resource ('LimCalendarEvent records'), and clarifies the two retrieval modes (single by id vs filtered list by query). It is clear on its own, though differentiation from the many sibling query_lim* tools rests entirely on the resource name rather than any explicit contrast.

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 distinguishes the two modes - pass id for one record, query for a filtered list - which gives implied guidance on parameter selection. It offers no broader when-to-use context, no exclusions, and no mention of alternatives among the 47 sibling query 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 readOnlyHint already declares this is a safe read, so the safety burden is lifted. The id-vs-query mode routing is a useful behavioral note, but it largely restates the schema's own id description, and nothing is said about pagination limits or result shape beyond what structured fields 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?

A single front-loaded sentence with the two modes stated up front and no wasted words. It is efficient, though its brevity is part of why coverage elsewhere is thin.

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 6-parameter query tool with a nested MongoDB-style filter object and no output schema, the description is minimal. It routes between modes but leaves filter semantics, sorting, and pagination behavior to the schema, which covers most but not all of the surface.

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 83%, so the schema already documents id, skip, sort, limit, and query with formats and clamping behavior. The description adds only the id-vs-query routing, which is redundant with the schema. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

States a specific verb (find) and resource (LimCall records), and clarifies the two operating modes (single by id vs filtered list). It does not explicitly distinguish itself from the many sibling query_lim* tools, but the resource name carries that differentiation inherently.

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

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

It tells the agent to pass id for one record or query for a list, which is mode-selection guidance, but gives no guidance on when to prefer this tool over sibling query tools or any prerequisites. Usage is implied rather than fully spelled out.

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?

readOnlyHint=true already tells the agent this is a safe read, so the description only needs to add context; it adds the single-vs-many return shape. It does not mention pagination behavior, default result size, clamping of limit, or authorization requirements, though the schema carries some of these.

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

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

A single front-loaded sentence with a dash separating the two modes, with no filler. It is efficient, though extremely terse relative to a six-parameter tool.

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

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

For a read-only query tool with an 83%-documented schema and no output schema, the essentials for invoking it are present. It does not explain what a LimChatFriend is or how results are shaped/paginated, leaving minor gaps against the surrounding siblings.

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

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

Schema description coverage is 83%, above the 80% threshold, so the baseline is 3. The description reinforces the id/query distinction and the notion of a filtered list, but adds no meaning beyond that, and the nested query object's MongoDB-style syntax is documented in the schema rather than here.

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

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

States a specific verb (Find) and resource (LimChatFriend records) and clarifies the two operating modes: single-record by id versus filtered list by query. It is clear, but it offers no differentiation from the many identically shaped query_lim* siblings, so the agent must infer scope purely from the resource name.

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

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

The description tells the agent how to choose between the id path and the query path, which is genuine usage guidance for this tool's two modes. However, it gives no conditions for choosing this tool over related siblings like query_limfriendrequest or query_limaccount, and no prerequisites are mentioned.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered without the description. The description adds only the id-vs-query behavioral split and says nothing about pagination clamping, sort behavior, or field projection semantics. With annotations carrying the load, a 3 is appropriate.

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

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

A single front-loaded sentence with no wasted words, moving directly from purpose to mode selection. It is appropriately sized for a simple query tool, though the compressed phrasing merges purpose and usage into one clause.

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

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

With no output schema, the description need not explain return values, but for a 6-parameter query tool with a nested MongoDB-style filter object it leaves sort syntax, limit defaults, and field projection entirely to the schema (and `fields` undocumented anywhere). It is minimally adequate but not 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 83%, above the 80% threshold, so the schema already documents id, skip, sort, limit, and query. The description merely restates the id/query distinction rather than adding format or syntax detail, and the undescribed `fields` array remains unexplained. Baseline 3 applies.

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

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

States a specific verb ("Find") and resource ("LimChatMessage records") and distinguishes its two modes (single record via id vs. filtered list via query). It does not differentiate itself from the many sibling query_lim* tools, but the resource name plus mode selection makes the purpose unambiguous.

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

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

Explicitly states the condition that selects each mode: "pass id for one record, or query for a filtered list." This is clear when-to-use guidance for the two paths. It offers no exclusions or alternatives to other sibling tools, so it stops short of a 5.

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

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

readOnlyHint=true already establishes the safety profile, so the description's main added value is the id-vs-query mode distinction. It says nothing about pagination behavior, return shape (array vs single object), or whether filters are required, which matters for a query tool.

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

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

One sentence, front-loaded action, zero filler. Both modes are conveyed without any repeated schema 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?

With no output schema, the description should ideally indicate the return form (single record vs list, and whether counts/pagination metadata are included). Instead it covers only input modes, leaving the agent to infer what comes back from a 500-record-capable query.

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?

At 83% schema coverage the schema already documents id, skip, sort, limit, and query well. The description only reinforces id and query semantics and adds nothing about sort/limit/fields beyond what the schema provides, so baseline 3 applies.

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

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

States a specific verb ('Find') and resource ('LimClassroomCourse records') plus the two retrieval modes, so an agent knows exactly what it returns. It doesn't explicitly differentiate from siblings like query_limclassroomstudent, but the resource name is inherently distinguishing.

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

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

Explicitly maps the two calling modes: 'pass id for one record, or query for a filtered list,' giving a clear condition for each parameter path. It stops short of naming alternatives or exclusions, but the primary when-to-use guidance is present.

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 readOnlyHint annotation already establishes that this is a safe read. The description adds the single-record vs filtered-list behavior, but it does not explain pagination defaults, sort syntax, filter semantics, or what the records look like. With annotations covering safety, additional behavioral depth is limited.

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 a single, front-loaded sentence with zero filler. It is efficient, though it is sparse enough that it could have carried one more useful clause without becoming bloated.

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 read-only query tool with an 83% schema coverage and no output schema, the most critical information is present, specifically the two query modes. However, the description does not describe result shape, typical record contents, or pagination and field-projection behavior, which are helpful for a tool with no output schema and six parameters.

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

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

Schema coverage is 83%, so the schema already documents most parameters, including the MongoDB-style query filter and the id semantics. The description restates the id-versus-query distinction without adding syntax, format, or constraint details beyond what the schema provides, so it sits at 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 gives a specific verb and resource: 'Find LimClassroomStudent records.' That identifies what entity is being queried and distinguishes it from siblings such as query_limclassroomcourse or query_limaccount. It stops short of stating how it relates to sibling tools, so it does not reach 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?

The description states the two invocation modes: 'pass id for one record, or query for a filtered list.' That is useful context for choosing between a lookup and a filtered list, but it offers no guidance on when to prefer this tool over the many other query_lim* tools, or when it is inappropriate. Usage is implied rather than explicitly guided.

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?

readOnlyHint=true already declares this as a safe read, so the safety burden is covered. The description adds the id-vs-query branching behavior but says nothing about pagination limits, clamping, or result shape beyond what the schema documents.

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

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

A single front-loaded sentence with no filler; the primary mode (single record) leads and the fallback (filtered list) follows. Nothing is redundant, though it is spare to the point of thinness.

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 6-parameter tool with a nested MongoDB-style filter and no output schema, the description covers the core calling pattern but leaves the query/sort/fields interplay and result-shape expectations entirely to the schema. Adequate but not fully self-sufficient.

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

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

Schema description coverage is 83%, so the schema already documents id, skip, sort, limit, and query semantics (including defaults and clamping). The description only restates the id/query dichotomy and adds no syntax or format detail beyond the structured fields.

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

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

The description names a specific verb ('Find') and resource ('LimCoinGateSnapshot records') and clarifies the two operating modes (single record by id vs. filtered list). It does not distinguish itself from the ~75 sibling query_lim* tools, though the resource name itself does most of that work.

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

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

It gives routing guidance between the two modes ('pass id for one record, or query for a filtered list'), which is genuinely useful, but offers no when-to-use vs. when-not-to-use context or named alternatives. Usage is implied by parameter shape rather than stated as a decision rule.

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

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

With readOnlyHint=true already covering the safety profile, the description adds only the fact that this is a find operation with two entry points. It does not disclose pagination defaults, clamping behavior, or result shape – though those are partly covered in 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?

A single sentence that front-loads the resource and then the two modes. No wasted words; every clause carries an instruction.

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 6-parameter query tool with a nested MongoDB-style filter object and no output schema, the description is minimal but mostly sufficient given strong schema coverage. It does not address the nested query operators the agent must construct, leaving a modest 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 83%, so most parameters are already documented in the schema with meaningful detail (clamping, sort prefix syntax, MongoDB-style query example). The description reinforces the id/query split but adds no syntax or format beyond the schema, matching the baseline 3.

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

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

The description names a specific verb ('Find') and resource ('LimCollaboration records'), and distinguishes the two operation modes (single record vs filtered list). It is clear, though it follows the same generic query template as the ~45 sibling query_lim* tools, so no differentiation beyond the resource 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?

'pass id for one record, or query for a filtered list' gives explicit selection guidance for the two primary modes. It stops short of explaining how skip/limit/sort/fields interact or when to prefer this over other resources, but the core routing is clear.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds the id-vs-query duality, but says nothing about pagination behavior, result format, or the fact that out-of-range limits get clamped (which lives only in 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?

A single sentence with the two usage modes front-loaded and zero wasted words. Nothing is padded.

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

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

For a read-only query tool with 83% schema coverage and no output schema, the description covers the essential call patterns. Minor gaps (return shape, sort/limit interaction) are carried by the schema rather than the description.

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

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

Schema description coverage is 83%, so the schema already documents id, skip, sort, limit, and query. The description only echoes the id/query split without adding format or semantics beyond what the schema provides. 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?

States a specific verb ('Find') and resource ('LimCommunity records') and distinguishes the two operating modes (single record by id vs filtered list). The resource name differentiates it from the many query_lim* siblings, but the description never explicitly contrasts itself with them.

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

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

Explicitly tells the agent when to use each mode: 'pass id for one record, or query for a filtered list.' This is clear mode-selection guidance, though it offers no exclusions or alternatives beyond those two paths.

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 readOnlyHint annotation already covers the safety profile. The description adds that id returns one record and query returns a filtered list, which clarifies result cardinality, but it omits pagination behavior, sorting, rate limits, and return field details. With annotations present, a 3 is appropriate.

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

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

The definition is a single front-loaded sentence with zero waste. It efficiently covers the two primary access patterns without unnecessary detail.

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

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

For a 6-parameter tool with a nested query object and no output schema, the description covers the two main access modes but leaves pagination defaults, return shape, and field selection unaddressed. The schema carries most parameter detail, but the description could better explain the tool's overall 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?

Schema description coverage is 83%, so the schema already documents limit defaults, sort syntax, skip, and fields. The description only echoes the schema's own explanations for id and query, adding no syntax, format, or default information beyond what the structured fields provide.

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 ("Find") and resource ("LimCommunityMember records"), and it distinguishes the single-record vs filtered-list modes. However, it does not differentiate this tool from the many sibling query_lim* tools beyond the resource name already present in 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?

The description gives implicit usage guidance by explaining that passing id fetches one record and query returns a filtered list. It does not say when to use this tool versus the numerous sibling query tools or name any alternative, so the guidance is limited to internal mode 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 readOnlyHint annotation already communicates that this is a safe read operation. The description adds the dual retrieval mode, which is useful behavioral context, but it does not disclose pagination behavior, auth needs, rate limits, or return shape.

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

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

A single sentence with zero waste. The core operation is front-loaded, and the id/query condition is stated compactly.

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 query tool with rich schema coverage and only a readOnly annotation, the description gives enough to call it correctly. The lack of output schema is not fully compensated, but the tool's return type is strongly implied by "Find records."

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 83%, so the schema already documents most parameters well. The description explicitly connects id to single-record retrieval and query to filtered-list retrieval, adding some clarity, but no syntax or format details beyond the schema.

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

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

States a specific verb and resource: "Find LimCommunityMessage records." The id-vs-query clause clarifies the retrieval modes. It does not explicitly distinguish itself from the many query_lim* siblings, but the resource name is precise enough.

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?

Explains how to use the tool: pass id for one record, or query for a filtered list. It does not say when to choose this tool over sibling query tools or list any prerequisites, so guidance remains implied rather than explicit.

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

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

The readOnlyHint annotation already establishes that this is a safe read operation. The description adds useful mode context by explaining id-based lookup versus filtered querying, but it does not describe pagination behavior, sorting/projection implications, or return shape. With annotations covering the safety profile, this is adequate but not rich.

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

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

The description is a single efficient sentence with the primary lookup modes front-loaded. There is no wasted wording or redundant explanation.

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 read-only query with six optional parameters and no output schema. The description covers the two main access patterns, but it omits the fields projection parameter and does not describe return values, which are left entirely to the schema and annotations.

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

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

Schema description coverage is high at 83%, so most parameters are already documented in the schema, including skip, sort, limit, and query. The description reinforces the id and query semantics but adds little beyond what the schema already says. 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 states a specific verb and resource: "Find LimCreateDomain records." It also distinguishes the two retrieval modes, single-record lookup by id versus filtered-list query. It does not explicitly differentiate this tool from similarly named sibling query tools, which keeps it below a 5.

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

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

It gives clear usage guidance: pass id for one record, or use query for a filtered list. That tells the agent when to choose each mode. It does not mention alternatives or exclusions beyond those two modes, so it is not a full 5.

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

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

readOnlyHint=true already tells the agent this is a safe read, so the description's burden is reduced. It adds the single-vs-many behavioral split, but says nothing about defaults, clamping, pagination ceilings, or result shape beyond what the schema 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?

A single front-loaded sentence with zero padding; the id-first ordering puts the simplest invocation path first.

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

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

For a read-only query tool with 83% schema coverage, the description plus schema together give an agent everything needed to call it correctly. Slightly richer context on the resource type or the 'fields' projection parameter would close the remaining gap.

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

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

Schema coverage is 83% and every parameter except 'fields' is self-documented, so the schema does the heavy lifting and baseline 3 applies. The description only reinforces the id/query relationship, adding no syntax or format detail the schema lacks.

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

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

States a specific verb ('Find') and resource ('LimCreateSite records'), which is enough to distinguish it from the many sibling query_* tools since each names its own resource. It stops short of explaining what a LimCreateSite record is, so an agent with no domain knowledge gets no semantic anchor beyond the type name.

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

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

The clause 'pass id for one record, or query for a filtered list' explicitly maps two invocation modes to their conditions, which is real routing guidance. It doesn't cover what to do when neither is supplied, or when to prefer this over query_limcreatesitevisit or query_limsite.

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

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

Annotations already declare readOnlyHint=true, so safety is covered structurally. The description adds nothing about result shape, whether the filtering is server-side, or pagination behavior — but nothing it says contradicts the read-only annotation.

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

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

One sentence, front-loaded with the resource, then the mode split. Zero filler and the branch condition is readable at a glance.

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 6 optional parameters, no output schema, and a nested query object, the description is thin on what comes back (list vs single object, whether pagination metadata is returned). The schema compensates for parameter detail, but the return contract is undocumented anywhere.

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 83%, and the schema already documents id, skip, sort, limit, and query in more detail than the description. The description only re-mentions id and query, adding no semantics beyond the schema, so the baseline 3 applies.

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

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

States a specific verb ('Find') and a specific resource ('LimCreateSiteVisit records'), and explicitly splits the two operating modes (single record by id vs filtered list via query). It does not differentiate from the near-identical sibling family (e.g., query_limcreatesite), but the entity name itself does most of that work.

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 'pass id for one record, or query for a filtered list' phrasing implies the two usage modes and is a reasonable selection rule. However, it gives no guidance on when this entity is the right one versus siblings like query_limcreatesite, and no note on what happens if both id and query are supplied.

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 readOnlyHint annotation already establishes the safe-read profile, and the description adds useful cardinality context (one record vs. filtered list). It does not disclose pagination behavior, default result counts, sorting semantics, or auth requirements, so it adds only modest 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?

A single front-loaded sentence with zero filler; the two usage modes are presented clearly. It is efficient, though its extreme brevity leaves some behavioral detail unstated rather than being a structural flaw.

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 six-parameter query tool with no output schema and only a readOnlyHint annotation, the description omits pagination/default-limit behavior, sort semantics, and the fields projection. The schema covers most of this, so it is adequate but not 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 high (83%), so the schema already documents id, skip, sort, limit, and query. The description merely restates the id/query distinction already present in the schema and adds nothing for the undocumented 'fields' parameter, matching the baseline 3 for high-coverage schemas.

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

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

States a specific verb ('Find') and resource ('LimDatabase records') and clarifies the two access modes (single record via id, filtered list via query). It does not differentiate itself from the many sibling query_lim* tools, relying on the resource name alone, so it falls short of a 5.

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

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

Gives clear conditional guidance: pass id for one record, use query for a filtered list. However, it offers no exclusions or pointers to alternative tools, and says nothing about when to use skip/limit/sort, so it stops short of a 5.

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

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

readOnlyHint=true already establishes the safety profile, so the description carries a lighter burden. It still adds nothing behavioral: no note on pagination interaction between skip/limit, default result volume, or filter limitations. It is consistent with the annotations, not contradictory.

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

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

A single front-loaded sentence with zero filler, and the id-first ordering matches the primary lookup path.

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?

Adequate for a straightforward read tool with 83% schema coverage and no required parameters, but with no output schema the description leaves the agent guessing about the shape and volume of returned records.

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 83% and the schema already documents id, skip, sort, limit, query, and the meaning of each. The description only restates the id-vs-query distinction, adding no syntax or format detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (Find) and resource (LimDatabaseAccess records) and cleanly splits the two access modes (single id vs filtered query). It does not differentiate itself from the 40+ sibling query_lim* tools beyond the resource name embedded in the tool name, so it stops short of a 5.

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

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

It gives mode-selection guidance ('pass id for one record, or query for a filtered list'), which is genuinely useful, but offers no when-not-to-use conditions, no mention of alternatives, and no prerequisites for the filter syntax.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description restates the id/query selection but adds no behavioral context such as pagination defaults, clamping behavior, or result shape that would go beyond the annotations and 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?

A single front-loaded sentence with no filler that covers both operating modes efficiently. It could still be marginally tighter and add one clause of return/pagination context without bloat.

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 6 parameters, a nested MongoDB-style filter object, and no output schema, the description is adequate but thin: it does not mention pagination defaults, the 1-500 limit range, or that it returns a collection of records. The schema carries most of the load at 83% coverage.

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 83%, so most parameters (skip, sort, limit, query, id) are already documented in the schema, and the description only echoes the id/query distinction. The lone undocumented parameter, fields (projection), is not addressed in prose.

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

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

States a specific verb ('Find') and resource ('LimDevice records') and distinguishes the two access modes (single by id, filtered list by query). Differentiation from the 40+ sibling query_lim* tools comes only from the entity name in the title/name, which is the standard convention here, so it is clear but not reinforced in prose.

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

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

Gives explicit conditional guidance for the two modes: 'pass id for one record, or query for a filtered list.' It does not say when to prefer this tool over adjacent ones or what happens if neither id nor query is supplied (required parameters are zero), leaving slight ambiguity.

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 readOnlyHint annotation already establishes this as a safe read, so the bar is lower. The description adds the dual-behavior distinction (one record vs filtered list), which is real behavioral context. It says nothing about pagination behavior, default result count, or return shape, so it stops at a moderate 3.

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

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

A single tight sentence with the primary capability front-loaded and zero filler. It is efficient, though its extreme brevity leaves several parameters and behaviors unaddressed rather than earning extra 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?

For a read-only query tool with no output schema, the description covers both access modes. But the 'fields' parameter has no schema description and no description compensation, and pagination/default behavior is left entirely to the schema. Reasonably complete but with a noticeable gap.

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

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

Schema coverage is 83%, so the schema already documents most parameters (including id, limit, skip, sort, query). The description only mirrors the id/query distinction the schema already makes and adds nothing for skip, sort, limit, or the undocumented 'fields' array. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description states a specific verb ('Find') and resource ('LimDoc records'), and the name itself carries the resource that distinguishes it from the long family of sibling query_* tools. It also clarifies the two operating modes (single record vs filtered list). It does not, however, explain what a LimDoc record is or differentiate explicitly from siblings, so it lands at a clear but not exceptional 4.

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

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

It gives mode-selection guidance — pass 'id' for one record, 'query' for a list — which is useful implied usage. But there is no when-to-use context, no prerequisites, and no exclusion or alternative-tool routing (e.g., when to prefer this over other query tools). Adequate but with clear gaps.

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?

readOnlyHint=true already establishes the safety profile, so the bar is lower. The description adds the single-vs-list retrieval behavior, but says nothing about pagination defaults, sorting, projection, or what a result looks like.

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

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

A single front-loaded sentence with no filler; the two modes are stated immediately and nothing is repeated from the schema.

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 read-only query tool with no output schema, the description leaves the return shape and field-projection behavior unaddressed, though the schema does cover most parameters adequately. It is minimally sufficient but not thorough.

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 83%, so the schema already documents most parameters including the skip/sort/limit semantics and a query example. The description only reinforces the id/query duality, adding marginal value over the schema.

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

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

States a specific verb (Find) and resource (LimDriveFile records) and clarifies the two retrieval modes. It distinguishes itself from the many sibling query_lim* tools only by the entity name, which is inherent to the naming rather than an explicit differentiation.

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

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

Explicitly tells the agent which mode to use: pass 'id' for a single record, or 'query' for a filtered list. This is clear contextual guidance, though it offers no exclusions or pointers to alternative tools.

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

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

The readOnlyHint annotation already declares the operation safe and read-only. The description adds output cardinality (single record vs list), which is behavioral context beyond the annotation, but it does not disclose pagination, sorting, or return format details.

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

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

A single, front-loaded sentence that states the purpose and the two usage modes with zero wasted words. It is appropriately sized for an agent to parse quickly.

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

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

Given the rich schema, read-only annotation, and absence of an output schema, the description is sufficient to orient an agent. The only minor gap is that the fields parameter lacks a schema description and is not mentioned, but the core query modes are covered.

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

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

Schema description coverage is high (83%), so the schema already explains most parameters in detail. The description only references id and query, adding little semantic depth beyond what the schema provides, making the baseline 3 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?

States a specific verb (Find) and resource (LimEditProject records), and clarifies the two query modes (id for one record, query for a filtered list). It does not explicitly differentiate from sibling tools beyond the unique resource name, so it falls short of a 5.

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

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

Explicitly says to pass id for a single record or query for a filtered list, giving clear context for choosing between the two main modes. It lacks when-not conditions or named alternatives, but the core usage is well covered.

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?

readOnlyHint=true already tells the agent this is a safe read. The description adds the id-vs-query mode semantics but says nothing about pagination behavior, default result size, or what happens when neither id nor query is supplied, which would be the value-add 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?

One sentence, zero waste, with the single-record path front-loaded ahead of the list path. Every clause earns its place.

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

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

For a read-only query tool with a well-described schema and no output schema, the definition is adequate but thin. It omits default limit behavior and result shape context that would help an agent call it confidently on the first try.

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 83%, so the schema already documents skip, sort, limit, and query. The description reinforces the id/query split but adds no format or default detail beyond it, and 'fields' is undocumented in both places. 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?

States a specific verb ('Find') and resource ('LimFamily records') and distinguishes the two retrieval modes (single by id vs. filtered list). It does not differentiate itself from the ~35 query_lim* siblings, which all share the same pattern, so an agent still needs the resource name to route.

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

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

The description explains when to pass id versus query, which is genuine mode-selection guidance. However it offers no exclusions or alternatives (e.g., when not to query many, or how it relates to query_limfamilyusage), leaving usage only implied for the sibling-selection problem.

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?

readOnlyHint=true already declares this is a safe read, so the safety burden is covered by annotations. The description adds the two access modes, which is useful, but says nothing about pagination defaults, clamping of limit, or result shape. Adds some value over annotations, no contradiction.

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

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

One sentence, front-loaded with the verb and resource, with the mode selection as the trailing clause. Zero filler and nothing that could be trimmed without losing signal.

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 read-only query tool with no output schema, the description covers both invocation paths and the schema handles parameter semantics. Return shape and pagination behavior are the only gaps, and those are partially inferable from limit/skip descriptions, so this is nearly complete.

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

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

Schema description coverage is 83%, so the schema already documents skip, sort, limit, query, and fields in detail (including the 1-500 clamp and default of 50). The description's id/query distinction largely restates the schema's own "Fetch one record by id; omit to query many". 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?

States a specific verb+resource ("Find LimFamilyUsage records") and splits it into two modes: single-record by id and filtered list by query. The entity name in the tool name already differentiates it from the ~45 sibling query_lim* tools, so no extra sibling routing is needed. It's clear, though it doesn't characterize what a LimFamilyUsage record represents.

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

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

Explicitly tells the agent which mode to use: "pass id for one record, or query for a filtered list." That is real when-to-use guidance covering the primary decision. It stops short of exclusions or advice on combining the modes (e.g. id with sort/limit is meaningless), so it isn't a full 5.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds the single-vs-list behavior, but does not disclose return format, pagination behavior, or other operational details beyond what the schema provides.

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

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

A single front-loaded sentence with no wasted words, clearly stating the tool's purpose and the two usage modes.

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 read-only query tool with a rich input schema and no output schema, the description covers the essential calling modes. It could be more complete by clarifying return shape or pagination, but the schema already carries most operational detail.

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

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

Schema description coverage is high at 83%, with id, skip, sort, limit, and query already documented in the schema. The description reinforces id/query usage but adds no syntax, constraints, or meaning beyond the schema.

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

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

The description states a clear verb ('Find') and resource ('LimFavorBusiness records'), and distinguishes two modes: single-record lookup by id and filtered-list query. It does not name or differentiate from sibling query tools, but the resource specificity is sufficient for an agent to identify the tool.

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

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

It explicitly explains the two calling modes: pass 'id' for one record, or 'query' for a filtered list. This gives clear context for parameter selection, though it does not mention when to prefer other sibling query tools or any exclusions.

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

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

Annotations already declare readOnlyHint=true, so safety is covered. The description adds the two-mode behavior (one record vs list), but does not mention default limit of 50, clamping of out-of-range values, or pagination behavior — all of which live only in 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?

A single efficient sentence with the primary mode-selection rule front-loaded. No filler, though it is arguably too terse for a 6-parameter tool.

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

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

For a read-only entity lookup with 83% schema coverage and no output schema, the description is serviceable but thin: it omits pagination defaults and the fields projection, leaving the agent to read the schema to call it correctly.

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

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

Schema description coverage is 83%, so the baseline is 3. The description only references id and query, adding no semantics for fields (the one underspecified parameter) or for combining skip/limit/sort.

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

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

States a specific verb+resource ('Find LimFavorReply records') and distinguishes the two retrieval modes (single by id vs filtered list). It does not explicitly differentiate from the ~70 sibling query_lim* tools, though the entity name in the tool name carries that differentiation.

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

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

The description implies when to use id vs query (single record vs filtered list), which is real guidance. It offers no exclusions, no mention of pagination/sort usage, and no alternatives — though for a uniform CRUD-family read tool there are no real alternatives to route to.

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

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

Annotations already declare readOnlyHint=true, so safety is covered. The description adds only the single-vs-list mode behavior, which is largely duplicated in the schema parameter text; it says nothing about pagination defaults, clamping, or result shape for a 6-parameter query tool.

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

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

One sentence, front-loaded with verb and resource, with the mode-selection clause at the end. Nothing wasted and no filler.

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

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

With 6 parameters, a nested MongoDB-style filter, and no output schema, the definition is minimally viable: the schema carries parameter detail, but nothing describes what a returned record looks like or how paginating through large result sets behaves.

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 83%, so the schema already documents id, skip, sort, limit, and query with an example. The description only restates the id/query distinction and adds no syntax or semantics beyond the structured fields.

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

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

States a specific verb (Find) and resource (LimFavorReview records) and names the two access modes. Entity name differentiates it from the ~70 parallel query_lim* siblings, though it doesn't explicitly reference any alternative.

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

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

Explicitly states the selection rule: pass 'id' for a single record, or 'query' for a filtered list. Clear operating context, but no exclusions or prerequisites (e.g., what happens if both are supplied).

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?

readOnlyHint=true already establishes the read-only safety profile, and the description adds essentially no behavior beyond it: no mention of result shape, sort/pagination behaviour, or what happens when id and query are combined. For a query tool with a nested filter object, the description carries little of the load.

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

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

One tight sentence with the primary usage fork front-loaded and zero filler. It is efficient, though its brevity borders on under-specification rather than optimal density.

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

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

With six parameters, a nested query object, and no output schema, the definition should explain at least the return shape and the precedence between id and query. It leaves both implicit, so an agent must infer behaviour that the description could cheaply have stated.

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 83%, so parameters are largely self-documenting, including the id 'omit to query many' note and the MongoDB-style filter example. The description only restates the id-versus-query dichotomy already present in the schema and adds no meaning to skip, sort, limit, or fields.

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

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

States a specific verb (Find) and resource (LimForm records), and the two operating modes are clear. However, it never distinguishes itself from the very similar sibling query_limformresponse, which an agent could easily confuse with form records versus form submissions.

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?

'Pass id for one record, or query for a filtered list' gives implied guidance on which parameter path to take, but says nothing about when to prefer this tool over query_limformresponse or how id and query interact if both are supplied.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered structurally. The description adds only the single-vs-list branching, and says nothing about defaults, clamping, or pagination behavior that the schema hints at but does not fully explain.

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

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

One short sentence with no filler, and the mode-selection rule is front-loaded after the resource name. Efficient, though slightly terse for a six-parameter tool.

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

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

With no output schema and a nested MongoDB-style query object, an agent still lacks information about what a result looks like and how paging (skip/limit) affects the response. Acceptable for a read-only query tool but leaves real gaps.

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

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

Schema coverage is 83%, so the schema already documents nearly all six parameters, including that omitting id queries many. The description restates that id/query distinction without adding new meaning, so baseline 3 applies.

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

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

States a specific verb (Find) and a specific resource (LimFormResponse records), plus the two access modes. It does not differentiate from the many query_lim* siblings beyond what the tool name already conveys, so it stops short of a 5.

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

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

The clause 'pass id for one record, or query for a filtered list' gives implied guidance on which parameter selects which mode, but there is no explicit when-to-use-this-vs-alternatives nor any exclusion. Usage is inferable rather than stated.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds no behavioral context of its own: it says nothing about pagination interplay, field selection, sort behavior, or what a result set looks like, so an agent must infer all of that from 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?

A single tight sentence that front-loads the resource and then the two usage modes; nothing is wasted. It is borderline under-specified rather than verbose, which is the only thing keeping it from a 5.

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 6-parameter, read-only query tool with no output schema and a nested MongoDB-style filter, the description is adequate but thin: it never hints at the return shape, the default limit of 50, or how 'fields' projects results. An agent can call it, but must derive behavior entirely from the schema.

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

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

Schema coverage is 83%, so the schema already documents skip, sort, limit, query, and id semantics. The description only restates the id-vs-query distinction and adds no new meaning (e.g., id precedence over query, or the shape of the fields projection). Baseline 3 applies when the schema carries the detail.

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

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

States a specific verb and resource ('Find LimFriendRequest records') and covers both access modes (single by id, filtered list by query). It is clear what the tool does, but nothing in the wording distinguishes it from the 45 sibling query_lim* tools beyond the entity name itself.

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 useful mode-selection guidance ('pass id for one record, or query for a filtered list'), so an agent knows how to pick between the two retrieval paths. It offers no guidance on when to prefer this tool over related lookups, and no prerequisites 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?

readOnlyHint=true already tells the agent this is a safe read, so the description's remaining burden is lighter. It adds the id-vs-query access branching but says nothing about pagination defaults, result shape, or how nested query filters behave.

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

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

A single sentence with zero waste, front-loading the resource and then the two usage modes. Nothing is padded or redundant.

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 read-only, well-documented query tool with no output schema, this covers the essential routing logic. Pagination and sort semantics live in the schema, so the description is nearly complete, though it could note the nested-query structure.

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 83%, so the schema already documents id, skip, sort, limit, and query. The description echoes the id/query semantics already present in the schema and adds no syntax or format detail beyond it, making the baseline 3 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?

States a specific verb (Find) and resource (LimKanbanBoard records), and distinguishes the single-record vs filtered-list modes. It does not differentiate from the ~48 sibling query_lim* tools beyond the entity name itself, which is inherent to the naming pattern.

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

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

Gives clear operative context: pass id for one record, or query for a filtered list. This tells the agent how to choose between the two access modes. It stops short of naming when-not-to-use or pointing at alternative tools.

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

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

The readOnlyHint annotation already declares this a safe read, so the bar is lower. The description adds the dual-mode behavior but omits anything on pagination defaults, result caps, or performance characteristics not already implied by 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?

A single compact sentence with the primary purpose front-loaded and no wasted text. It is appropriately sized, though it invests its one clause in mode branching rather than disambiguation.

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 generic read/query tool with a well-documented schema and no output schema, the description is minimally adequate. It says nothing about the shape of returned records or what the nested query object supports, leaving the agent to rely entirely on the schema.

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

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

Schema description coverage is 83%, so the schema already documents id, skip, sort, limit, and query semantics. The description only restates id vs query behavior without adding format or constraint detail beyond the schema.

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

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

States a specific verb and resource ("Find LimKanbanTemplate records") and distinguishes the two access modes: single-record by id versus filtered list by query. It does not differentiate itself from siblings like query_limkanbanboard, which share the identical query_* pattern.

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

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

The description explains the internal branching ("pass id for one record, or query for a filtered list"), which is useful mode selection, but offers no guidance on when to choose this tool over the many sibling query_lim* tools or what prerequisites apply.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds nothing beyond that: it doesn't say what happens when every parameter is omitted (the schema implies a default 50-record page), whether unscoped queries are expensive, or how the result set is shaped. For a tool with six optional parameters and no output schema, this is thin.

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

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

A single sentence with zero waste, front-loading the resource and then the two calling modes. Nothing could be removed without losing 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 six-parameter, zero-required, nested-filter read tool with no output schema, the description covers the primary calling decision but not the default behavior (what an empty call returns), pagination implications, or result ordering. Adequate to invoke correctly, but it leaves the agent guessing about the no-argument case.

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 83%, so the schema already documents id, skip, sort, limit and query meaningfully; the description only reinforces the id-vs-query duality. The undocumented fields array is left unexplained in both places, and no filtering syntax or field-selection semantics are added beyond the schema's own example.

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

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

States a specific verb (find) and resource (LimLink records), and splits the operation into two explicit modes: single-record fetch via id and filtered list via query. The resource is unambiguous against the ~80 sibling query_lim* tools because only this one targets LimLink records, though the description never explicitly contrasts itself with them.

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

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

It gives mode-selection guidance (pass id for one record, query for a filtered list), which tells the agent how to choose between two calling patterns. It offers no guidance on when to prefer this tool over a sibling resource tool, and no exclusions or prerequisites, so usage is implied rather than fully framed.

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?

readOnlyHint=true already establishes this as a safe read, so the description only needs to add context. It discloses the id-vs-query branching behavior, which is useful, but says nothing about pagination limits, default page size, or result shape beyond what the schema already carries.

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

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

A single front-loaded sentence with zero filler; the two-mode structure is stated up front and every word earns its place.

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

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

For a 6-parameter read tool with a nested MongoDB-style query object and no output schema, the description covers the core invocation modes but leaves the nested query capabilities and return format entirely to the schema. Adequate as a minimum-viable definition but thin given the tool's flexibility.

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 83% (high), so the schema already documents id, skip, sort, limit, and query semantics well. The description reinforces the id/query distinction but adds no syntax or format detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb ('Find') and resource ('LimMail records') and immediately distinguishes its two operating modes (single record via id vs. filtered list via query). It is clear enough to separate from the flood of sibling query_lim* tools since the resource name is unique, though it offers no explicit sibling differentiation.

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

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

The description gives mode-selection guidance ('pass id for one record, or query for a filtered list'), which tells the agent how to invoke it two different ways. However, it never says when to prefer this tool over the other 46 query_lim* siblings or when not to use it.

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

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

readOnlyHint=true already tells the agent this is a safe read, so the description only needs to add context beyond that. It adds nothing about result ordering, pagination defaults, or clamping behavior (those live only in the schema), so it clears the lowered bar without distinguishing 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?

A single front-loaded sentence with the verb first and zero filler; every clause carries information an agent needs to choose between the two modes.

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?

Six parameters, a nested query object, and no output schema; the description covers only the id-vs-query branch. The remaining parameters are handled by the schema, but with no output schema present the description also never hints at what a returned record contains.

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 83%, so the schema already documents skip, sort, limit, and query syntax including the MongoDB-style filter example. The description restates only the id/query dichotomy and adds no format or constraint detail beyond the schema. Baseline 3 applies.

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

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

States a specific verb ('Find') and resource ('LimMcpLink records') plus the two retrieval modes, so an agent knows exactly what it returns. It does not differentiate itself from the ~46 structurally identical query_lim* siblings beyond the resource name, which the name already carries.

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

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

Gives a clear selection rule: pass 'id' for a single record, use 'query' for a filtered list. It offers no exclusions or guidance on the other four parameters, but the primary branching decision is explicit.

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

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

readOnlyHint=true already declares this is a safe read, so the description carries a lower burden. It adds the single-record vs filtered-list distinction but says nothing about pagination defaults, result caps, or return shape beyond what the schema and annotations imply.

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

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

A single sentence that front-loads the resource and immediately disambiguates the two modes. No waste, nothing to trim.

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 generic read/query tool with no output schema, the description plus the well-covered schema give the agent enough to call it correctly. It could still note default result limits or field projection, but those are minor for this tool class.

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?

With 83% schema coverage, the schema already documents skip, sort, limit, query and id thoroughly (including clamping behavior). The description only restates the id/query semantic, adding little beyond what is structured. Baseline 3 applies.

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

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

States a specific verb ("Find") and resource (LimMusicCollection records) and clarifies the two operating modes (id for one, query for a list). It is clear on its own, but offers nothing to distinguish it from the 47 parallel query_lim* siblings beyond the resource 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?

Explicitly tells the agent when to use id versus query, which is the key routing decision within this tool. It does not, however, address when to prefer this over any sibling tool or discuss prerequisites.

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

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

Annotations already declare readOnlyHint=true, so the safe-read profile is covered. The description adds the dual-mode retrieval behavior, but says nothing about pagination clamps, defaults, or result ordering beyond what the schema already documents.

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

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

A single front-loaded sentence with zero filler that packages both modes efficiently. Nothing is redundant or wasted.

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

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

For a read-only lookup tool with a well-described 6-parameter schema and no output schema, the description covers the essential usage pattern. It is slightly thin on list behavior (pagination, ordering) but the schema carries that burden.

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

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

Schema description coverage is 83%, so the schema already explains id, skip, sort, limit, and query semantics in detail. The description only reinforces the id-vs-query distinction and adds no new parameter meaning; the 'fields' array is left undocumented in both places.

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

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

States a specific verb ('Find') and resource ('LimMusicFollow records') and describes both operating modes (single record by id, filtered list by query). It does not differentiate itself from the many sibling query_lim* tools beyond the resource name, but the resource name is self-evidently 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?

It gives clear mode-selection guidance ('pass id for one record, or query for a filtered list'), which tells the agent how to choose between the two entry paths. It offers no context on when this tool is preferable to other tools or any exclusions, leaving usage implied.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds the single-vs-many mode split, which is useful, but says nothing about pagination, clamping behavior, return format, or query limitations. With annotations carrying the heavy behavioral load, a 3 is appropriate – the description adds some value but not much beyond the structured fields.

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

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

A single, front-loaded sentence with zero waste. It packs the core purpose and the two operational modes into one clear clause.

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 read-only query tool with 6 parameters, a nested query object, and no output schema, the description is minimally adequate. It omits return-shape and pagination context that would help an agent call it correctly, relying almost entirely on the schema and readOnly annotation.

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 83%, so most parameters are documented in the schema itself (skip, sort, limit, query examples). The description only reinforces the id-vs-query distinction already present in the schema, adding little parameter meaning beyond what is structured.

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 ('Find') and resource ('LimMusicTrack records'), and distinguishes the two retrieval modes (single record by id vs filtered list by query). It does not name or contrast any sibling query_lim-* tool, but the entity name itself differentiates it from the many other query tools.

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

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

It gives a clear conditional: use id to fetch one record, use query for a filtered list. That is actionable usage guidance, though it stops short of naming alternatives or when-not-to-use 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?

The readOnlyHint annotation already establishes the safe, read-only nature of the operation. The description adds the behavioral distinction between fetching a single record and querying a filtered list, which is useful but also largely reflected in the schema parameter descriptions. It does not disclose pagination behavior, default limits, or authentication requirements beyond what 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 a single front-loaded sentence with zero wasted words. It immediately states what the tool does and then explains the two usage modes efficiently.

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 is fairly rich and annotations cover the safety profile, so the brief description is mostly adequate for this query tool. However, the fields parameter has no description in either the schema or the description, and pagination or default behavior is left entirely to the schema. The description does not fully compensate for those 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 high at 83%, so the schema already documents most parameters including id, skip, sort, limit, and query. The description mentions id and query, but only as part of the mode selection, adding no new syntax or format details beyond the schema. Baseline 3 is appropriate.

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

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

The description states a specific verb and resource: 'Find LimNote records'. It distinguishes two operating modes (single record via id, filtered list via query), which helps an agent understand the tool's scope. However, it does not explicitly differentiate this tool from any of the many sibling query_lim* tools, so it stops short of a 5.

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

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

The description gives clear in-tool guidance: pass id for one record, or query for a filtered list. This tells the agent exactly how to choose between the two modes. It does not state when not to use the tool or name an alternative sibling, so it is not a 5.

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

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

readOnlyHint=true already tells the agent this is a safe read, and the description adds only the two access patterns rather than behavior. It says nothing about pagination defaults, clamping, or result volume, which is exactly the kind of context a read tool should surface.

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

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

A single sentence, front-loaded with the resource and immediately followed by the mode-selection rule. No filler, no repetition of schema or annotation content.

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

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

For a read-only query tool with rich per-parameter schema text the description is minimally sufficient, but with no output schema there is no indication of the return shape (single object vs. array), total-count behavior, or default result volume — a gap an agent calling with no id and no query would care about.

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 83% and the schema already documents id, skip, sort, limit, query, and fields individually, including the '-' descending prefix and 1-500 clamped limit. The description's mention of id/query is largely redundant with that, so baseline 3 applies.

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

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

The description states a specific verb ('Find') and resource ('LimNotification records') and clarifies the two access modes (single id vs. filtered query). It is clear but does nothing to differentiate this tool from its ~45 identically-shaped query_lim* siblings beyond the resource name that is already in 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?

'Pass id for one record, or query for a filtered list' gives implicit selection guidance between the two primary parameters, but there is no when-to-use/when-not framing, no mention of alternatives, and no prerequisites (e.g., that no filters returns all records). Adequate but thin.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds only the mode distinction (single vs list), which is thinly behavioral; it says nothing about authorization scope, result caps, or pagination interactions between skip/limit, so it goes only slightly beyond the annotation.

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

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

A single front-loaded sentence with zero filler, and the primary usage decision (id vs query) is stated first. It is perhaps overly terse given a 6-parameter, nested-object tool, but nothing is wasted.

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

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

For a tool with 6 parameters, a nested MongoDB-style query object, and no output schema, the description covers the core calling pattern but leaves the 'fields' projection parameter completely undocumented in both schema and description, and says nothing about return shape or sort/limit defaults.

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 83%, so the schema already documents id, skip, sort, limit, and query in reasonable detail. The description's mention of id/query mirrors what the schema already states and adds no format or syntax detail (e.g., query operator support). Baseline 3 applies.

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

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

The description uses a specific verb ('Find') with a named resource ('LimParentCode records') and explicitly splits the two operating modes (single record by id vs. filtered list). It does not explain what a LimParentCode domain entity actually is, so an agent must infer it from the name alone, but the operation itself is unambiguous.

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

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

It gives conditional guidance for the tool's two internal modes ('pass id for one record, or query for a filtered list'), which is genuinely useful routing. However, it offers no guidance about when to prefer this tool over the ~55 sibling query_lim* tools, and no exclusions or prerequisites.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds the dual-mode behavior (single vs list), which is useful context, but says nothing about defaults, clamping (limit), pagination interaction, or result shape.

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

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

A single front-loaded sentence with zero waste that captures both usage modes. Nothing is padded or redundant.

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 6-parameter query tool with a nested MongoDB-style query object and no output schema, the description covers the id-vs-query decision but leaves sort, skip, limit, and fields behavior to the schema. Adequate but thin given the tool's complexity.

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

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

Schema coverage is high (83%), so most parameters are documented in the schema itself, making 3 the baseline. The description only reinforces the id/query distinction, adding marginal meaning beyond what the schema already states.

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