GoldenMatch

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

With no annotations, the description carries full burden. It discloses that corrections are added with source='agent' and trust=0.5, explains canonicalization of pair IDs to (min, max), and notes the version requirement for field-level corrections. It also enumerates the decision values. This is substantial behavioral information, though it does not describe potential overwriting behavior or side effects.

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

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

The description is extremely concise—four sentences covering purpose, shapes, parameters, and a key behavioral note (canonicalization). Every sentence adds value, and the structure is front-loaded with the primary purpose. No unnecessary wording.

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 11 parameters, no output schema, and no annotations, the description is adequate but incomplete. It covers the two shapes and required parameters well, but does not describe optional parameters like path, reason, matchkey_name, original_value, or the return value of the tool. The behavioral transparency is good, but the lack of complete parameter documentation and no mention of side effects leaves gaps.

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

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

Schema coverage is 73%, so the description compensates by explaining which parameters belong to which shape (pair-level vs field-level). It adds context for id_a, id_b, cluster_id, field_name, corrected_value, and the trust level of the source. This clarifies usage beyond the schema definitions. However, a few parameters (e.g., path, reason, matchkey_name) lack additional explanation.

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: 'Add a Learning Memory correction.' It details two shapes (pair-level and field-level) with specific decision values and required parameters. This is a specific verb ('Add') on a specific resource ('Learning Memory correction') and distinguishes between two usage modes, making it unambiguous even among many 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 explains the two shapes and their parameter requirements, giving implied usage context. However, it does not explicitly state when to use this tool over alternatives (e.g., agent_approve_reject for approvals/rejections). No 'do not use if...' guidance or comparisons to siblings are provided, leaving room for misinterpretation.

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

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

No annotations are provided, so the description must carry the behavioral burden. It only states the action ('approve or reject'), implying a write operation, but does not disclose side effects, permissions, or what happens after the decision.

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 sentence, which is concise but under-specified. For a tool with 6 parameters and no schema descriptions, more detail is needed to avoid ambiguity.

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 complexity (6 required parameters, no output schema), the description is severely incomplete. It does not explain parameter roles, expected decision values, or return behavior, making it insufficient for reliable agent use.

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%, and the description adds no meaning to the 6 parameters. It does not explain id_a, id_b, reason, decision, job_name, or decided_by beyond their names.

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 the verb 'approve or reject' and the resource 'review queue pair', making the purpose clear. It distinguishes from siblings like 'agent_explain_pair' and 'agent_review_queue' but could be more specific about the pair.

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

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

No guidance is provided on when to use this tool versus alternatives such as agent_review_queue or agent_explain_pair. The description lacks exclusions or context for usage.

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

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

The description is only five words and does not disclose any behavioral traits such as mutation, output format, or required permissions. With no annotations, the description carries the full burden but fails entirely.

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 concise but severely under-specified. It lacks essential information, making it insufficient for an agent to use correctly.

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 7 optional parameters, no output schema, and no annotations, the description is completely inadequate. It does not explain what the tool returns, how to provide data, or what 'ER strategies' are.

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 57% description coverage, but the tool description adds no meaning beyond what the schema already provides. It does not explain the purpose of parameters like 'ground_truth' or 'filename'.

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 the tool 'compare ER strategies on your data', which gives a verb and resource, but it is vague. It does not specify what ER strategies are or how they are compared, and it does not differentiate from sibling tools like 'compare_clusters' or 'evaluate'.

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

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

The description provides no guidance on when to use this tool versus alternatives. There is no indication of context, prerequisites, or exclusions.

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

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

With no annotations, the description must disclose behavioral traits. It mentions 'confidence gating and reasoning' but does not explain side effects, authentication needs, rate limits, or what the tool does internally. This leaves significant gaps.

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 concise sentence, well front-loaded with the core purpose. However, for a complex tool, it may be too minimal, but it avoids unnecessary detail.

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

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

Given the tool's complexity (full pipeline, 6 parameters, no output schema, no annotations), the description is incomplete. It does not mention return values, error handling, prerequisites, or how 'confidence gating' works, leaving the agent underinformed.

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 has 6 parameters with 67% description coverage, meaning some parameters are documented in the schema. The tool description adds no additional meaning beyond the schema's descriptions, so a baseline score of 3 is appropriate.

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

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

The description clearly states the tool runs a 'full ER pipeline with confidence gating and reasoning', indicating a comprehensive entity resolution process. However, it does not explicitly differentiate from similar sibling tools like 'dedupe' or 'match', leaving some ambiguity.

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

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

No guidance is provided on when to use this tool versus alternatives such as 'dedupe' or 'match'. The description implies it is for a full pipeline, but it lacks explicit context or exclusion criteria.

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

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

No annotations are provided, so the description bears full responsibility. It does not disclose whether the tool is read-only, what format the explanation takes, or any side effects. Minimal behavioral 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 very concise at one sentence, but it is under-specified. Conciseness should not come at the cost of missing necessary detail. It sacrifices clarity for brevity.

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

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

With no output schema and minimal description, the tool lacks completeness. It does not describe the explanation format, prerequisites, or how it differs from similar tools. Inadequate for effective use.

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% (no parameter descriptions). The description adds no meaning beyond the schema: it does not explain what 'cluster_id' represents or how to obtain it. Fails to compensate for low coverage.

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 'Explain why records are in the same cluster' clearly states the action (explain) and resource (records in a cluster). However, it does not differentiate from siblings like 'explain_pair' or 'explain_cluster', which may have overlapping functionality.

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

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

No guidance on when to use this tool versus alternatives. Siblings like 'explain_pair' and 'explain_cluster' exist, but the description does not specify contexts, prerequisites, or exclusions.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It does not mention any side effects, authentication needs, rate limits, or data impacts. The description is minimal and offers no behavioral insight beyond the bare action.

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

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

The description is extremely short, which sacrifices necessary detail. While it front-loads the purpose, it lacks any structuring or elaboration, making it more under-specified than concise.

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 (four parameters, nested objects, no output schema, no annotations), the description is severely incomplete. An agent would not have enough information to correctly invoke the tool or interpret its behavior.

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

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

Schema description coverage is 0% and the description adds no meaning to the four parameters (record_a, record_b, exact, fuzzy). It does not explain their roles, formats, or how they influence the explanation. The two required parameters are ambiguous.

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 the tool provides a 'natural language explanation for a record pair', which clarifies the basic purpose. However, it does not specify what kind of explanation (e.g., why they match or not) or distinguish it from similar siblings like 'explain_pair' or 'explain_match'.

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

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

No guidance is given on when to use this tool versus alternatives such as 'explain_pair', 'explain_cluster', or other agent tools. There is no mention of prerequisites or context needed.

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, the description carries full burden for behavioral disclosure. It fails to mention side effects, permissions, or what happens to the files. 'Intelligent strategy selection' is vague and does not clarify behavior.

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

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

The description is a single sentence, making it concise but lacking structure. It is not front-loaded with critical details and misses opportunities to organize information for quick understanding.

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 has 9 parameters (0 required), no output schema, and no annotations, the description is severely incomplete. It does not specify return values, strategies used, or how to provide files, leaving the agent without sufficient context.

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

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

Schema description coverage is only 44%, and the tool description adds no parameter-specific information. Key parameters like 'config' (nested object) and 'file_a' vs 'file_a_content' are not explained beyond the schema.

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

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

The description states 'Match two files with intelligent strategy selection', which clearly identifies the action and resource. However, it does not differentiate from sibling tools like 'match' or 'match_record', lacking specificity on what 'intelligent strategy selection' entails.

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

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

