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 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 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?

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 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?

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 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 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?

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 no further behavioral context such as pagination behavior, default limits, or what a returned record looks like, leaving the annotation to carry 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?

A single front-loaded sentence with zero waste that leads with the primary retrieval pattern. 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 6 params and 83% schema coverage plus no output schema, the description covers the essential calling patterns. It is adequate, though it omits any note on what fields a LimPhoneCall record contains or return volume.

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, query, and fields including the '-' descending convention and clamping. The description only restates the id-vs-query split already present in the schema, adding no parameter meaning 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 clear verb 'Find' plus resource 'LimPhoneCall records' and distinguishes two retrieval modes (single by id vs filtered list). However, it does nothing to differentiate this resource from the dozens of near-identical sibling query_lim* tools, so an agent gets no help distinguishing it from query_limphonecontact or query_limcall.

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?

Clearly states the two usage modes: 'pass id for one record, or query for a filtered list,' which routes the caller between the id and query paths. It offers no exclusions or guidance on when to prefer a sibling tool, so context is clear but alternatives are absent.

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 dual-mode behavioral context (single vs filtered list), but omits any return/result shape or note on the default/clamping behavior that the schema mentions. Adds modest value given annotations carry the safety burden.

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

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

A single front-loaded sentence with the resource first and the mode rule after; zero waste. Slightly terse given the six parameters it governs, but well-structured.

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

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

For a 6-parameter, read-only query tool with no output schema, the description covers the core dual-mode behavior but is thin on pagination, sort, and fields semantics, relying on the schema. 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 baseline is 3. The description restates the id/query split already documented in the schema's 'id' parameter description, adding little beyond what 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?

States a specific verb ('Find') and resource ('LimPhoneContact records') and clarifies the two operating modes. It does not name or contrast alternatives, but the resource name itself distinguishes it from the ~45 sibling query_lim* 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?

Distinguishes the two modes (pass id for one, query for a list), which is useful intra-tool guidance. However it provides no guidance on when to use this tool versus alternatives or prerequisites, 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 id-vs-query mode split but says nothing about default projection, result caps, or pagination behavior beyond what the schema states. Adequate, 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?

A single sentence that front-loads the verb+resource and then the mode split. No filler, no redundancy.

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

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

For a 6-parameter tool with a nested query object and no output schema, the description is thin: it does not describe what a returned record looks like, default field projection, or how the nested MongoDB-style filter is validated. The schema carries most of the load, so this is minimum viable rather than 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 id, skip, sort, limit, and query in detail. The description's id/query contrast largely restates the schema's own 'omit to query many' note, adding little new meaning. Baseline 3 is correct.

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 (LimPhoto records), and splits the two invocation modes (single by id vs filtered list by query). It does not differentiate from the ~45 sibling query_lim* tools beyond the resource name, but that name is the only real distinction available.

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?

Clearly tells the agent which parameter selects which mode: 'pass id for one record, or query for a filtered list.' That is actionable routing guidance, though it offers no exclusions or advice on when to prefer a sibling 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 readOnlyHint annotation already tells the agent this is a safe read, so the description isn't obliged to restate that. It adds the single-vs-list mode distinction but says nothing about pagination defaults, result shape, or how the query filter is bounded, leaving behavioral gaps for a tool with nested filter objects.

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 immediately explains the two invocation paths. No filler or redundancy.

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

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

For a 6-parameter query tool with a nested filter object and no output schema, the description is minimal: it omits pagination behavior, return shape, and the fields projection. It is adequate to select the tool but not to call it fully informed.

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 most parameters are already documented in the schema, and the description only echoes id and query semantics. The undocumented 'fields' parameter is left entirely unspecified in both places, and no detail on filter syntax or sort format is added 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?

"Find LimReferral records" gives a clear verb and a specific resource, and the id/query split tells the agent this is a dual-mode fetch tool. It does not explicitly contrast with the dozens of sibling query_lim* tools, but the resource name itself disambiguates 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 states the two modes ('pass id for one record, or query for a filtered list'), which is a genuine when-to-use signal for its own parameters. It offers no exclusions, prerequisites, or pointers to sibling/alternative tools, so guidance is implied rather than complete.

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 as a safe read operation. The description adds one behavioral fact—that it can return either a single record or a list—but says nothing about default limits, pagination, sorting behavior, or return shape, all of which affect invocation.

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. It efficiently conveys purpose and the two main usage paths.

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 minimal. It does not describe the return format, default limit behavior, or what happens when no id or query is supplied, though much parameter detail is covered in the schema.

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

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

