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

Beyond the readOnlyHint=true annotation, the description fully explains the behavior: per-row recalculation using x=varColumn value and i=row sequence, a default threshold of 1%, and reporting only deviating rows. It also discloses a dependency on list_tables column patterns. No contradiction with annotations.

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

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

Two sentences with no wasted words: the first front-loads the purpose and algorithm, and the second appends a short actionable prerequisite. Every sentence 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 5-parameter tool with no output schema, the description covers core semantics, default threshold, use case, and a prerequisite. It does not specify the exact shape of the returned rows (e.g., whether each row includes row index, original value, or deviation), but the combination of 'rows' and formula-variable explanation gives a reasonably complete picture.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful value by defining expression semantics (x and i, with an example), noting varColumn is typically a rank/sequence column, and specifying thresholdPct's default of 1%. This goes beyond the schema descriptions.

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

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

The description clearly identifies a column audit tool: it recomputes each row of a specified column against an anchor formula and reports rows that deviate beyond a threshold, with a specific goal of finding manual adjustment breakpoints. However, it does not explicitly contrast itself with similar siblings like recon_diff or eval_formula, so it lacks 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 a concrete prerequisite ('先看 list_tables 的 columnPatterns 了解列的既有模式') and an intended use case (identifying hand-tuned breakpoints in growth curves). It stops short of naming alternative tools or giving when-not-to-use guidance, so it is below the 5 level.

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 only declare readOnlyHint=true; the description adds meaningful behavioral context: deterministic core engine, not LLM-estimated, and optional Monte Carlo stochasticity when simulations are provided. It also discloses the returned metrics, which is useful 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?

One compact sentence that front-loads the core purpose, then lists outputs, optional behavior, and intended use case. No filler or redundancy; every clause 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 no output schema, the description compensates by listing all key return values and rating scale. It also covers the optional simulation parameter and the tool's use case, making it complete enough for an agent to select and invoke correctly.

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

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

Schema description coverage is 100%, so the schema already documents all parameters and defaults. The description adds the overall simulation semantics and maps simulations to 'optional Monte Carlo win rate,' but it does not add per-parameter meaning beyond the schema.

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

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

Description states a specific action and resource: deterministic player-vs-enemy battle simulation, explicitly distinguishing itself from LLM estimation and listing concrete outputs (kill slashes, received slashes, killRatio, rating, DPS, optional Monte Carlo win rate). This clearly separates it from siblings like simulate_gacha and compute_power.

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 clear context: 'used to evaluate combat balance after changing numbers.' It implies when to use it but does not explicitly name alternative tools or exclusion conditions, though the deterministic-vs-estimation distinction gives some routing 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?

The readOnlyHint annotation already signals a safe read-only operation, and the description adds useful behavioral context by calling it a deterministic engine and explaining the calculation model. This goes beyond the annotation without contradicting it.

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 dense sentence that front-loads the purpose and model, then covers input, output, and use case without wasted words. It is concise yet complete.

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

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

There is no output schema, so the description helpfully lists the returned values (power, EDPS, EHP, marginal values). Combined with the schema and annotation, an agent has enough to call the tool correctly, though output structure and edge cases are not detailed.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds example Chinese keys and the formula model, but the schema already documents attrs, stdAtk, and stdSpeed, including defaults, so no major semantic gap exists.

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

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

The description clearly states that the tool computes power using a deterministic EHP×EDPS square-root model, takes an attribute panel as input, and returns power, EDPS, EHP, and marginal values. This is specific enough to distinguish it from siblings like battle_simulate or power_curve.

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 explicitly says it is for comparing power before and after changing values, giving a clear intended context. However, it does not mention exclusions or alternatives such as battle_simulate for actual battle 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?

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds meaningful behavioral context: evaluation is deterministic and values are always computed by the engine rather than estimated, which tells the agent the result is exact and reproducible.

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

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

The description is two concise clauses, front-loads the core function, and every sentence adds useful information. There is no filler or repetition of schema details.

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 two-parameter formula evaluator with full schema coverage, the description is largely complete: it covers supported syntax, variable-name language, determinism, and intended use. It does not discuss error behavior or the exact return shape, but the numeric-result nature is strongly implied by '数值永远由引擎算而非估算'.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds beyond the schema by specifying the supported formula grammar (four arithmetic operations, powers, parentheses) and explicitly confirming Chinese variable names are allowed. This helps the agent construct valid expressions.

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 ('数值公式'), and enumerates supported constructs (四则/幂/括号/变量) including Chinese variable names. It also names concrete uses—verifying anchor formulas and quick arithmetic—so an agent can distinguish it from sibling calculation/simulation tools.

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

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