No guidance is provided on when to use this tool versus alternatives such as 'match', 'compare_strategies', or 'agent_compare_strategies'. The context for choosing this tool over others is absent.

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

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

No annotations exist, and the description does not disclose whether the tool is read-only, requires authentication, or has any side effects. It fails to provide critical behavioral context beyond the basic 'get' operation.

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 sentence, which is concise but under-specified. It does not provide enough information for effective tool selection or invocation.

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

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

The tool has one parameter, no output schema, and many siblings. The description lacks essential details about return values, filtering criteria, and how it integrates with the rest of the agent workflow, making it incomplete for effective use.

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 parameter 'job_name' with no description, and the tool description does not explain what value it should take or how it affects the results. This is a significant gap especially given 0% schema coverage.

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 it retrieves borderline pairs for approval, which is a specific action, but it does not differentiate from sibling tools like agent_approve_reject or agent_explain_pair. The term 'borderline' is vague without additional context.

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

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

No guidance is provided on when to use this tool versus its siblings. For example, it does not indicate that it is for viewing pending items before acting on them with agent_approve_reject.

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

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

No annotations are provided, so the description bears full responsibility. It describes what the tool returns but does not explicitly confirm it is a read-only operation or disclose side effects. The verb 'diagnose' implies no modification, but this is not guaranteed.

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 short sentences: the first defines the tool's outputs, the second provides a usage case. It is economical and front-loaded with key information.

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

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

The description explains the return value conceptually, which helps the agent understand the tool's purpose. However, it does not cover parameter details, output format, or behavioral constraints, leaving gaps for a tool with no output schema and low schema coverage.

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

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

Schema description coverage is only 33% (only 'limit' has a description). The tool description does not explain any parameters. The agent must infer from parameter names like 'sample_size' and 'target_block_size', which are ambiguous.

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 diagnoses blocking on a dataset, listing specific outputs (blocking key candidates, counts, etc.) and a use case (explain slow matching). It is distinct from sibling tools that focus on matching, dedup, or other tasks.

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 to use it 'to explain why matching is slow or produces too many candidate pairs,' providing clear usage context. However, it does not mention when not to use it or give alternatives.

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

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

No annotations provided, and description fails to disclose behavioral traits (e.g., read-only, destructive, side effects, authentication). Does not mention that tool accepts file input.

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?

Extremely short but not front-loaded with critical info. Three verbs without details is under-specification, not conciseness.

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

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

Tool has 4 parameters, no output schema, and many sibling tools. Description provides almost no context for proper use, leaving agent without necessary details.

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 75% with 'file_path' missing description. Tool description adds no parameter information beyond schema, missing chance to explain 'file_path' parameter.

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 uses vague verbs 'profile', 'detect', 'recommend' without specifying data type or domain. Does not distinguish from sibling tools like 'profile_data' or 'suggest_config'.

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

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

No guidance on when to use this tool versus alternatives such as 'profile_data', 'dedupe', or 'suggest_config'. Missing context for agent decision.

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

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

No annotations are provided, so the description must carry the burden. It discloses return details (committed config with telemetry) and uses the word 'committed' implying a write operation. However, it does not specify if repeated calls have side effects, or what happens to existing configurations.

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, front-loaded with the core action, and no fluff. Every sentence provides essential information.

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

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

The description provides a reasonable overview but lacks details on expected input format (e.g., CSV structure), constraints behavior, and output schema. Given the tool's complexity (auto-config with telemetry), more context would be beneficial.

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 67% (4 of 6 parameters described in schema). The tool description adds no parameter-level information. Two parameters (file_path, constraints) lack any description whatsoever, and the description does not clarify their roles or relationships.

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 clearly states it runs AutoConfigController on a CSV and returns a committed config with telemetry. It also references the CLI equivalent, providing a clear purpose. However, it does not explicitly differentiate from sibling tools like pprl_auto_config or suggest_config.

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

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

No guidance on when to use this tool versus alternatives (e.g., suggest_config or pprl_auto_config). No prerequisites, limitations, or context for usage are provided.

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

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

With no annotations, the description carries the full burden. It explains the unsupervised method, capture-recapture approach, and that the result is a point estimate. It also notes the limitation requiring a labelled audit, providing good transparency.

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

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

Two sentences covering the main purpose, method, and prerequisites. Concise and front-loaded, though could be slightly more structured with clear separation of purpose and usage.

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

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

Adequate for a tool with no output schema and no annotations. Explains the core functionality and prerequisites, but lacks details on output format, error conditions, and edge cases.

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% with descriptions for all 4 parameters. The description does not add additional meaning for individual parameters beyond what the schema provides, so baseline 3 is appropriate.

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

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

Description clearly states the tool estimates match recall without ground truth using capture-recapture over decorrelated systems. It's specific but technical, distinguishing it from other evaluation 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 mentions the prerequisite of >=3 decorrelated systems and references a need for a labelled audit for a safe lower bound. It does not explicitly state when not to use this tool or compare to alternatives like evaluate.

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 full burden. It describes the classification and index return but does not disclose any behavioral traits such as side effects, authorization needs, rate limits, or output structure beyond the mention of the index.

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 long, front-loaded with the core purpose, and each sentence adds distinct value with no redundancy or extra fluff.

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 lack of output schema, the description mentions the Talburt-Wang Index and cluster classifications, but does not detail the format or structure of the returned data, leaving some gaps for an agent to fully consume 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?

Schema coverage is 71%, and the description adds general context about JSON cluster files but does not enhance parameter-specific understanding beyond the schema descriptions already present.

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 the tool compares two ER clustering outcomes and classifies clusters into four categories, returning the Talburt-Wang Index. It clearly identifies the specific verb and resource, but does not differentiate from sibling tools like `evaluate` or `explain_cluster`.

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

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

The description implies usage for comparing clusters on the same dataset without ground truth, but provides no explicit guidance on when not to use this tool or alternatives among the many sibling tools.

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

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

With no annotations, the description carries the full burden. It discloses that the tool is diagnostic (non-mutating), returns ranked findings with explanations and fixes, and produces a summary. It does not mention side effects, auth requirements, or rate limits, but for a read-only diagnostic tool the description is reasonably transparent.

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 sentence that efficiently conveys the tool's purpose and output. While it is somewhat long, it avoids redundancy and front-loads key information ('Diagnose weaknesses...'). Every clause contributes value.

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

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

The description adequately covers what the tool checks, the output structure (ranked findings with explanations and fixes, plus a summary), and the default behavior. Given no output schema, the description provides sufficient context for an agent to understand the tool's capabilities and 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?

Schema coverage is 100% and both parameters are described in the schema. The description does not add additional meaning beyond the schema, so it meets the baseline of 3. No extra context like allowed values or usage tips 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 specifies the tool's purpose: 'Diagnose weaknesses in the loaded run's auto-config' and lists specific types of weaknesses (column admission, oversized blocks, etc.). It also describes the return format (ranked findings with explanations and a summary). This distinguishes it from sibling diagnostic tools like 'review_config' or 'analyze_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 implies usage context (after a run, for auto-config weaknesses) but does not explicitly state when to use this tool versus alternatives like 'review_config' or 'suggest_config'. No 'when not to use' or comparative guidance is provided.

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

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

No annotations provided, so description bears full burden. It indicates a read operation and mentions JSON shape, but lacks details on errors, empty states, or side effects beyond implied read-only behavior.

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

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

