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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so the safety profile is covered. The description adds real scope information by bounding the check to lexical analysis rather than compilation or type checking. It says nothing about whether diagnostics are returned as errors or a list, or about limits on the code size, though an output schema exists to carry 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 no filler, front-loading the action and following immediately with the disambiguation. Nothing could be removed 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?

The tool is simple (one required string parameter) and has an output schema, so the description carries little burden and the scope statement plus exclusion is nearly sufficient. A brief note on what the checks report back, or that the input is limited in size, would make it 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 description coverage is 0%, so the description would need to compensate, but it adds nothing about the single 'code' parameter. The parameter's meaning (the code to be lexically checked) is largely self-evident from the tool's stated purpose, but the 131072-character cap is undocumented 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 and resource: 'run language-specific lexical checks' on code. It also draws a boundary against compilation and type checking, which separates it from lsl_compile_code without naming it. 'Language-specific' is left implicit (LSL is only inferable from the tool-name prefix), which keeps it short of a 5.

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

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

The clause 'this is not compilation or type checking' is a genuine when-not signal that steers agents away from lsl_compile_code for syntax/type validation. However, there is no positive 'use this when...' framing and the alternative tool is never named, so the routing is 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?

Annotations already declare read-only, idempotent, non-destructive, closed-world behavior, and the description stays consistent while adding real context an agent would not otherwise have: the compilers are pre-configured and hash-pinned, and submitted code is never executed. It stops short of describing failure modes or which compilers are configured.

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

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

Two tight clauses with the core action and the key safety constraint front-loaded; no filler. Slightly telegraphic — the 'Separate from lexical checks' fragment is clipped enough that it reads as a note rather than guidance.

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

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

An output schema exists, so return values need not be explained, and the tool is a single-parameter operation. Still missing: what a compile failure looks like versus a transport error, and whether the language is implicitly LSL given the sibling set.

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 0% for the single 'code' parameter, but the parameter is self-describing and the description adds the meaningful nuance that the payload is compiled, not executed. No guidance on format, language version, or the 131072 max length — though those are largely schema-level concerns.

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 ('Run configured, hash-pinned local compilers') and scopes the behavior negatively ('never execute submitted scripts'). It gestures at sibling differentiation with 'Separate from lexical checks' (i.e., lsl_check_code) but never names the sibling, so the distinction requires inference from the prefix alone.

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

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

Usage is implied rather than stated: compile rather than lint, and do not expect submitted scripts to be executed. There is no explicit 'use this when you need to build/validate compilation' phrasing and no exclusions beyond the lexical-check contrast.

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

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

The annotations already establish read-only, idempotent, non-destructive behavior, so the description need not repeat safety traits. It adds that the notes are "source-backed" and cover pitfalls plus LSL-to-SLua migration, but does not disclose whether a topic miss returns all notes or how topics are matched.

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 no wasted wording. It efficiently states the content type and the topical scope.

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

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

For a simple one-parameter read tool with an output schema, the description covers the basic purpose and content. It remains incomplete because topic semantics are vague and it does not help the agent choose among several closely named sibling guidance and migration tools.

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

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

The schema has one optional topic parameter with 0% description coverage, so the description must compensate. It only says "by topic," giving the parameter meaning but not valid topic values, default behavior, or how an agent should choose a topic.

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 ("Read") and resource ("source-backed pitfalls and LSL-to-SLua migration notes") with scope "by topic." It is clear what the tool returns, but it does not distinguish itself from near siblings such as lsl_migration_guidance or slua_get_guidance.

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

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

There is no explicit when-to-use guidance or condition for selecting this tool over lsl_migration_guidance, slua_get_guidance, or the search/reference tools. The phrase "by topic" implies topical retrieval, but the agent is left to infer usage from the name and description.

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

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

Annotations already declare readOnlyHint, idempotentHint and non-destructive behavior, so the safety profile is covered. The description adds the useful behavioral trait that matching is exact and case-sensitive, but adds nothing about miss handling or result shape beyond the annotations.

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

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

One short sentence, front-loaded with the matching semantics and ending with what the result carries. 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 single-parameter lookup with an output schema and full annotation coverage, the description supplies enough to invoke it correctly. The remaining gap is explicit routing away from lsl_search_reference and any note on what happens when an exact match is not found.

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

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

The single 'name' parameter has no schema description (0% coverage), and the schema only supplies min/max length. The description compensates partially by conveying that the value must match exactly and case-sensitively, which is real semantic value, but it gives no format or naming-convention guidance.

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 and resource ('symbol lookup') and qualifies scope with 'exact, case-sensitive,' which sets it apart from a fuzzy search. It does not explicitly distinguish itself from the sibling lsl_search_reference, so an agent must infer the boundary.

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?