The description explicitly says when to use the tool: for verifying anchor formulas and quick arithmetic. It does not explicitly name alternatives or exclusion criteria, but the clear use-case framing gives enough context for an agent to select it among formula-related siblings.

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?

Beyond the readOnlyHint annotation, the description discloses the precise output structure, the automatic conversion of Chinese column names to string keys, the optional column narrowing behavior, and the over-1MB rejection path. This gives the agent a detailed picture of what invoking the tool entails.

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 compact and front-loaded with the primary action and output format, followed by key options, size-limit behavior, and prerequisite. There is no redundant or filler text.

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

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

For a three-parameter tool with no output schema, the description covers output shape, default format, column-name handling, size-limit rejection, and how to obtain the required table parameter. An agent has enough information to call it correctly.

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

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

Schema description coverage is 100%, so the parameter descriptions already document table, format, and columns. The tool description mostly restates these facts and adds no novel parameter-level semantics 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 clearly states the tool exports the current workspace's table as a Lua record array module or JSON array text, naming the exact output formats. It implies distinction from read_table by focusing on serialized output, but it does not explicitly contrast itself with any sibling tool.

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

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

It provides clear usage context: get the table name from list_tables first, use the columns parameter to narrow large exports, and expect rejection with guidance when output exceeds 1MB. It does not state when to prefer this over alternatives or explicitly list 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, and the description is consistent, describing a scanning and output operation with no mutation. It adds valuable behavioral detail beyond the annotation by specifying exactly what it outputs (grade levels, coverage, orphan table judgment) and that it does not persist results itself (delegates to save_structure). This enriches the read-only context.

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, dense run-on sentence with multiple embedded clauses and technical criteria. While it front-loads the purpose, the excessive detail (e.g., specific header patterns) makes it harder to parse quickly. It could be split into clearer sentences without losing information.

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

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

With no parameters and no output schema, the description must carry the burden of explaining what the tool does and what it returns. It lists the outputs (workspace grade, per-table grade, coverage, orphan table detection) and the integration with save_structure. This is adequate for an agent to call it correctly, though it doesn't specify the exact data structure of the output.

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

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

The tool has zero parameters and 100% schema coverage (vacuously), so the baseline is 4. The description doesn't need to explain parameters; it instead explains the logic and outputs, which is appropriate.

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

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

The description clearly states the tool's purpose: grading a workspace by scanning all tables and classifying them into A/B/C levels based on specific criteria. It also mentions the outputs (workspace grade, per-table grade, coverage, orphan table detection), making it highly specific and distinct from sibling tools like profile_table or infer_foreign_keys.

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 positions itself as the 'first step of reverse integration', giving clear context on when to use it. It also references save_structure as a follow-up action, which helps an agent understand the workflow. However, it doesn't explicitly state when not to use it or mention alternative tools for other steps, so it falls 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 no annotations present, the description carries full weight for behavioral disclosure. It explicitly discloses the destructive behavior ('同名工作区整体覆盖重建'), the non-destructive check mode, the heuristic headerRows detection plus retry fallback, the auto-merging of two-row headers, and the side-effect of setting the current workspace. This is unusually transparent for a tool with no annotations.

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

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

The description is dense but well-organized, front-loading the primary purpose (import and create workspace) before detailing modes, parameter behavior, and post-import usage. Every clause carries useful information, though the long first sentence with many subordinate clauses makes it slightly harder to parse quickly than a bulleted structure would be.

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

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

Given the tool's complexity (two modes, heuristic behavior, destructive overwrite, normalized output artifacts), the description covers most of what an agent needs: input path, sheet selection, header handling, check-mode behavior, and follow-up tool suggestions. There is no output schema, and the description does not fully specify the return shape for the import mode beyond mentioning echo and findings; slightly more detail about the success response would make it 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 100%, so the baseline is 3. The description adds meaningful semantic context beyond the schema: it explains why headerRows matters (double-row headers become 'parent.child' composite names), what mode=check actually validates, and that same-name workspaces are overwritten. It doesn't add much about workspaceName or sheets beyond what the schema already states, but the added behavioral context raises it above baseline.

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

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