Two concise sentences covering purpose, origin, and format. No extraneous content; every sentence adds value.

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

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

For a zero-parameter read tool, the description covers purpose, data source, and shape. Could mention error conditions or session requirements, but adequately complete given simplicity.

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?

No parameters exist, so schema coverage is 100%. The description adds no parameter info beyond schema, which is sufficient (baseline 4 for 0 params).

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 specifies verb 'Return' and resource 'AutoConfigController telemetry', and distinguishes from siblings by tying to specific prior calls (auto_configure, agent_deduplicate).

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

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

Clearly states when to use: after 'auto_configure' or 'agent_deduplicate' calls in the session. No explicit when-not-to or alternatives, but context is sufficient.

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, the description carries full burden for behavioral traits. It does not disclose side effects (e.g., overwriting existing domains), permissions needed, or interaction with the file system (local vs global scope). The description is too brief to inform the agent of important 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 a single, well-front-loaded sentence that conveys the core purpose efficiently. However, it could be slightly expanded to include additional context without becoming verbose.

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 has 7 parameters, nested objects, and no output schema, the description is too minimal. It lacks details about the return value, how the rulebook is used later, and practical usage context. The agent may need more information to correctly invoke the 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 100%, so the baseline is 3. The tool description adds no extra meaning beyond the schema. It does not explain parameter relationships or provide usage examples, but the schema descriptions are sufficient for basic understanding.

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 explicitly states the tool creates a custom domain extraction rulebook and gives concrete examples of data domains (medical devices, automotive parts). This clearly distinguishes it from sibling tools like list_domains or test_domain.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention prerequisites, when not to use it, or how it relates to siblings like test_domain or list_domains. The description only states the purpose without contextual usage instructions.

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

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

No annotations are provided, so the description bears full burden. It only says it's an alias and finds duplicates, but does not disclose any behavioral traits like whether it is read-only, destructive, or any side effects. This is insufficient for a tool that may mutate state or require specific permissions.

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 brief (two sentences) and front-loaded with the alias information. However, it lacks important details about usage context and behavior, so it is under-specified rather than concise. It earns its place but could be more informative without being wordy.

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 complexity (alias tool, no annotations, no output schema), the description is incomplete. It does not explain what find_duplicates does, leaving the agent to infer behavior from the name and sibling tool. The schema details are good, but the description lacks operational context.

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

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

The input schema covers all parameters with descriptions (100% coverage). The description adds minimal value beyond the schema by saying 'Provide field values to search against the loaded dataset,' but this largely restates the record parameter description. The alias statement provides some context but does not enhance parameter understanding.

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 it is an alias for find_duplicates and its purpose: to find duplicate matches for a record. It uses specific verb-resource language ('Find duplicate matches for a record'). However, it does not differentiate from its sibling tool find_duplicates, which it is identical to, so not a full 5.

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

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

The description says 'Provide field values to search against the loaded dataset,' which implies when to use (when you have a record to find duplicates). But it gives no guidance on when not to use or alternatives, especially since there is an identical sibling tool.

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

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

No annotations provided, and the description does not disclose behavioral traits such as side effects, authentication needs, rate limits, or whether it is read-only. It only mentions output but not potential impacts.

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

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

The description is a single, efficient sentence that front-loads the primary purpose. While concise, it sacrifices some clarity with jargon like 'dedupe_df' and could be structured slightly better.

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

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

With 6 parameters, no output schema, and no annotations, the description is incomplete. It does not explain the output format, error handling, or prerequisites, which are crucial for a complex ingestion 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 only 33%, and the description adds minimal detail beyond listing parameters. It does not explain model, backend, drop_empty, or their defaults, leaving the agent without sufficient meaning for correct usage.

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 action (extract records), input (documents and schema), output (rows and report), and purpose (for deduplication). It distinguishes from sibling tools like dedupe or match.

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 does not explicitly state when to use this tool versus alternatives, nor does it provide exclusions or prerequisites. It implies usage for document ingestion but lacks comparative 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?

No annotations are provided, so the description must carry the burden of behavioral disclosure. It merely implies a read-only suggestion operation ('Propose') but does not explicitly state side effects, authentication needs, or constraints. The lack of detail is significant.

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 sentence with no wasted words, achieving brevity. However, it is somewhat under-specified, which caps the score at 4; it could be more informative without losing conciseness.

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

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

Given three parameters, no output schema, and no annotations, the description fails to cover essential information such as parameter details, return structure, or behavioral properties. It is only minimally complete for the core purpose.

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

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

Schema description coverage is 0%, and the description adds no information about the three parameters: model, backend, and sample_path. It only vaguely references 'sample document image/PDF', leaving parameter semantics completely unexplained.

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 verb 'Propose' and the resource 'target extraction schema (JSON)' from a sample document. It is specific and distinct from sibling tools like schema_match or suggest_config, which deal with different tasks.

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

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

No guidance is provided on when to use this tool versus alternatives, nor any prerequisites or context for its invocation. The description is silent on usage scenarios.

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

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

No annotations are provided, so the description must fully disclose behavior. It does not state whether the operation is read-only, what side effects occur, or any error handling (e.g., missing file). This leaves uncertainty about the tool's impact.

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

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

The description is extremely concise—two sentences—with no filler. Every word adds value, clearly stating input, action, and output.

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 lack of output schema, the description should explain the return format (e.g., dictionary with metric names). It also omits behavior for edge cases like empty CSV or mismatched columns. Despite low complexity, the description feels incomplete for reliable 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?

Schema coverage is low (33%); only ground_truth_path has a schema description. The description mentions column names (id_a,id_b) but does not explain the col_a and col_b parameters for overriding defaults, nor their defaults. Meaning beyond the schema is limited.

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 evaluates a run against ground-truth pairs, loads a CSV, and returns precision, recall, and F1. It uses specific verbs and resources, making the purpose unambiguous.

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

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

The description implies the tool is used when a ground-truth CSV is available and a run is loaded, but it lacks explicit guidance on when to avoid this tool or mention of alternatives. Prerequisites like having a loaded run are not stated.

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

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

With no annotations, the description must disclose behavior. It only states the tool 'explains' without noting side effects, read-only nature, or output structure. The alias hint is minimal and does not compensate for missing 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 extremely concise with one sentence. However, it omits essential information, which reduces effectiveness despite brevity.

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

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

Given the simple input schema and no output schema, the description should explain the explanation format or scope. It fails to do so, leaving the agent without sufficient context to 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?

The schema coverage is 0%, yet the description adds no meaning to the 'cluster_id' parameter. It remains an opaque integer, forcing the agent to guess its purpose or constraints.

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 explains why records are in the same cluster, but it does not differentiate from its alias 'agent_explain_cluster' or siblings like 'explain_pair'. The purpose is identifiable but lacks specificity about the output form.

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

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

No guidance is provided on when to use this tool versus alternatives. The description merely calls it an alias, leaving the agent without context on when the alias should be preferred over the original or other explanation tools.

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

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

No annotations provided, so description must disclose behavioral traits. It only mentions output (per-field score breakdown) but doesn't state safety (non-destructive), side effects, or 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?

Two sentences, zero waste. Directly communicates purpose and output.

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?

Lacks detail on prerequisites, return format, or behavior in edge cases. With no annotations or output schema, description is too thin for full understanding.

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% with minimal descriptions. The tool description adds context about 'per-field score breakdown' but doesn't enhance parameter understanding 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 clearly states the tool explains match/no-match with per-field breakdown. While siblings exist (explain_pair, agent_explain_pair), the description is sufficiently specific about the resource and action.

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?