'Exact, case-sensitive' implies when this tool is appropriate (when you already know the symbol's spelling), and the existence of lsl_search_reference makes the alternative inferable. However, no when-to-use or when-not-to-use statement or sibling name is given explicitly.

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

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

The annotations already establish a read-only, idempotent, non-destructive, closed-world operation. "No automatic source rewriting" adds a useful capability limitation beyond those annotations by clarifying that the tool provides guidance rather than transformed code, but filtering and not-found behavior remain 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?

Two short sentences front-load the content scope and then state the key limitation. There is no filler or unnecessary 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?

For a simple guidance read with no required parameters and an output schema, the stated scope and no-rewriting limit make a basic unfiltered call viable. The undocumented filters and unstated migration direction and sibling relationship prevent confident targeted invocation and selection.

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

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

Neither topic nor symbol is explicitly explained despite 0% schema description coverage. The listed difference categories indirectly suggest possible topics and "per-API" hints at symbol lookup, but valid topic values, filter interaction, and symbol format are left unstated.

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

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

The description gives a concrete review task and scope: per-API counterparts plus event, timer, table, numeric, and conversion differences. It does not state the source and target languages or otherwise distinguish itself from slua_migration_guidance, so sibling differentiation remains weak.

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 supplies a clear use case—reviewing migration mappings and semantic differences—and an explicit boundary that it does not perform automatic source rewriting. It does not explain when to prefer lsl_get_guidance, lsl_lookup_symbol, or the SLua migration tool, leaving alternative selection inferential.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds some context about the reported dimensions (coverage, revisions, manual review dates), but does not explain what 'source-scoped' means or how the report is triggered.

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 single sentence is front-loaded and free of filler, stating the report content directly. 'Source-scoped' is slightly opaque but does not make the sentence wasteful.

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

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

The tool is simple (no parameters, rich annotations, output schema present), so the description carries a lighter burden. However, the central qualifier 'source-scoped' is unexplained and no alternative routing is provided, leaving an agent unsure about when this report is the right choice over lsl_search_reference or lsl_check_code.

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 zero parameters, there is no parameter semantics burden; the baseline is 4. The only minor friction is that the phrase 'source-scoped' could momentarily suggest an argument, but the empty schema makes the no-argument nature clear.

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 ('Report') and a specific resource set ('source-scoped reference coverage, revisions and manual review dates'), which is clearly distinct from siblings like lsl_search_reference or lsl_lookup_symbol. It stops short of explicitly contrasting itself with those siblings, so an agent must infer the distinction.

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

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

There is no guidance on when to call this tool versus lsl_search_reference, lsl_lookup_symbol, or lsl_check_code, and no prerequisites or exclusions are stated. The agent is left to infer the use case from the purpose phrase alone.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the description's job is to add behavior beyond that. It does: 'deterministic ranking' tells the agent result order is stable and reproducible, and 'bounded pagination' signals that result sets are capped and paged. It does not disclose the actual bounds or how ties break, which is the remaining gap.

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 or redundancy; every phrase carries information. It is terse to the point of leaving gaps, but nothing in it is wasted.

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

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

An output schema exists, so the description need not explain return values, and annotations cover safety. Still, for a four-parameter search tool with zero schema descriptions, the missing explanation of the `kind` filter and query tokenization leaves the agent guessing on parameters it must supply.

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 0% across four parameters, so the description carries the full burden and largely drops it. 'Bounded pagination' hints at limit/offset being capped, but nothing explains the `kind` enum filter (function/event/constant/type) or what characters/tokenization `query` accepts. Only one of four parameters gets indirect treatment.

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 operation: a 'literal word search' over the reference, adding the key distinction that matching is on exact words rather than fuzzy or relevance-ranked search. That is more informative than the name alone. It stops short of naming or contrasting the adjacent tools (lsl_lookup_symbol, slua_search_reference), so the agent must infer that this is the LSL-side word-index search.

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

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

There is no statement of when to choose this tool over lsl_lookup_symbol or lsl_get_guidance, and no prerequisites or exclusions. The phrase 'literal word search' weakly implies it is for exact-term lookups rather than symbol resolution, but that is inference, 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, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds the useful behavioral constraint that results are purely lexical and will not catch semantic or type errors — a real expectation-setting detail. It says nothing about error reporting, severity levels, or partial/incomplete code handling, which keeps it at a 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 sentence, front-loaded with the affirmative purpose and immediately followed by the negative scope. Nothing is wasted and the semicolon construction keeps both halves tight.

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

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

An output schema exists, so return values need not be explained, and annotations cover safety. What remains uncovered is how diagnostic results should be interpreted and whether fragments are acceptable input — modest but real gaps for a lint-style 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 0% for the single 'code' parameter, but the parameter is near self-describing given the tool's purpose. The description does not clarify whether the input may be a fragment vs a whole file, nor anything about the 131072-character limit or language/version assumptions.

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 and resource ('Run language-specific lexical checks') and sharply bounds the scope by ruling out compilation and type checking. That boundary lets an agent separate it from lsl_compile_code/slua_compile_code, though it does not name those siblings explicitly.

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?

Guidance is implied by exclusion: the description tells the agent this is not compilation or type checking, which indirectly points to the compile siblings for those needs. There is no explicit when-to-use statement, no mention of prerequisites, and no named alternative.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety bar is lower; the description still adds meaningful behavior by promising only pinned local compilers are used and that submitted scripts are never executed. It does not mention timeouts, resource limits, or how compiler failures surface, which keeps it from a 5.

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

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

Two short clauses with zero padding; the core action comes first and the sibling differentiation follows immediately. Every word carries information.

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

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

With annotations covering safety and an output schema covering return values, the description needs only purpose and safety semantics, which it supplies. It stops short of clarifying the language family (slua vs lsl siblings) or error/diagnostic behavior, which would fully close the gap for a compiler 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 coverage is 0% and the single parameter 'code' is undocumented beyond its type and 131072 max length. The description says nothing about the expected source language, encoding, or size limits, though the single obvious 'code' parameter needs little explanation. Baseline 3 is appropriate for a one-parameter tool whose schema does the rest minimally.

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 — running configured, hash-pinned local compilers — and explicitly separates itself from the lexical-check siblings ('Separate from lexical checks'). An agent can tell this apart from lsl_check_code/slua_check_code without opening any schema.

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

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

'Separate from lexical checks' gives a clear condition for choosing this tool over the check_code siblings, but the sibling is not named and there is no guidance on when compilation is appropriate versus reference/guidance lookups in the same family. Clear context, no explicit exclusion list.

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

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

The annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, so safety and side effects are covered. The description adds a meaningful trait: content is source-backed, so the agent can trust the returned notes. It says nothing about invalid-topic behavior or the response shape, so it only adds modest value beyond the annotations.

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

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

It is one tightly packed sentence with no filler, and it leads with the verb and the resource. That said, its brevity comes at the cost of the missing guidance; it is concise but slightly under-specified.

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?

Because there is an output schema, return values need no explanation. The remaining needs are valid topic values and the distinction from the sibling guidance tools. Neither is covered, but the tool's surface is small, so these are moderate rather than severe gaps.

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

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

The schema documents the single 'topic' parameter at 0% description coverage: no enum, no description, no examples. The description only echoes 'by topic' and does not list valid topic values, say whether topics are free-form strings, or note the 'all' default. The agent is left to guess what to pass.

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

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

The description gives a specific verb and resource: read source-backed pitfalls and LSL-to-SLua migration notes, scoped by topic. That separates it from the reference/lookup/compile tools in the sibling list. The gap is that it does not say how it differs from lsl_get_guidance or slua_migration_guidance, which sound like they serve the same purpose.

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

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

There is no statement of when to use this tool versus lsl_get_guidance, slua_migration_guidance, or slua_search_reference, and no exclusions or prerequisites. The only implied usage is the phrase 'by topic,' which narrows how to call the tool but not why or when to choose it.

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

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

The annotations already establish that this is a read-only, idempotent, non-destructive, closed-world lookup. The description adds useful behavior by specifying exact case-sensitive matching and noting that results include official source, caveats, and a review date, but it does not describe miss/error behavior or source-selection limits.

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 no wasted wording. It conveys the key matching rule and result context 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?

This is a simple lookup tool with an output schema and strong annotations, so it does not need to explain return values or safety. Still, the description lacks explicit routing against search and sibling lookup tools and does not clarify the SLUA symbol namespace.

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 0%, so the description must compensate for the single required name parameter. It adds that lookup is exact and case-sensitive, which is meaningful, but it does not describe the expected symbol-name format, namespace, or constraints such as the 128-character limit.

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: exact, case-sensitive symbol lookup. It implies differentiation from search tools by emphasizing exactness, but it does not explicitly identify the SLUA/Lua namespace or distinguish itself from the sibling lsl_lookup_symbol.

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

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

The phrase 'Exact, case-sensitive symbol lookup' implies this should be used when the exact symbol name is already known, rather than for discovery. However, it does not explicitly say when to use this instead of slua_search_reference or name the alternative search 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?

Annotations already declare readOnly, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description does add one genuinely useful trait beyond the annotations: this tool will not rewrite source code, which prevents a false expectation of transformation. It says nothing about result shape, scope limits, or how "exact" the counterparts are (version coverage), so it is only a partial gain.

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

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

Two compact sentences with the capability up front and the key caveat last; no filler. It is arguably too compressed given the schema gaps, but nothing is 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?

An output schema exists, so return values need no explanation, and the annotations cover safety. The remaining gaps are unenumerated topic values, the unspecified default of "all," the undocumented symbol format, and the missing direction/versions of the migration mapping.

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 0%, so the description must carry the load, and it does partially: the listed areas (event, timer, table, numeric, conversion) plausibly name accepted topic values, and "per-API counterparts" hints that symbol selects an API to diff. However, it never states the default "all" behavior, the relationship between topic and symbol, or the string format expected for symbol.

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?

"Review exact per-API counterparts and event, timer, table, numeric and conversion differences" conveys that this is a cross-language mapping/differences reference, but the source and target languages are never named and the tool name is the only cue (slua_ vs the lsl_ siblings). The verb "Review" is also loose for a lookup-style tool, so the purpose is inferable rather than stated.

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

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

There is no explicit when-to-use statement and no alternative named. The only routing hint is the negative "No automatic source rewriting," which weakly implies the check/compile siblings handle rewriting, but the agent must infer that.

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

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

The annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds only what the report contains, not scope limits, freshness, or which reference corpus counts, so it is useful but thin beyond the annotations.

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

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

One front-loaded sentence with no filler, which suits a zero-parameter status tool. The only cost is the unexplained compound "source-scoped reference coverage," which is dense jargon packed into an otherwise efficient line.

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

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

With no parameters, an output schema, and full annotations, the remaining burden is disambiguation, which is unmet. An agent can call it correctly but cannot confidently choose it over lsl_reference_status or know what "source-scoped" means in this tool's context.

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

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

The tool takes zero parameters and the schema has 100% description coverage, so there is nothing to disambiguate. The description is consistent with a no-argument status call and adds no conflicting parameter claims.

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?

A concrete verb ("Report") paired with specific reported content (reference coverage, revisions, manual review dates), so the resource is identifiable. However, it never mentions that this is the SLua reference family or how it differs from the near-identical sibling lsl_reference_status, and "source-scoped" is left unexplained.

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

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

No when-to-use guidance at all: it does not say whether to call this before a lookup, after code changes, or instead of slua_search_reference / slua_lookup_symbol. With 13 siblings in two parallel families, the absence of routing is a real gap.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds two genuine behavioral traits beyond that: ranking is deterministic (results are stable across calls) and pagination is bounded. It stops short of saying whether matching is substring, whole-word, or case-sensitive, which is the most important behavioral detail for a "literal word search" 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 well-formed sentence with no filler, and the differentiating detail ("literal word search") is front-loaded. Its brevity is efficient rather than padded, though the space saved is spent nowhere useful given the undocumented parameters.

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

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

An output schema exists and rich annotations are present, so the description needn't explain return shape or safety. Still, for a four-parameter search tool with zero schema documentation, the agent is left without the meaning of `kind`, the matching semantics of `query`, or any routing rule against the twelve sibling lookup/search tools.

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

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

Schema description coverage is 0% across all four parameters, so the description carries the full burden and largely drops it. The `kind` filter (function/event/constant/type) is a meaningful narrowing dimension that is never explained, and nothing clarifies that `query` is matched word-wise rather than as a substring, or how `limit`/`offset` interact for paging.

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 the mechanism ("literal word search") which usefully distinguishes it from a semantic/fuzzy search, and the tool name supplies the resource (reference docs). However, it never states which corpus is searched (SLua reference) and never distinguishes itself from the near-identical sibling lsl_search_reference or from slua_lookup_symbol, so the agent must infer the scope from the name prefix alone.

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

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

There is no when-to-use guidance at all — nothing says whether to prefer this over slua_lookup_symbol for exact symbol names, or over lsl_search_reference for the other dialect. The word "literal" hints that it will not handle conceptual queries, but that is inference rather than stated guidance.

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