The description states a specific verb ('import'), a concrete resource ('local xlsx file absolute path'), and the resulting artifact ('normalized tables/*.json + workspace.json'). It clearly distinguishes itself from the post-import sibling tools by noting those are usable after import, and it enumerates its two modes (import vs check) so an agent knows exactly what the tool does.

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 context for when to use the tool: to build a workspace from an xlsx file, and mode=check as a pre-import validation step. It also names downstream tools (list_tables, read_table, audit_column, export_table) that should be used after import. It does not explicitly explain when not to use this tool or name direct alternatives, but the mode distinction provides solid practical 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?

The readOnlyHint annotation already covers safety; the description adds that fitting is deterministic and that the tool returns both the optimal rule and suspected manually-adjusted breakpoint rows. This gives an agent a clear behavioral model without contradicting 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?

The description is dense but front-loaded with the tool's role and outputs, followed by usage workflow. Every sentence adds information, though the single long sentence with semicolons and the reference to an unlisted write_table slightly reduce readability.

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 takes responsibility for explaining the return value (optimal rule with parameters, fitPct, expression, breakpoint rows), which it does. It also gives the follow-up workflow. It doesn't cover failure modes or non-numeric input, but for a read-only inference tool the essentials are present.

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

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

Schema description coverage is 100%, so the baseline is 3. The description restates that the column must be numeric and mentions breakpoint rows, but adds no meaningful detail about thresholdPct beyond the schema's '偏离阈值百分比（默认 1）'.

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 opens with a specific role ('列规则推断') and states the exact operation: fit three curve families (arithmetic/geometric/power) to a numeric column and return the optimal rule plus breakpoint rows. This clearly distinguishes it from related siblings like audit_column and power_curve by naming it the starting point for reverse analysis.

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

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

It explicitly says to use this tool first when analyzing growth/consumption curves, then hand the expression to audit_column for review. This gives concrete workflow context. It does not explicitly state when not to use alternatives, and it references 'write_table' which is not present in the sibling list, slightly weakening the routing 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 mark readOnlyHint=true, and the description adds substantial behavior: deterministic algorithm, exact acceptance conditions, confidence formula, no persistence, and output as unpersisted candidate edges for user confirmation. This goes well beyond the annotation baseline.

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 dense but every sentence carries meaningful information: algorithm, thresholds, confidence formula, output behavior, and usage modes. No filler or redundancy; appropriately compact for a nontrivial 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 inference tool with no output schema, the description covers the algorithm, validity criteria, confidence calculation, output form, persistence behavior, and both invocation modes. An agent has enough context to call it correctly and interpret results.

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

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

Schema coverage is 100%, so the schema already documents all three parameters. The description adds extra semantic value by explaining topN's purpose as preventing output explosion and clarifying fromTable/toTable as a paired directional-detection mode.

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

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

The description clearly states the tool's function: inferring foreign keys between tables using value-domain containment detection, and specifies the output as candidate relation edges with kind=foreign_key. It is specific and informative, but it does not explicitly differentiate itself from overlapping siblings like infer_table_relation or suggest_refs.

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

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

The description provides clear usage context: targeted detection via fromTable/toTable or default full-table pairwise scanning, with topN limiting output. It does not explicitly state when not to use this tool or name alternative tools for other scenarios, so it falls just short of a 5.

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

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

Annotations provide readOnlyHint=true so the agent knows this is a read-only operation. The description adds behavior such as '确定性拟合', tolerance handling (取整容限内免误报), and default behavior (auto-pairwise on all numeric columns) which goes beyond the schema. However, it doesn't elaborate on output format or failure behavior, but annotations cover the safety profile.

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 dense and packed with domain-specific terminology in Chinese, but it front-loads the core function first. It includes example structures and sibling references but could be slightly more concise. It earns a 3 because while informative, it's somewhat dense and may bury the simplest summary.

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

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

Given the tool's moderate complexity, the description explains the two modes (pair-specific vs auto-pairwise), default behavior, tolerance semantics, and relationship to sibling tools. There's no output schema, so the description carries the burden of conveying behavior, and it does so adequately. Minor gaps: no explicit statement of what 'deviation rows' output looks like, but context is otherwise 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 100%, so the schema documents all three parameters. The description adds context: columns default to all numeric columns, thresholdPct tolerance semantics (relative tolerance, max with rounding tolerance). This is useful but the baseline with full schema coverage is 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 clearly states the tool's purpose: infer linear column relationships (B ≈ A × k) and identify deviating rows, or automatically discover baseline anchor columns and coefficients across numeric columns. It distinguishes this from infer_column_rule explicitly, making its scope unambiguous.

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

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