Implies usage for comparing two records, but provides no explicit guidance on when to choose this tool over similar explanation tools or any constraints.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the output includes a per-field score breakdown, but lacks details on side effects, permissions, or other behavioral traits. The alias reference adds some clarity but not enough depth.

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: one stating it's an alias and the purpose, the second adding the key detail about output. No unnecessary words, and the most critical info (purpose) 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 tool that is an alias with two simple parameters and no output schema, the description adequately covers the core functionality and output. It could mention what happens when records don't match or how the score is formatted, but overall it's sufficient for the tool's simplicity.

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% with both parameters described as objects. The description adds no additional meaning beyond what the schema already provides (e.g., format, constraints, or example values). Therefore, it meets the baseline but does not enhance semantics.

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

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

The description clearly states it explains why two records match or don't match, showing a per-field score breakdown. It also identifies itself as an alias for `explain_match`, distinguishing it from sibling tools that explain clusters or routing.

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 mentions it's an alias for `explain_match`, implying identical usage, but does not provide explicit guidance on when to use this tool versus alternatives. No exclusions or context for when not to use it are given.

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

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

No annotations are provided, so the description bears full burden. It implies read-only behavior but does not explicitly state it, nor disclose any side effects, auth needs, or 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 sentence, but it is too brief to be useful. It lacks necessary details, making it under-specified rather than efficiently concise.

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 nested input schema, missing annotations, and no output schema, the description is severely incomplete. It does not cover how to invoke the tool or what the response contains, limiting its utility.

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 descriptions are missing for all 4 parameters (coverage 0%). The tool description does not explain any parameter meaning or usage, leaving the agent uninformed about required fields like n_rows and estimated_pair_count.

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 provides human-readable explanations of routing decisions per stage, including driver-RAM projections. It distinguishes itself from siblings like lint_routing and plan_routing by focusing on explanation, but does not specify output format.

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

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

No guidance on when to use this tool vs. alternatives. Siblings include plan_routing and lint_routing, but the description does not contrast them or specify context.

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

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

With no annotations, the description carries full burden for behavioral disclosure. It only states the action (export) but does not mention file overwrite behavior, required permissions, size limits, or return values, leaving agents uninformed.

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, well-formed sentence that conveys the core purpose and supported formats. It is efficiently front-loaded with no unnecessary words.

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 export tool, the description covers the main purpose. However, it lacks details on file handling (e.g., overwrite, truncation) and potential side effects, which would make it more complete given no output schema.

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

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

Schema coverage is 100% and both parameters have descriptions. The description adds 'matching results' context but does not further explain parameter usage beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool exports results to a file in CSV or JSON format. However, the term 'matching results' is vague without context of what matching entails, which slightly reduces clarity.

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 explicit guidance on when to use this tool versus alternatives, but among sibling tools, only this one performs file export. Usage is implied, but no warning about when not to use it (e.g., large datasets) is provided.

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

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

No annotations are provided, so the description carries the full burden. It implies a read operation but does not disclose whether results are limited, if any side effects occur (e.g., caching, logging), or what the output format is. Basic transparency is present but insufficient for a tool with no annotation support.

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 with no extraneous words. It front-loads the core purpose and gives a brief instruction. Every sentence earns its place without 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?

Given the simple two-parameter schema and lack of output schema, the description is minimally adequate. However, it omits details like return format, whether the dataset must be pre-loaded, and how duplicate matching works. For a tool in a deduplication suite, more context (e.g., similarity threshold) would improve completeness.

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 adds modest value by reinforcing the 'record' parameter's purpose ('Provide field values to search'), but it does not elaborate on 'top_k' beyond what the schema already states. No additional semantics are provided.

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 ('Find duplicate matches') and the resource ('a record'), specifying that it searches against the loaded dataset. It distinguishes itself from sibling tools like 'dedupe' or 'match' by focusing on finding existing duplicates rather than deduplicating or matching from scratch.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'match_record' or 'dedupe'. It does not mention when to avoid it or which scenarios it is best suited for, leaving the agent without decision support.

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 full burden of disclosing behavioral traits. It mentions applying fixes and returning data, but does not specify whether the original file is modified (only if output_path is given), side effects, or the nature of fixes. The dependency note is minimal behavioral info.

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 concise (two sentences plus a dependency note) and front-loaded with the main action. It could be slightly better organized (e.g., placing the dependency separately), but overall it is efficient.

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

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

For a tool with 7 parameters, no output schema, and no annotations, the description is incomplete. It does not explain the structure of the returned summary and manifest, nor does it address safety or reversibility. Agents would have limited context to judge the tool's full impact.

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 does not add new meaning beyond the schema, which already documents all parameters with descriptions. No extra parameter context is provided.

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 runs a GoldenCheck scan and applies fixes to a CSV file, returning a summary and manifest. While it distinguishes from siblings like 'scan_quality' by including fixing, it does not explicitly contrast with other fixing or correction tools.

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

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

No guidance on when to use this tool versus alternatives (e.g., 'scan_quality' for scanning only, 'add_correction' for manual fixes). The only usage-related information is a pip install prerequisite, which is a dependency note rather than a usage guideline.

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

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

No annotations are provided, so the description carries the full burden. It says 'get details', indicating a read operation, but it does not explicitly state that no data is modified or that the operation is safe. Additional context about side effects or permissions would be helpful.

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 sentence that is concise and front-loaded with the key information. Every word adds value; there is no unnecessary 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?

The tool is simple with one parameter and no output schema. The description provides a hint about the return content (member records and field values), which is adequate for a straightforward getter. However, it could be more explicit about the structure of the response.

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 describes the only parameter (cluster_id) with a clear description. The tool description does not add substantial meaning beyond what the schema provides, so a baseline score of 3 is appropriate given 100% schema description coverage.

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 it retrieves details of a specific cluster, including all member records and their field values. This distinguishes it from sibling tools like list_clusters (which lists clusters without details) and explain_cluster (which likely provides explanations).

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

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

The description implies use when needing details of a specific cluster, but it does not explicitly state when to use this tool over alternatives like explain_cluster or list_clusters. No usage guidance or exclusions are provided.

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

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

No annotations are present, so the description carries the full burden. It states the tool retrieves a record but does not disclose error behavior (e.g., if cluster_id does not exist), idempotency, or whether the call is safe. The description adds minimal behavioral context beyond the schema.

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

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

A single sentence that fully captures the purpose without extraneous words. Every word adds value. Ideal structure for a simple tool.

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

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

For a simple read tool with one parameter and no output schema, the description is largely sufficient. It could optionally mention the return format (e.g., 'returns a single record'), but the current wording covers the core functionality.

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% with a basic description of 'cluster_id' as 'Cluster ID'. The tool description adds 'for a cluster' but does not enrich the parameter's meaning (e.g., format, constraints). Baseline score of 3 is appropriate given schema coverage.

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 ('get') and the resource ('merged golden (canonical) record for a cluster'), distinguishing it from sibling tools like 'get_cluster' which likely returns raw cluster data. The verb-noun structure is specific and 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?

No explicit guidance on when to use this tool versus alternatives such as 'get_cluster' or 'explain_cluster'. The context of 'canonical record' implies usage for deduplicated data, but no exclusion criteria or alternative suggestions are provided.

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

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