Schema coverage is 83%, so the baseline is 3. The description goes beyond the schema by explicitly linking 'id' to fetching one record and 'query' to retrieving a filtered list, clarifying the two primary parameters' roles.

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 LimSite records'. It also distinguishes the two retrieval modes (single record via id vs. filtered list via query), making it clear how this tool differs from sibling query_lim* tools that target other resources.

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 when to use each mode: 'pass id for one record, or query for a filtered list.' It lacks when-not guidance or named alternatives, but there is no sibling tool for the same resource, so the primary usage decision is 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, so the description only needs to add context. It adds the dual-mode behavior and the fact that omitting id switches to list mode, but says nothing about pagination defaults, result caps, or how the filtered list behaves when query is absent. Adequate but thin 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 sentence, front-loaded with the verb and resource, and the mode-selection clause is placed immediately after. No filler, no redundancy.

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

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

For a 6-parameter read tool with a nested query object and no output schema, the description plus the rich schema fields cover what an agent needs to invoke it correctly. Return shape and default-limit behavior are left implicit, which is a minor gap given no output schema exists.

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 the parameter descriptions already explain skip, sort, limit (with clamping and default), and the MongoDB-style query shape. The description confirms id/query semantics but adds no syntax or format detail beyond what the schema documents, 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?

Names a specific verb ('Find') and resource ('LimStoreApp records') and clearly splits the two operating modes (single record by id vs filtered list via query). It does not differentiate itself from the forty-plus sibling query_* tools beyond the resource name, but within its own family the purpose is unambiguous.

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

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

Explicitly states the selection rule between modes: pass id for one record, use query for a filtered list. There is no guidance on exclusions or when another tool would be a better fit, but the branch condition an agent actually needs 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?