The description explicitly states when to use it: for reconstructing generation structures like 'equipment attributes = baseline × equipment coefficient', and mentions comparing results with coefficient tables like read_table. It explicitly excludes column-internal temporal patterns, directing to infer_column_rule.

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

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

The readOnlyHint annotation already establishes a safe read operation. The description adds valuable behavioral context beyond that: the tool returns metadata for all tables in the current workspace, scoped to a 'numeric tables' inventory, and includes the specific fields returned. This is adequate for a simple listing 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?

Two sentences with no filler: the first states the resource and output fields, the second provides the usage trigger. Every sentence earns its place and the key scoping information (workspace, table metadata) is front-loaded.

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

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

For a metadata-listing tool with one optional parameter and no output schema, the description is complete: it names what is listed, the fields returned, and when to invoke it. No further return-format or pagination details are necessary for correct invocation.

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

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

The single 'module' parameter has 100% schema description coverage, listing valid filter values, so the schema does the heavy lifting. The description adds no additional parameter-level detail beyond implying the table list can be scoped by module, which keeps this at the baseline score.

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

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

The description states a specific verb ('列出' / list) and resource ('当前工作区的全部数值表') and enumerates the output fields (table name, module, row count, column names). It also positions the tool as a discovery step before querying, which separates it from read_table and other table-manipulation 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?

The description gives explicit when-to-use guidance: use it before answering numeric questions to locate the relevant table and available columns. It does not name alternatives or state when not to use it, but the trigger context is clear enough for an agent to choose this tool over read_table or export_table.

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, and the description reinforces this by stating it lists (a read-only action). It adds context about the workspace root and the controlling environment variable, which is beyond what annotations provide. No contradiction with annotations.

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

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

A single, front-loaded sentence that states the action and resource first, then the location, then a pointer to the sibling tool. No wasted words, efficient and complete.

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 parameterless list tool with readOnlyHint annotation and no output schema, the description covers the key operational detail (where workspaces are found) and points to the related tool. An agent has everything needed to call it correctly.

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

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

The tool has zero parameters, so per the rubric baseline is 4. The description adds no parameter details because none exist, but it does clarify the source of the list, which indirectly explains why no parameters are needed.

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

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

The description clearly states the action (list) and the resource (all available workspaces), and specifies the location via environment variable with a default. It distinguishes itself from set_workspace by explicitly naming the sibling for a different 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?

It names the alternative tool (set_workspace) for the related but distinct operation of switching, giving clear context on when to use which. However, it doesn't explicitly state when not to use this tool beyond that, but for a list operation the intent is obvious.

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?

Beyond the readOnlyHint annotation, it discloses sampling behavior, automatic column-name recognition with fallback to explicit columns, and the concrete output composition including first/median/last power, growth multiplier, and shape classification. This is substantial behavioral context that the annotation alone does not 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 dense but every clause earns its place: input, sampling, output, auto-mapping, fallback behavior, and intended use case. It is front-loaded with the core batch-curve purpose and contains no filler.

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

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

With no output schema, the description still enumerates the output fields and shape classifications. The schema covers all parameters and the annotation marks the tool read-only, so nothing essential is missing for correct invocation and interpretation.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real parameter semantics: concrete auto-name mappings (攻击力→attack, 体力→hp, etc.), explicit column-mapping examples, and the guarantee that first/last rows are always included when sampling. This raises it above baseline.

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

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

The description uses a specific action plus resource: it reads a growth table and produces a level-to-power curve with shape summary metrics. It explicitly distinguishes itself from compute_power by presenting itself as the batch/full-curve version and stating it replaces repeated single-point calls.

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 states when to use the tool: full-curve analysis and growth × equipment joint derivation, and it names compute_power as the single-point alternative it replaces. It does not explicitly state a when-not-to-use condition, but the context is clear enough for an agent to choose correctly.

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?

Beyond the readOnlyHint annotation, it discloses that the tool is deterministic and LLM-free, and it fully specifies the behavioral criteria for each output category, including formulas like distinct/rows and prefix-sum with rounding tolerance. This gives an agent confidence about repeatability and side-effect-free execution.

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 key purpose and nature are front-loaded ('单表画像，确定性统计，无 LLM'), and subsequent clauses compactly enumerate the computed metrics and heuristics. It is dense but every element carries information; only a slightly monolithic long sentence prevents a perfect structure score.

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

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

For a one-parameter tool with no output schema, the description clearly lists what the agent will get back and even gives role-candidate rules and the follow-up save_structure action. It does not specify exact return shapes or edge-case behavior, but the essential selection and invocation information is present.

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

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