No annotations exist, and the description does not disclose behavioral traits beyond the obvious read operation. It fails to mention permissions, side effects, or performance implications.

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, concise sentence that front-loads the action and lists the return values. 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 no-parameter tool, the description is mostly complete. It could be improved by explicitly stating which dataset is being queried, but it is sufficient given the sibling 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?

Since there are no parameters, the description adds value by enumerating the statistics returned. Schema coverage is 100% (empty schema), so the description compensates well.

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

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

The description clearly states it retrieves dataset statistics and lists specific metrics (record count, cluster count, match rate, cluster sizes). However, it does not differentiate from sibling stat tools like identity_stats or memory_stats, though the context implies they are for different domains.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., identity_stats, memory_stats). There is no mention of prerequisites or context.

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

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

Description discloses append-only nature, commit order, and included fields; no annotations provided, so description carries burden but lacks details on safety or pagination.

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?

Single sentence with efficient structure; no fluff, front-loads core purpose.

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?

Provides enough context for basic use (fields, ordering, filtering), but misses limit semantics and path meaning; no output schema.

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

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

Schema coverage is 0%; description explains actor and dataset, but not path or limit, leaving two parameters undocumented.

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 explicitly states it exports the append-only identity audit log in commit order with key fields, clearly distinguishing it from sibling tools like seal and verify.

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 mentions optional filtering by dataset/actor, but does not explicitly contrast with siblings or state when not to use.

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?

Discloses key behaviors: cheap, idempotent, no-op when nothing new, and that root_hash can be published for external verification. No annotations provided, so description carries full burden, which it mostly handles.

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, front-loaded with main action, no wasted words. Efficient and to the point.

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 and three optional parameters, description provides sufficient context for usage. Lacks details on return format but mentions root_hash.

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 67%. Description adds context for dataset (scoping) but does not explain path or actor beyond schema. Moderately compensates for gaps.

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 clearly states it anchors the audit log with a tamper-evidence seal using chained sha256 root. Differentiates from siblings like identity_audit and identity_audit_verify.

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

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

Explicitly recommends periodic runs or after batch actions, mentions idempotency and scoping. Does not explicitly list alternative tools but context implies when to use.

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, the description carries full burden and explains the verification process well, including replaying hashes and return format. However, it does not explicitly state that the operation is non-destructive or require authentication, though behavior is reasonably clear.

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 purpose and mechanism, no redundant information. Every sentence adds value.

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

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

Given no output schema, the description covers return format and detection types. However, it does not clarify whether the 'path' parameter is required (though implied by functionality) or discuss error conditions, leaving minor gaps.

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

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

Schema description coverage is 50%; only 'path' has a description. The tool description adds 'Optionally scoped to a dataset' for the dataset parameter, providing some context but not full compensation for the undocumented parameter.

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 verifies the audit log against its seal chain, specifying it detects content edits, deletion, reordering, and insertion. It uses specific verbs like 'Verify' and 'Replays', and distinguishes from sibling tools like identity_audit and identity_audit_seal by focusing on verification rather than reading or sealing.

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

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

The description implies usage for integrity checking but lacks explicit guidance on when to use this tool versus alternatives like identity_audit or identity_audit_seal. No when-not or exclusion criteria are provided, relying on the agent to infer context.

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

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

The description discloses core behavioral traits: it moves the record out of the prior entity and emits provenance-stamped 'claimed' events on both entities. However, it does not cover authorization needs, reversibility, failure scenarios, or the outcome of the operation beyond the event emission. With no annotations, the description carries the full burden and is moderately transparent.

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

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

The description is extremely concise—two sentences that efficiently convey the primary action, effect, and side effect. No extraneous information or repetition.

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

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

The description lacks details on prerequisites (e.g., record/identity must exist), return value (no output schema), and potential errors. For a state-modifying tool with no annotations, more context is needed for reliable 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 description adds no additional meaning beyond the input schema. While 67% of parameters have schema descriptions, the description does not reference any parameter or explain how they relate to the operation. Parameters like 'path' and 'reason' are left undocumented in the description.

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

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

The description uses a specific verb 'claim' and clearly indicates the resource (a record into an identity) and the side effect (moving it out of any prior entity). It includes a clarifying paraphrase and mentions emitted events, making the action distinct from siblings like identity_merge or identity_split.

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

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

There is no guidance on when to use this tool versus alternatives such as identity_merge, identity_split, or certify_recall. The description implies a specific use case (reassigning ownership of a record) but does not explicitly state prerequisites, conditions, or exclusion criteria.

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

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

No annotations are provided, so the description carries the full burden. It implies a read-only action ('list') but does not disclose any potential side effects, pagination, or error behavior. The description is insufficient for understanding the tool's full behavioral traits.

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 sentence, which is concise but lacks any structure. It does not separate purpose, usage, or parameters, making it too sparse to be helpful.

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 two undocumented parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain what the output is, how to filter, or when to use this over similar sibling tools.

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

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

Schema description coverage is 0%, and the description does not mention the two parameters 'path' and 'dataset'. With no parameter documentation, the agent cannot infer how to use them correctly.

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 'List evidence edges marked conflicts_with', which provides a specific verb and resource, but the term 'evidence edges' is jargon and unclear without domain knowledge. It vaguely distinguishes from siblings like identity_resolve_conflict, but does not fully clarify its scope.

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

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

No guidance on when to use this tool versus alternatives. With many sibling tools like identity_resolve_conflict, identity_merge, etc., the description offers no context for selection.

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

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

With no annotations, the description must disclose behavioral traits, but it only states the output type. It omits details like read-only nature, authentication requirements, pagination, or limits on results.

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

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

The description is a single concise sentence with no fluff, but it is too minimal to be fully informative. It front-loads the purpose but lacks necessary supporting 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?

The tool has 3 parameters and no output schema, but the description is extremely sparse. It fails to explain what the temporal event log contains, how parameters affect results, or any expected behavior, making it insufficient for correct use.

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%, yet the description adds no explanation for parameters ('path', 'limit', 'entity_id'). The agent receives no additional meaning beyond parameter names and types.

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 returns a 'temporal event log' for an identity. This is a specific verb and resource, and it distinguishes from siblings like identity_profile or identity_show.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., identity_audit). The description lacks any contextual cues about appropriate use cases or prerequisites.

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

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

No annotations are provided. The description does not disclose behavioral traits such as read-only nature, permissions required, or side effects. It is insufficient for an agent to infer safety or behavior beyond the minimal listing action.

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, concise sentence. It is front-loaded with the key action. However, it sacrifices completeness for brevity; some additional context could be added without losing conciseness.

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

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

The description is incomplete given the tool has 5 parameters and no output schema. It does not explain return values, pagination (limit/offset), or the effect of omitting filters. It only partially covers the functionality.

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. It only clarifies two of five parameters (dataset and status). It does not explain path, limit, or offset. The description adds minimal value beyond the parameter names.

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 verb 'list' and resource 'identities', and mentions optional filtering by dataset/status. It distinguishes from sibling identity tools like identity_merge or identity_resolve by being a simple list operation, but could be more specific about what identities are (e.g., from a domain or system).

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

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

No guidance on when to use this tool versus alternatives. Sibling tools like identity_profile, identity_worklist, or identity_audit might serve different purposes, but the description provides no context for selection.

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

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

Discloses core behavior: records from absorb_entity_id are reassigned to keep_entity_id, and events are stamped with actor/trust provenance for auditing. With no annotations, this provides good transparency but could note side effects like deletion of absorb_entity_id.

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 concise sentences that are front-loaded with the core action. Every sentence adds value with no redundancy.

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

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