readOnlyHint=true already tells the agent this is a safe, non-mutating read, so the description carries a lighter burden. It adds the single-vs-list behavioral distinction, but says nothing about default result size, clamping, or pagination behavior beyond what the annotations and schema supply. Adequate but 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 compact sentence with the primary action front-loaded and the two modes stated in the order an agent would evaluate them. No filler, though the brevity also means few marginal details are conveyed.

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 annotations covering safety and no output schema, the description is minimally sufficient: it conveys lookup vs. list intent. It leaves gaps around the nested MongoDB-style query filter semantics, field projection behavior, and what a result set looks like, which the schema only partially covers.

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 (with clamping and defaults), and query. The description only restates the id/query modes and adds no syntax, format, or interaction details (e.g., whether id ignores query). Baseline 3 applies 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 ('LimStoreReview records'), and the resource name alone separates it from the ~40 sibling query_* tools. It also distinguishes the two operating modes (single record by id vs. filtered list via query). It stops short of 5 because it never articulates anything resource-specific about LimStoreReview that would help an agent choose among overlapping data sources.

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 real mode-selection guidance: id implies single-fetch, query implies list. However, there is no when-to-use/when-not framing relative to alternatives, no note on combining id with query, and no guidance on which fields are worth filtering by.

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. Beyond that, the description's mode/result-cardinality hint largely repeats the id parameter's own schema text ("Fetch one record by id; omit to query many") and says nothing about pagination, default limits, or result volume.

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 modes are stated in the order an agent would reason about them (id first, then query). Nothing wastes space.

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 six-parameter tool with no output schema and one nested object, the description adequately frames the two invocation modes, and pagination/sorting details live in the schema. It could say more about what a LimStory record contains, but no output schema exists so that burden is light.

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 nearly every parameter including the MongoDB-style query example and the limit clamping behavior. The description adds no syntax, format, or defaulting detail beyond what the schema already states, which is the baseline case.

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 ("LimStory records"), and distinguishes the two operating modes (single by id vs. filtered list). It does not differentiate itself from the ~48 sibling query_lim* tools beyond the resource name, so it is clear but not sibling-aware.

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 mode-selection guidance: pass id for one record, query for a filtered list. It offers no when-not guidance, no prerequisites, and no routing advice relative to the many other query_lim* tools, so usage is implied rather than fully specified.

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 externally. The description adds the meaningful behavioral fact that the same tool serves both single-fetch and list-query shapes, but says nothing about pagination defaults or result size (left to 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 with the resource and both modes front-loaded and no 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 6-parameter tool with a nested MongoDB-style query object and no output schema, the description is minimal but the schema carries most parameter detail. It does not explain the query-object form or the fields projection, so it is adequate rather than 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 semantics. The description only echoes the id/query distinction and adds no syntax or format detail beyond what the schema provides, 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?

States a specific verb ('Find') and resource ('LimVidComment records'), and distinguishes its two operational modes (single-record by id vs filtered list by query). It is clear what the tool does, though it does not explicitly differentiate from the many sibling query_* tools 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?

The description tells the agent how to choose between the two modes (pass id for one record, query for a filtered list), which is useful mode selection. However, it gives no guidance on when to prefer this tool over alternatives or any preconditions, leaving usage largely 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?

readOnlyHint=true already tells the agent this is a safe read, and the description adds only the id/query mode split, which is essentially purpose rather than behavior. Nothing is said about default limits, clamping, sorting semantics, or what the response shape looks like, so the description contributes little 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 compact sentence with the two call modes front-loaded and zero padding. It is appropriately sized for what it conveys, though it could still afford one clause on scoping or result defaults.

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 essential calling information is mostly present via structured fields. However, the description omits any sibling routing guidance in a family of ~45 near-identical query tools, leaving an agent with little basis for choosing this one.

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 itself documents id, skip, sort, limit, and query thoroughly. The description's id-vs-query framing duplicates what the id parameter's schema description already says ('Fetch one record by id; omit to query many'), adding no new parameter meaning.

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

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

States a clear verb ('Find') and specific resource ('LimVidFollow records'), and distinguishes the two operational modes (single by id vs. filtered list by query). It does not, however, differentiate itself from the large family of sibling query_limX tools beyond the resource noun.

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

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

The description implies usage: pass id for one record, or query for a filtered list. That covers mode selection but gives no guidance on when to reach for this tool versus sibling query tools, no preconditions, and no note on pagination or result-set sizing behavior.

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 already tells the agent this is a safe read. The description adds the id-vs-query branching but nothing about return format, pagination behavior, default limits, or the nested filter semantics — all of which matter for a list-heavy query tool. With annotations covering only safety, the description leaves most behavioral context undisclosed.

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 that front-loads the verb and resource and packs the dual-mode guidance without waste. Nothing 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 6-parameter tool with a nested MongoDB-style filter object and no output schema, the description is adequate but thin — it never indicates the shape of returned records or how the nested query interacts with skip/limit/sort. The schema covers most parameters, but a query tool with an output-less contract would benefit from more.

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%, well above the coverage threshold where the schema does the heavy lifting, so baseline 3 applies. The description's id/query distinction is already documented in the schema's own param descriptions, so it adds no meaning beyond structured data. The undocumented 'fields' array is not described either.

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 clear verb ('Find') and resource ('LimVidVideo records'), and distinguishes the two access modes (single id vs filtered query). The resource name is specific enough to separate it from sibling tools like query_limvidcomment and query_limvidfollow, though it does not explicitly name a sibling the way the strongest definitions do.

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

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

The description gives a conditional on which parameter to use ('pass id for one record, or query for a filtered list'), which implies usage. However, there is no explicit when-to-use versus alternatives, no statement of when this tool is inappropriate, and no prerequisites for the query path.

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, so the description's burden is lower. It adds the id-vs-query behavioral split, which is useful, but says nothing about pagination defaults, result limits, or what an empty query returns. Adequate but thin against 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?

A single compact sentence that front-loads the action and the mode-selection rule. No padding or redundancy.

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

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

With 6 parameters, a nested query object, a fields projection array, and no output schema, the description covers only the id/query fork. Projection, sorting, and pagination behavior rely entirely on the schema. Just barely sufficient but leaves real gaps for a complex list tool.

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

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

Schema description coverage is 83%, so the schema already documents id, skip, sort, limit, and query with meaningful detail (including the 1-500 clamp and '-' descending prefix). The description restates the id/query distinction but adds no syntax or semantics beyond the schema. 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?

States a specific verb (Find) and resource (LimWalletCard records), and distinguishes the two operational modes: single-record lookup by id versus filtered list via query. This is clear, though the sibling namespace is differentiated only by the resource name inherent to the tool, not by 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?

Explicitly tells the agent which parameter selects which behavior: 'pass id for one record, or query for a filtered list.' That is clear usage context for the two modes. It stops short of naming when-not conditions or listing alternative tools.

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