The input schema already documents the only parameter ('目标表名（来自 list_tables）') with 100% coverage, so the baseline is 3. The description does not add parameter-specific guidance beyond saying the profile is for a single table, which is not additional semantic value.

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 action and resource: profiling a single table with deterministic statistics, and it enumerates the exact metrics returned (row count, type distribution, cardinality, monotonicity, PK candidates, cumulative-column check, role candidates). It explicitly positions itself for '逆向理解单表结构先用它', which distinguishes it from relation/column-level 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 gives a clear usage context: use this first when reverse-engineering a single table, and route results to save_structure for persisting conclusions. It does not explicitly state when not to use it or name alternatives for exclusion, so it stops short of 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, and the description aligns with that by describing a read operation. The description adds useful context by naming the two memory artifacts it reads, but it does not disclose return format, size, or whether it reads from the current workspace specifically. This is adequate but not rich.

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

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

The description is two concise sentences with no filler. The first sentence states exactly what the tool does, and the second sentence gives practical usage guidance. Information is front-loaded 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 simple parameterless read-only tool with an annotation covering safety, the description is largely complete: it states the resource, the files involved, and when to use it. It does not explicitly describe the return format, but the nature of reading memory is clear enough for an agent to invoke it correctly.

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

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

The tool has zero parameters, so parameter semantics are inherently satisfied. The description does not need to explain parameter behavior. Baseline 4 is appropriate for a parameterless tool.

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

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

The description clearly states a specific verb ('read') and resource ('workspace all project memory'), and even names the concrete files involved (PROFILE.md and facts.md). This differentiates it from sibling tools like read_table and list_workspaces, which operate on tabular or workspace-level data rather than project memory.

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

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

The description provides an explicit usage context: check memory before answering questions related to historical conclusions. It does not explicitly state when not to use it or name alternatives, but the guidance is clear enough for an agent to know when this tool is relevant.

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

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

Annotations already mark the operation as read-only, and the description adds meaningful behavioral details: default limit of 20 rows, supported filters (eq/ne/gt/gte/lt/lte/contains), column selection, and pagination via offset/limit. This goes beyond the annotation without contradicting it.

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

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

The description is two sentences, front-loaded with the core action, then quickly covers capabilities and the prerequisite workflow. Every sentence earns its place, with no redundant 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 table query tool with five parameters, the description covers the prerequisite, supported filters, pagination, and column selection. It does not describe the return format, but the absence of an output schema is mitigated by the simplicity of the operation and the explicit read-only 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 coverage is 100%, so the input schema already documents every parameter. The description reinforces the filter operator list and pagination defaults but adds little new meaning beyond the schema; the schema itself already mentions the list_tables source and default limit. This meets the baseline but does not significantly extend 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?

The description clearly states the action ('读取...数据行') and the resource ('工作区内指定数值表'), and specifies the main capabilities (column selection, filtering, pagination). It also distinguishes itself from list_tables by telling the agent to call list_tables first for table and column names, avoiding confusion with sibling tools.

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

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

The description provides concrete usage context: use this tool to read rows from a table, and explicitly instructs the agent to first call list_tables to obtain table and column names. It does not explicitly state when not to use this tool or mention alternative siblings, but the workflow guidance is sufficient for correct 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?

Beyond the readOnlyHint annotation, it discloses precise behavior: missing left keys in right produce an error (FK broken-chain isomorphic), the tolerance formula is absolute half-grid (default 0.5) plus relative 1e-9, ratio handles multiplier transcription, and omitted values select pure key-domain reconciliation.

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 dense but every clause adds operational value: purpose, roles, error semantics, tolerance formula, ratio behavior, optional mode, and prerequisite. No filler or repetition of schema names.

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 an 8-parameter tool with no output schema, it covers input roles, error behavior, tolerance, optional reconciliation mode, and table discovery. The only notable omission is the shape or semantics of the result/return value, which would round it out.

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?