Adequately describes the merge action and auditing, but lacks output/return value information. Given no output schema, this is acceptable. Missing prerequisites or constraints.

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?

Description adds context for actor and trust by mentioning provenance, but does not explain keep_entity_id, absorb_entity_id, path, or reason. Schema coverage is only 33%, so description partially compensates but insufficiently.

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?

Clearly states 'Manually merge two identities' with specific verb and resource. Distinguishes from sibling tools like identity_split by focusing on merging rather than splitting.

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?

Implies usage for manual merging but does not explicitly state when to prefer this over alternatives like identity_resolve_conflict or identity_claim. No exclusions provided.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It describes the output fields and the not-found case, but lacks details on authentication requirements, rate limits, or side effects. Given the simplicity of a read-only profile operation, the description is adequate but not comprehensive.

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, each serving a distinct purpose: the first explains the tool's function and output, the second handles the edge case. There is no redundancy or unnecessary information, making it efficient and easy to parse.

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 profile tool, the description covers the core functionality and an important edge case (entity not found). However, it does not mention what happens if the entity_id is malformed or if there are permission issues. With no output schema, describing the return format for success cases would add completeness.

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 has two parameters: 'path' (with a brief description) and 'entity_id' (no description). Schema description coverage is 50%. The tool's description adds no additional information about these parameters, expecting the agent to infer meaning from context. This misses an opportunity to clarify the purpose of 'path' or suggest typical values.

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 provides an MDM profile for one entity, listing specific fields (record count, per-source breakdown, golden record, etc.) and notes the return format when no entity exists. This distinguishes it from siblings like identity_stats or profile, which likely operate at different scopes.

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 indicates when to use the tool: to get a comprehensive profile for a single entity. It also specifies the behavior when the entity is not found (returns {found: false}). While it does not explicitly state alternatives or when not to use it, the context is clear enough for an agent to differentiate from tools like identity_show or identity_history.

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

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

No annotations are present, so the description carries the full burden. It does not disclose whether the operation is read-only, idempotent, or has side effects. It only describes the return value, not behavioral traits like performance, permission requirements, or error states.

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

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

The description is two sentences, front-loaded with the action, and every word contributes to understanding. No redundancies or 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 no output schema, the description adequately explains the return value (full identity view with components or null). Though it does not detail pagination, error handling, or additional context, the description is sufficient for a simple lookup tool with 2 parameters.

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

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

Schema coverage is 100% with both parameters described. The description adds no new meaning beyond the schema: it mentions record_id implicitly but does not elaborate on format or optional path. Baseline score of 3 is appropriate since the schema already covers parameter details.

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 resolves a record_id to its durable identity, specifies the output (full identity view with members, evidence edges, recent events, or null), and thus distinguishes itself from siblings like identity_list or identity_merge that serve different purposes.

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

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

The description implies usage for looking up a record identity, but does not explicitly state when to use this tool over alternatives (e.g., identity_show, identity_profile). No 'when not to use' guidance is provided.

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

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

No annotations are provided, so the description carries full burden. It discloses durable recording of verdict and event, and stopping re-surfacing. However, it is vague about side effects: 'distinct splits the second record out into a new identity' is unclear about what happens to the first record. The 'apply' parameter's effect (action vs. log-only) is mentioned only in the schema, not the description. The description lacks clarity on irreversible changes and required permissions.

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-loading the primary action (resolution options) and then the outcomes. It is concise with no redundant information. Minor improvement could be separating the resolution options into a clearer list or adding structured details about side effects.

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 moderately complex, and the description covers the core conflict resolution behavior but leaves gaps: what happens to record_a when 'distinct' is chosen, how the 'apply' parameter interacts, and what the output is (no output schema). The description is adequate but not fully comprehensive given the lack of annotations and output schema.

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

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

The schema has low description coverage (33%), but the description adds meaning to the 'resolution' parameter by explaining its enum values. It also ties actor and trust to provenance. However, it does not explain parameters like path, reason, dataset, or record IDs beyond what the schema provides. The description partially compensates for low schema coverage.

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 it adjudicates a conflicts_with pair, with three explicit resolution options ('same', 'distinct', 'defer') and their effects. The verb 'adjudicate' is specific to conflict resolution, and the description distinguishes this tool from siblings like identity_merge or identity_split by focusing on conflict mediation.

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

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

The description implies the tool is used for conflict resolution but does not explicitly state when it should be used over alternatives, nor does it mention prerequisites (e.g., the pair must be in conflict) or situations where it should not be used. No guidance on when to use other tools like identity_resolve or identity_merge is provided.

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

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

No annotations provided, so description solely covers behavior. It discloses the return value for not-found cases and the expected content, but does not mention side effects, permissions, or rate limits. Adequate but not thorough.

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 that efficiently convey the tool's action and a notable return case. No unnecessary words; information 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?

Covers core purpose and not-found response, but lacks details on the structure of event log, pagination hints, or how the event_limit parameter affects results. Output schema absent, so more description is warranted.

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 33% (only entity_id mentioned explicitly in description). Path and event_limit parameters are not explained or even referenced in the description, leaving the agent without guidance on their meaning or optionality.

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 it fetches full detail of an identity by entity_id, including member records, evidence edges, and event log. It distinguishes from siblings like identity_list by specifying full detail, but does not explicitly differentiate from other identity 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 implies use when needing complete identity details by entity_id, but provides no when-not-to-use instructions or alternatives among siblings. Lacks explicit guidance on context.

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

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

No annotations are provided, so the description carries the burden. It mentions that split events carry 'actor'/'trust' provenance, which adds some behavioral context, but does not disclose side effects, permissions needed, or outcome for the original identity beyond keeping remaining records.

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 efficiently convey the core purpose and a key behavioral detail. There is no unnecessary information, and the purpose 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?

Given 6 parameters, 2 required, no output schema, and no annotations, the description is too brief. It lacks details on prerequisites, output, or constraints, making it incomplete for an agent to use correctly without additional context.

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

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

Schema description coverage is low (33%), with only 'actor' and 'trust' having descriptions. The tool description adds no additional meaning for any parameters, leaving most (path, reason, entity_id, record_ids) unexplained.

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 verb 'split' and the resource 'identity', and distinguishes the action from siblings like identity_merge by specifying that the original keeps remaining records and a new identity is created.

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 guidance on when to use this tool versus alternatives, nor are there any exclusions or prerequisite conditions mentioned. The description implies its purpose but lacks use-case differentiation.

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

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

No annotations provided, and the description does not disclose behavioral traits such as read-only nature, performance impact, required permissions, or side effects. Agents cannot infer whether this operation is safe or costly.

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 clear sentence listing the included statistics, which is efficient. However, it could be improved by using a structured format (e.g., bullet points) for 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?

Given no output schema and moderate complexity, the description explains what the tool returns but omits details on return format, pagination, or how the path parameter is used. It is adequate for basic understanding but lacks full context.

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

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

Schema coverage is 50% (dataset lacks description). The description adds meaning by mentioning 'optionally scoped to a dataset', which clarifies the dataset parameter's purpose. However, it does not elaborate on path beyond the schema's own description.

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 it provides graph-level summary/health stats and lists specific metrics (entities by status, total records, etc.), distinguishing it from other tools like get_stats or identity_profile by its focus on aggregate health stats.

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

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

No guidance on when to use this tool compared to alternatives like get_stats, identity_profile, or analyze_blocking. The description implies it's for high-level stats but does not specify prerequisites or when not to use it.

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

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

With no annotations, the description carries full burden. It discloses the filtering logic (open conflicts, confidence below weak_confidence) and ordering (highest conflict first), which is sufficient to understand the tool's behavior as a read-only query.

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 sentence that conveys the essential logic without extraneous details. It is concise and front-loaded, but could be slightly clearer with explicit mention of 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?

Given no output schema, the description does not describe the return structure or fields of the entities. While the filtering and ordering are clear, an agent would still need to infer the output format, which is a notable gap.

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

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

Schema coverage is low (25%), but the description adds meaning to 'weak_confidence' by explaining its role in filtering. However, it does not explain 'path', 'limit', or 'dataset', so the description only partially compensates for the missing schema documentation.

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 returns a prioritized worklist of active entities needing attention, based on open conflicts or confidence below a threshold, ordered by conflict count. This distinguishes it from sibling tools like identity_list or identity_conflicts.

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

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

The description implies usage for stewards needing to prioritize attention, but does not explicitly state when not to use it or mention alternatives like identity_audit or identity_conflicts. The context is implied but not 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?

With no annotations, the description carries the burden. It discloses return format (pairs + counts) and auto-config behavior, but does not clarify whether the tool is read-only, has side effects, or requires specific permissions.

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 concise sentences with front-loaded action verb and key details, no wasted words.

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 description gives a good overview of the tool's purpose and return format, but for a 9-parameter tool without output schema, additional details on file formats or configuration could improve completeness.

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

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

Schema description coverage is high (78%), so the description adds minimal parameter detail beyond the schema. It mentions 'config' optionality but does not elaborate on the many parameters.

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

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

The description clearly states the tool's function: matching new records against an existing base dataset incrementally. It distinguishes from siblings like 'match' or 'dedupe' by highlighting the incremental aspect and avoiding full re-run.

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

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

The description implies usage context (batch of new records, existing base) and mentions auto-configuration, but does not explicitly state when not to use or name alternative tools.

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

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

No annotations are provided, so the description bears full burden. It discloses that the tool forces a pass (potentially a blocking operation), returns a list with specific fields, and has a condition for when it does substantive work. No contradictions. It does not detail side effects like performance impact, but the behavior is sufficiently described.

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: first states the action and return, second gives a key condition. No extraneous words. Front-loaded with the core purpose. Every sentence adds value.

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

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

Given 2 optional parameters, no output schema, and low complexity, the description covers return format, the condition for empty list, and the default path. It is complete enough for an agent to decide when to invoke and what to expect.

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 has 100% coverage with both parameters described. The tool description adds context beyond the schema: the condition 'Requires >= 10 corrections per matchkey' relates to the matchkey_name parameter, and the default path is mentioned. This enhances understanding of when parameters matter.

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 it forces a MemoryLearner pass over accumulated corrections and returns a list of LearnedAdjustments. The verb 'force' and the resource 'MemoryLearner pass' are specific. It distinguishes from sibling tools like add_correction which adds corrections, not learns them.

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

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

The description provides a clear precondition: requires at least 10 corrections per matchkey before threshold tuning fires, otherwise returns empty list. This guides when to use the tool. It does not explicitly exclude use cases, but the condition is implied. Sibling tools like add_correction are alternatives for building corrections.

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?

Discloses it provides per-field scores and cluster id, and optional output to directory. However, lacks details on behavior like read-only nature, dependency on a prior run, or side effects. No annotations to supplement.

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, front-loaded with purpose, then optional behavior. No redundant information, efficient.

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 3 params and no output schema, description should cover more. Missing explanation of 'loaded run', output format (inline vs path), and natural_language parameter. Incomplete for agent to use effectively.

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 low (33%), only output_dir has a description. The description adds meaning to output_dir by linking it to optional write, but max_pairs and natural_language are not explained. Baseline 3 due to partial coverage.

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 clearly states it provides field-level provenance for a loaded run, including per-field scores and cluster id, and optionally writes JSON to a directory. It distinguishes from sibling tools like explain_pair by focusing on lineage, though not explicitly differentiating.

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

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

No guidance on when to use this tool vs alternatives (e.g., explain_match, explain_cluster). No context about prerequisites or typical use cases.

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

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

No annotations provided, so description carries full burden. It mentions 'ERROR at scale' and 'would_refuse mirrors the runtime guard', giving some behavioral insight. However, it does not disclose side effects, permissions, or output format.

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

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

Two concise sentences that front-load the purpose. No unnecessary words or repetition.

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

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

For a linter tool with many siblings, the description covers the core function but lacks details on return values (no output schema) and parameter usage. It is adequate but not thorough.

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

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

Schema coverage is 0% and description does not mention any parameters. The tool has 5 parameters including nested objects, and no guidance is provided to help the agent fill them correctly.

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 clearly states the tool flags config/env overrides that force a slow path, with a concrete example. Distinguishes from sibling tools like 'plan_routing' or 'explain_routing' by focusing on linting, though could be more explicit.

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 explicit guidance on when to use this tool vs alternatives like 'plan_routing' or 'explain_routing'. The description implies it is for detecting bad config, but does not state conditions or exclusions.

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

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

No annotations provided, so description carries full burden. Only states it lists clusters and returns data, but does not disclose whether it is read-only, side-effect-free, or what auth/permissions are needed. Omits behavioral traits.

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?

Highly concise at 15 words over two sentences. Every sentence is purposeful: first states action, second states return. No extraneous words.

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

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

Adequate for a simple list tool with 2 parameters and no output schema. Covers basic purpose and return fields, but lacks information on pagination, ordering, or behavior when limit is exceeded. Leaves some gaps.

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

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

Schema coverage is 100%, so baseline is 3. Description adds no extra meaning beyond what the schema already provides for limit and min_size. No elaboration on parameter semantics.

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

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

Clearly states the verb 'List', the resource 'duplicate clusters', and the returned fields (IDs, sizes, member counts). Distinguishes from siblings like get_cluster by indicating a list action.

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

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

No guidance on when to use this tool vs alternatives such as get_cluster, compare_clusters, or explain_cluster. The description does not mention typical scenarios or exclusions.

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

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

No annotations provided, so description bears full burden. It lists the returned fields, indicating a safe read operation. However, it does not disclose any potential side effects, authentication needs, or rate limits, which is acceptable for a simple list 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, each with a distinct purpose: first states the action and optional filter, second enumerates returned fields. No wasted words, front-loaded purpose.

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 low complexity (2 optional params, no nested objects, no output schema), the description fully covers the tool's behavior: it lists corrections with an optional dataset filter and specifies the exact fields returned.

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%, providing description for both parameters. The tool description adds no extra meaning beyond what the schema already provides (e.g., 'optionally filtered by dataset' mirrors the schema description). Baseline score of 3.

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

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

The description clearly states the verb 'list', the resource 'Learning Memory corrections', and the optional filtering by dataset. This distinguishes it from the sibling tool 'add_correction' which is for writing.

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 indicates when to use the tool (listing corrections with optional filter) but does not explicitly mention when not to use it or provide alternatives. The context of sibling tools implies the read-only nature.

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

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

No annotations are provided, so the description carries the full burden. It discloses that both built-in and user-defined rulebooks are listed, but lacks details on permissions, performance, or output behavior beyond that.

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 words. Every part adds value.

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

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

Given no output schema and no annotations, the description adequately explains the tool's purpose. It could hint at return format, but for a simple list tool, this is sufficiently 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?