Even though schema coverage is 100%, the description significantly enriches parameters: it defines left as detail/checked and right as baseline/master, explains tolerance's default and formula, gives a ratio example (quality coefficient 1.4), and clarifies that omitting leftValues/rightValues yields FK-style reconciliation.

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 opens with '跨表对账（L3）' and defines the exact operation: align two tables by declared key columns and compare value columns cell by cell. It specifies left vs right roles and even names the prerequisite list_tables, making the tool's unique role among siblings evident.

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 context for use: current workspace, two-table reconciliation, left/right orientation, and the explicit prerequisite '先 list_tables 拿表名与列名'. It does not name alternatives or when-not-to-use conditions, 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 no annotations provided, the description carries the burden of disclosing behavior. It does disclose the key behavioral trait: switching the workspace affects all subsequent numeric tool calls. It also reveals the constraint that name must be a valid workspace from list_workspaces. It doesn't describe invalid-name behavior or persistence, which would be nice but is not essential for such a simple setter.

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

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

The description is only two sentences, with the core purpose and side effect stated first and the parameter constraint second. Every sentence earns its place, and there is no vague filler.

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

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

Given the tool's simplicity (one parameter, no output schema, no nested objects), the description is complete enough: it states what the tool does, the side effect on subsequent calls, and where the valid value comes from. An agent has sufficient information to invoke it correctly.

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

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

Schema coverage is 100%, so the schema already documents the name parameter and its source. The description reiterates that name must come from list_workspaces, which matches the schema description and adds no new semantic information beyond the schema. Hence 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?

The description names a specific verb and resource: 'switch current workspace', and clearly states the tool's role as a state setter for all subsequent numeric tool calls. The context distinguishes it from sibling tools like list_workspaces and read_table by emphasizing that it changes the active workspace rather than querying or transforming data.

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 usage context: call this to change the workspace that subsequent numeric tools will act on. It also states the prerequisite that name must come from list_workspaces, which is actionable guidance. It does not explicitly mention exclusions or alternatives, but there is no real alternative for this action among the siblings.

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 description is not burdened with stating read-only behavior. The description adds the 'deterministic engine' trait, but does not elaborate on output format, performance, or error handling. Given the annotation coverage, a 3 is appropriate – the description adds some context but misses richer behavioral details.

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

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

The description is two sentences, dense with information, and front-loads the mode concept before detailing each variant. No wasted words; every clause adds meaning. Structure is exemplary for a multi-mode 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?

Without an output schema, the description must explain return values. It mentions 'distribution and quantiles' and 'distribution and expectation' but does not specify the exact structure (e.g., array of counts, percentiles). For a tool with 8 parameters and two complex modes, this is a noticeable gap, though the description covers the essential functional scope.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds value by explaining mode-dependent parameter requirements (mode=tiers needs tiers; mode=pity needs baseRate, hardPity, etc.), clarifying conditional semantics not obvious from the schema alone. This elevates it to 4.

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

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

The description clearly states a specific verb (simulate) and resource (gacha/probability draws), and explicitly distinguishes two modes (tiers for layered pools without pity, pity for gacha with guarantee). Concrete examples (rogue skill three-choice, chest quality drops) anchor its purpose and differentiate it from sibling tools like battle_simulate.

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 explicitly specifies when to use each mode (mode=tiers for layered pools, mode=pity for guaranteed draws), which effectively routes the agent to the correct parameter set. However, it does not mention when not to use this tool or alternative tools for similar probabilistic tasks, so it falls short of explicit exclusion 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?

readOnlyHint already marks this as read-only, and the description adds valuable behavioral context: outputs are candidates, not conclusions; inference is based on domain containment; and lexical similarity is only used for ranking. It also warns that confirmed mappings still require recon_diff, which clarifies the tool's limitations.

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 packs purpose, workflow, caveats, and an illustrative example into one coherent paragraph. The key constraint that candidates are not conclusions is front-and-center, and every sentence contributes useful information, though the paragraph is somewhat dense.

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 no output schema, the description adequately explains what the tool scans, how candidate discovery works, and what the follow-up step should be. It stops short of describing the exact output shape, but the workflow and boundary against recon_diff are sufficient for an agent to select and invoke the tool correctly.

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

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

The only parameter topN is fully described in the input schema with a range and default, so schema coverage is 100%. The description adds no additional parameter-level semantics, which is acceptable given the schema already carries that burden.

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

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

The opening phrase '引用完整性候选发现' names an explicit task, and the description specifies scanning all tables in the current workspace to find candidate mappings where a column in table A may reference a key column in table B. It also differentiates itself from recon_diff by framing outputs as unverified candidates rather than confirmed broken-link results.

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

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

The description provides a clear workflow: use suggest_refs to generate candidates, get user confirmation, then use recon_diff for zero-tolerance broken-link checks. This gives concrete context for when to use the tool and how it relates to recon_diff, though it does not explicitly contrast it with other sibling discovery tools such as infer_foreign_keys.

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