The tool has no parameters, so schema coverage is 100% trivially. The description adds semantic value by noting the inclusion of built-in and user-defined rulebooks, which is the baseline for no-parameter tools.

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 lists available domain extraction rulebooks, specifying both built-in and user-defined. The verb 'list' and resource 'domain extraction rulebooks' are specific, distinguishing it from sibling tools like create_domain or get_stats.

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

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

The description implies usage for when you need to see available rulebooks, but it does not provide explicit when-to-use or when-not-to-use guidance, nor does it mention alternatives among sibling tools.

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

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

With no annotations provided, the description carries full disclosure burden. It clearly states that the tool lists plugins and describes the content of each entry (name, source, category, first line of docstring). It does not hide any behavioral traits, and there is no indication of side effects or destructive actions.

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 long with no wasted words. The first sentence states the primary purpose, and the second adds relevant detail about what entries include. It is front-loaded and efficiently conveys necessary 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?

Given the tool's simplicity (one optional parameter, no output schema), the description covers the core functionality and entry structure. It might be missing details on pagination or limits, but for a list-plugins tool, the context is largely complete and sufficient for an agent.

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 0% description coverage for the only parameter (category), meaning the description must add meaning. While the description mentions 'by category', it does not explain what each enum value (all, golden_strategy, scorer, transform, connector) represents. The agent would need to infer the filtering behavior from the enum values alone.

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 lists all registered goldenmatch plugins by category, specifying the exact verb (list), resource (plugins), and scope (by category). It also details what is included (22 predefined plugins plus user-registered ones) and what each entry contains, making the purpose very specific and distinguishing from 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 does not provide explicit guidance on when to use this tool versus alternatives, nor does it mention any context where it should not be used. It lacks exclusions or comparisons to other list tools, leaving the agent to infer usage.

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

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

No annotations provided; description does not disclose read-only nature or any side effects. The word 'list' implies non-destructive but not explicitly stated. Does not explain how output_dir parameter affects behavior.

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

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

Single sentence of 12 words is concise and front-loaded, but lacks substantive detail. It is not verbose, but could be more informative.

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

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

No output schema, no annotations, and undocumented parameter. Description does not explain what 'runs' are, output format, or how to interpret the list. Incomplete for a tool with minimal other metadata.

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 description provides no explanation for the single parameter 'output_dir'. The description adds no 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?

Clearly states verb 'List', resource 'previous dedupe/match runs', and purpose 'for rollback'. Distinguishes from sibling list tools like list_clusters or list_corrections.

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?

Implies usage for rollback context but does not explicitly state when not to use or compare to sibling 'rollback' tool. Lacks explicit 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?

No annotations are provided, so the description must disclose behavioral traits. It specifies real-time matching, use of configuration, and gives an example input. This adds context beyond the schema, though it could mention output format or side effects. It does not contradict 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 two sentences plus a JSON example. It is front-loaded with the alias and purpose, then provides usage context and an example. Every sentence earns its place with no fluff.

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 alias tool with no output schema and fully described parameters, the description covers the core functionality, real-time behavior, and configuration dependency. It lacks explicit mention of return values but implies match feedback. Overall adequate for its complexity.

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

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

Schema description coverage is 100%, so the schema already explains all parameters. The description adds an example of record fields, which provides a concrete use case but does not significantly enhance semantic understanding beyond the schema.

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

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

The description clearly states it is an alias for 'match_record' and matches a single record against the loaded dataset in real-time. It explicitly names the sibling it aliases, distinguishing it. The verb 'match' and resource 'record against dataset' are specific and 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 explains when to use: to paste a record and see if it matches any existing record in real-time. It mentions using configured matchkeys, scorers, and thresholds, providing context. However, it does not explicitly state when not to use or alternatives beyond naming the alias.

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

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

The description mentions it uses configured matchkeys, scorers, and thresholds, and provides an example. However, it does not explicitly state that the operation is read-only or disclose any side effects. Since no annotations are provided, the description carries the burden but falls short of full transparency.

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

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

The description is concise: two sentences plus an example JSON. It front-loads the purpose and does not waste words. Every sentence is informative.

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 description does not explain the return value or format of results, which is a gap given no output schema. It also does not cover edge cases like no match or missing fields. For a tool with 3 parameters and no annotations, the description is incomplete.

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

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

Schema coverage is 100% with parameter descriptions. The description adds value by providing an example of the 'record' parameter format (JSON object), which clarifies how to structure the input. The 'threshold' and 'top_k' parameters are described in the schema, and the description adds context about default threshold usage.

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 matches a single record against the loaded dataset in real-time, using configured match keys and thresholds. It distinguishes from potential batch matching siblings like 'match' or 'find_duplicates' by emphasizing 'single record' and 'real-time'.

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

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

The description implies usage for checking if a specific record exists in the dataset, but does not explicitly state when to use this tool versus alternatives (e.g., batch matching tools). It lacks direct guidance on when not to use or the context of other sibling tools.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool returns a list of dicts and that the caller must handle file writing, but it does not mention side effects, rate limits, data volume, or authentication requirements. The format (CSV-shaped) is noted.

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 composed of just two short sentences that convey the essential purpose and responsibility. Every word adds value, with no superfluous information. It is well-structured and easy to parse.

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 absence of an output schema and the presence of similar siblings, the description is incomplete. It does not explain the structure of the returned dicts, the default path, or what 'dataset' refers to. More detail is needed for effective usage.

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 50%: only 'path' has a description. The tool description adds meaning for 'dataset' by stating it is an optional filter. However, it does not specify data types, valid values, or the exact format of the dataset parameter, leaving some ambiguity.

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 verb 'Return' and the resource 'corrections' as a list of dicts. It specifies CSV-shaped output and optional filtering by dataset. However, it does not explicitly distinguish this from the sibling tool 'list_corrections', which may have similar functionality.

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 mentions 'Caller is responsible for writing the file', which implies programmatic use. However, it provides no explicit guidance on when to use this tool versus alternatives like 'list_corrections' or 'memory_import', and no conditions or prerequisites are stated.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool performs an upsert with a conflict resolution strategy (higher trust wins, same trust latest wins) and returns the count. This provides good transparency into the core behavior, though it omits details like error handling or side effects on the database.

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 exceptionally concise: two sentences that efficiently convey the tool's purpose, input shape, behavior, and return value. Every word adds value with no redundancy or 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 has only two parameters, no output schema, and no annotations, the description provides sufficient context: it explains what the tool does, its input requirements, the conflict resolution logic, and the return type (count). It lacks details on error conditions or edge cases, but for a straightforward import tool, it is largely 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?

The schema has 100% coverage. The description adds value beyond the schema by providing a default for the path parameter and specifying that corrections should be exactly as returned by memory_export, which clarifies the expected structure beyond the generic 'array of objects' in the schema.

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

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

The description clearly states the tool imports corrections from a list of dicts, specifically referencing the shape returned by memory_export. It uses a specific verb and resource, distinguishing it from similar tools like add_correction which presumably handles single corrections.

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

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

The description explains the import and upsert behavior but does not provide explicit guidance on when to use this tool versus alternatives like add_correction. The context implies bulk import use case vs individual addition, but no direct comparison or exclusions are given.

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

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

No annotations are present, so the description must cover behavior. It declares it is cheap, safe, and returns specific values, but lacks details on error handling, permissions, or side effects.

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

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

The description is a single sentence plus a short fragment, front-loading key information with no wasted words.

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

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

The tool is simple with one optional parameter, and the description lists return items, but it lacks information about error scenarios or output formatting, which is acceptable for a basic status tool.