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

No annotations provided, so description carries full burden. It discloses destructive nature via 'delete' and safety guard (confirm). However, it does not mention irreversibility, cascading effects, or permission requirements. Still, it provides adequate transparency for an agent to understand the operation's gravity.

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?

Three sentences, front-loaded with core action, then required flag, then usage guidance. Every sentence adds value 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 complexity of a bulk delete with filters and the presence of an output schema, the description is fairly complete. It covers purpose, required parameter, alternatives, and context. Minor lack of behavioral depth (e.g., irreversibility) keeps it from a 5, but it's sufficient.

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

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

Schema coverage is 100%, so baseline is 3. Description adds minimal extra meaning beyond schema—it mentions the filter criteria but does not elaborate on nuances like the relationship between 'kind' and 'kinds' or the role of 'confirm' beyond 'must be true'. Hence, at baseline.

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

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

Description clearly states it bulk deletes entries matching a filter by kind/moduleName/tags. It distinguishes from siblings like delete-entry (singular) and delete-module/delete-slice by specifying bulk operation and filter criteria.

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

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

Explicitly states when to use (before full re-import, to clear a module slice) and when not to (prefer replace-entries with deleteOrphans for idempotent sync). Also notes confirm=true requirement.

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. Describes removal and index update, but lacks details on reversibility, side effects, or permissions. 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?

Three sentences with no wasted words. First sentence states action and effect, second gives use case, third lists exclusions. Perfectly front-loaded and 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?

Given tool simplicity (delete one entry) and presence of an output schema, the description covers purpose, usage, and exclusions well. Lacks mention of error conditions or idempotency, but overall complete enough.

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% with both parameters documented. The description adds no parameter-specific details beyond the schema, meeting baseline but offering no extra semantic value.

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

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

The description clearly states the verb 'Removes' and the resource 'one entry' with specific scope 'entry' (not module or slice). It distinguishes itself from siblings by explicitly stating it cannot delete modules or slices.

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

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

Provides explicit when-to-use ('Use when a fact is obsolete') and when-not-to-use ('Do not use to delete modules—use delete-module. Cannot delete slice definitions—use delete-slice') with alternative tools named.

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 discloses core behavior (deletes module and detail file) and explicitly states exclusions (entries, custom slices). Lacks information on error conditions 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?

Extremely concise: three sentences that efficiently convey purpose, scope, and exclusions 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?

Given the presence of a output schema and high schema coverage, the description is fairly complete. It could mention return values or error handling, but overall adequate for a deletion tool.

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

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

Schema coverage is 100% with descriptions. The description adds minimal value beyond the schema, only implying moduleName is required and projectId defaults to normalized workdir.

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 it deletes a module from architecture and its detail file, distinguishing itself from sibling tools like delete-entry and delete-slice by explicitly listing what it does not delete.

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

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

Provides guidance on when to use this tool by noting it does not delete entries or custom slices, and suggests using delete-entry if entries need removal. Could be more explicit about prerequisites or 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?

No annotations provided, so description carries full burden. Clearly states limitations (custom only, no entry deletion) but does not discuss reversibility or permissions. Adequate for a straightforward delete 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?

Two concise sentences with no unnecessary words. Front-loaded with primary action, then clarifies restrictions and alternatives efficiently.

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

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

Output schema exists, so return values are covered elsewhere. Description fully covers key constraints and differentiates from siblings, making it complete for this simple deletion tool.

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

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

Schema coverage is 100% with clear parameter descriptions. Description adds no new parameter information beyond what schema already 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?

Clearly states it deletes custom slice definitions only, explicitly excluding built-in slices. Distinguishes from sibling tools by specifying it does not delete entries.

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

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

Explicitly states when to use (custom slices only) and when not to (built-in slices cannot be deleted). Provides alternative for related action ('use delete-entry').

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. The description implies read-only by saying 'returns', but does not explicitly disclose safety, authentication, or rate-limit behaviors. It could be more transparent about side effects or 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?

Three sentences, each purposeful. First sentence states purpose, subsequent sentences provide usage guidance. 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's simplicity, presence of output schema, and comprehensive usage guidelines, the description covers all necessary context for correct invocation.

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

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

Schema description coverage is 100%, and the description adds value by providing context for parameters: the id should come from list-entries or search-entries, and projectId can be resolved via list-projects. This goes beyond the schema descriptions.

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

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

The description clearly states the tool returns one full entry by id, with specific verb 'returns' and resource 'one full entry'. It distinguishes from sibling tools like list-entries and search-entries by specifying when to use this tool after those calls.

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

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

Explicitly states when to use the tool ('after list-entries or search-entries when you need payload and refs') and when not to use it, providing specific alternatives like get-slice and get-module-details.

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, so the description is the primary source. It correctly indicates a read operation returning grouped counts. It does not mention any side effects or permissions, but for a simple read-only stats tool this is sufficient.

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 two sentences—no fluff. The first sentence states purpose, the second provides usage context. 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?

Given the output schema exists (not shown) and the tool has a single optional parameter, the description adequately covers purpose and usage. It could briefly mention aggregation scope, but overall it's 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 schema covers 100% of the parameter with a description ('Project id'). The tool description adds no additional meaning beyond what is already in 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 returns entry counts grouped by kind, module, and tag, specifying the verb and resource precisely. It also distinguishes itself by noting when to use it, differentiating from sibling tools that handle entries.

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 advises to use this tool after 'replace-entries/import' to verify catalog size. While it does not list when not to use it or name alternatives, the usage context is clear and helpful for the AI agent.

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 that it returns files, dependencies, examples. Hints at an implied action (adding entries) when get-slice is empty. With no annotations, the description does well but could explicitly state whether the tool is read-only or has 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?

Three concise sentences: purpose, usage guidelines, and a behavioral note. No superfluous words. Front-loaded with the core function.

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 an output schema exists, the description covers what is returned and when to use. Could mention error conditions or prerequisites (e.g., module must exist), but overall sufficient for an agent to use the tool correctly.

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

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

Schema covers both parameters fully (100% coverage). The description adds value by requiring exact match for moduleName, which is not in the schema. No further detail needed for projectId.

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 module's full detail (files, dependencies, examples). It distinguishes from sibling tools like get-slice (for cross-cutting lists) and get-project-architecture.

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

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

Explicitly states when to use: 'Use when you know the module name from get-project-architecture or list-modules.' Also provides a when-not-to: 'For cross-cutting API/domain lists use get-slice.' Includes a specific workflow hint about adding entries if get-slice is empty.

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 for behavioral disclosure. It only describes the return structure and usage context, but does not mention any side effects, required permissions, rate limits, or other behavioral traits. The description is safe but lacks transparency beyond the 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?

The description is concise with three sentences that are front-loaded with the most important information (what the tool returns). Every sentence serves a purpose: return structure, usage context, differentiation from siblings, and parameter hint. 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?

Given the tool is a simple read operation with one optional parameter and an available output schema, the description covers all necessary context: what it returns, when to use it, and how to get the projectId. It also differentiates from many siblings. The information is complete for an agent to select and invoke correctly.

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

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

The input schema already describes the projectId parameter with default behavior. The description adds value by noting 'projectId from list-projects if unsure', which provides practical guidance beyond the schema. Since schema coverage is 100%, the description enhances understanding without being redundant.

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 'Returns vertical structure: project description, module list, dataFlow' which includes a specific verb and resource. It also distinguishes itself from sibling tools get-slice and get-module-details by contrasting their use cases.

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

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

Explicitly says 'Use for refactoring boundaries between components' and provides when-not-to-use with alternatives: 'For all HTTP endpoints or domain terms use get-slice—not this tool. For one module's files and examples use get-module-details.' Also advises using list-projects to obtain projectId if unsure.

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 should carry burden. Mentions format behavior and filtering, but does not explicitly state it's read-only or disclose any safety/cost implications. 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, front-loaded with purpose, no redundancy. Every sentence adds meaning (empty slice, prerequisite call, pagination, filtering).

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 output schema present, return values are covered. Description includes key behavioral aspects: empty slice, prerequisite, pagination, filtering, format differences. Missing no critical info given complexity.

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

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

Schema coverage is 100%, but description adds value: clarifies default format, that sliceId can be built-in or custom, and gives examples. Enhances understanding beyond 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 'Returns a horizontal project view: filtered entries transformed for agents.' Differentiates from siblings by referencing slices, and explains empty slice behavior.

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 instructs 'Call list-slices first to pick sliceId.' Provides pagination guidance and filtering options, implying when to use. Lacks explicit alternatives but context is clear.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It explains the batch limit, the replace-only mode, and the deleteOrphans parameter behavior (deletes scope entries missing from batch when true). It does not explicitly mention that the tool performs a destructive update (replacing entries), but the combination of 'mode=replace' and 'deleteOrphans' implies mutation, which is sufficiently 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 concise (two sentences) but the first sentence is dense, packing multiple pieces of advice. It efficiently conveys essential information without unnecessary words, though a slight restructuring could improve 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 the tool's complexity (7 parameters, nested objects, output schema exists), the description covers the key workflow and constraints (batch size, mode, deleteOrphans strategy, alias). It omits immediate return value details, but the output schema covers that. No major gaps for an AI agent to use the tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value beyond the schema by explaining how to use parameters together (e.g., splitting batches, deleteOrphans=false until final batch, scope filter as filter object), providing context for effective invocation.

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 entries with a max of 50 per call, explicitly identifies it as an alias for replace-entries (mode=replace), and distinguishes it from siblings like delete-entries and set-entries by outlining different workflows for full re-import.

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 explicit guidance on when to use this tool (bulk import of up to 50 entries per call) and when to use alternatives (e.g., delete-entries + set-entries for full re-import, or replace-entries with deleteOrphans=false until final batch). It clearly specifies splitting large catalogs into batches and the deleteOrphans strategy.

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 discloses that the tool returns metadata only ('no payload'), supports pagination with a max limit of 200, and notes that unlinked entries lack moduleName. Does not explicitly state it is read-only, but 'returns' implies a safe 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?

Three compact sentences. First sentence states the main purpose and return fields. Second adds filter and pagination details. Third provides additional context about unlinked entries and a sibling alternative. 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?

Given the tool has 7 parameters and no annotations, the description covers the return shape, filters, pagination, and a sibling note. It does not explicitly mention the query, offset, or projectId parameters, but these are documented in the schema. For a listing tool with many siblings, it provides sufficient context to guide 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 coverage is 100% with good descriptions for each parameter. The description adds value by summarizing supported filters (kind, moduleName, tags) and pagination limit (max 200), and provides context about unlinked entries and moduleName. This supplements the schema without duplicating.

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 returns the entry catalog with specific fields (id, kind, title, tags, moduleName) and explicitly mentions 'no payload'. It distinguishes from the sibling 'get-slice' by directing to that tool for typed horizontal views.

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

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

Provides context for when to use validate ('run validate after edits') and contrasts with get-slice for typed horizontal views. Does not mention other siblings like search-entries or get-entry, but the guidance given is clear and useful.

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 a read-only operation by stating 'Lists module summaries' and scopes to 'vertical structure only.' While it doesn't explicitly mention permissions or limits, the behavioral intent is clear and consistent, and the output schema covers return structure. No contradictions.

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?

Three sentences, front-loaded with purpose, directly followed by usage guidance and a hint about usage. No wasted words; every sentence contributes meaning. Excellent 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 the simple nature of the tool (one optional param, output schema present), the description is fully complete: it covers purpose, distinguishes from siblings, gives usage context, and even provides post-edit advice. Nothing essential is missing.

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

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

Schema coverage is 100% for the single parameter projectId, with good description in the schema. The tool description adds no additional meaning about this parameter beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description clearly states what the tool does: 'Lists module summaries from architecture (name, description)—vertical structure only.' It specifies the resource (modules) and the scope (vertical structure), and contrasts with horizontal facts tools like list-slices and get-slice, 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?

Explicitly tells when to use this tool (for vertical structure) and when not to (for horizontal facts, use list-slices then get-slice). Also provides post-editing advice ('After edits run validate') and usage context for module names in set-entry refs, offering clear alternatives and 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 provided, so description carries burden. It implies read-only behavior (listing) and mentions optional filtering. Does not explicitly state nondestructive nature, but the action is inherently safe. Lacks detail on rate limits or auth, but these are likely not needed for a local 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?

Three sentences, each adding distinct value: purpose, usage guidance, optional filter. Front-loaded with primary action. 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?

For a simple list tool with one optional parameter and an output schema, the description covers location, output fields, usage context, and filter behavior. No gaps identified given the tool's complexity.

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

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

Schema covers 100% of parameters with descriptions. The description adds value by clarifying that the 'query' parameter performs a substring filter on projectId or description, which is more specific than the schema's 'filter by substring'.

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 ('Lists'), identifies the resource ('projects in ~/.mcp-architector'), and lists output fields. It clearly distinguishes from sibling tools which operate on entries, modules, or slices.

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

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

Explicitly states when to call this tool ('Call first when tools return empty/wrong project') and why (workspace path normalization). Provides a concrete example. Does not explicitly mention when not to use, but the context is clear.

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

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

With no annotations provided, the description carries the full burden. It discloses that slices are not stored data, but filters over entries, and explains the behavioral implication of an empty slice. This adds valuable 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?

The description is concise with three sentences, each serving a distinct purpose: stating the function, clarifying behavioral nuance, and providing usage advice. 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?

The description covers the core functionality, behavioral details, and usage context. However, it does not explain what happens when projectId is omitted (since it's not required) or specify the output format beyond having an output schema. Nonetheless, for a list tool with an output schema, this is adequate.

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 single parameter 'projectId' described simply as 'Project id'. The tool description does not add any additional meaning or context to this parameter, such as its effect on output or whether it's optional. It meets the baseline but provides no extra value.

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

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

The description clearly states that it lists built-in and custom slice views, clarifying that slices are filters over entries, not separate data. It also explains the meaning of empty slices, distinguishing from missing slice definitions. This effectively differentiates it from related tools like get-slice.

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 instructs to use this tool before get-slice to pick a sliceId, providing clear context. While it does not delineate when not to use it or list alternatives, the usage direction is strong.

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 fully disclose behavioral traits. It mentions rebuilding from two sources and optionally syncing module files, but omits critical information: whether the operation is destructive (overwrites existing dataFlow), reversible, or idempotent. It also fails to mention authorization needs or error states. The 'pruneOrphans' parameter hints at deletion, but the description does not address this directly. This lack of transparency could lead to risky invocations.

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 totaling about 20 words. The first sentence states the core action and sources, and the second provides a usage recommendation. Every word is purposeful, with no redundancy or filler. The structure is front-loaded with the essential action, making it easy for an agent to quickly grasp the tool's 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 the tool's complexity (4 parameters, multiple source options, potential for side effects like pruning orphans), the description is incomplete. It does not address prerequisites (e.g., project must exist), safety implications (e.g., is it safe to run multiple times?), or fallback behavior. The presence of an output schema reduces the need to explain return values, but the lack of behavioral and contextual details leaves significant gaps for an AI agent to safely and correctly use this 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?

Since the input schema has 100% coverage with descriptions for all 4 parameters, the description adds minimal extra value beyond repeating the schema's purpose. The description's mention of 'optionally syncs module files' maps to the 'syncInverse' parameter but is slightly vague. Overall, the description does not significantly enhance understanding of parameters beyond what the schema already provides, meeting the baseline expectation for high 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 verb 'rebuilds' and the resource 'dataFlow for all modules', specifying two source types (module file dependencies or dependsOn edges) and the recomputation of providesTo. It also advises using this tool instead of editing architecture.json directly. However, it does not explicitly differentiate from sibling tools like 'set-module-data-flow' or 'refactor-architecture', leaving some ambiguity about when to prefer this over alternatives.

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

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

The description provides one usage guideline: 'Use instead of editing architecture.json directly', which tells when not to use manual editing. It does not specify when to use this tool versus other sibling tools (e.g., for individual module updates use set-module-data-flow), nor does it mention prerequisites or conditions (e.g., project exists). The guidance is implied but not explicit enough for confident 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 provided, the description fully bears the burden. It discloses that the tool rebuilds an index from disk and does not modify entry bodies (non-destructive). It mentions the default for projectId ('normalized workdir'). However, it lacks details on possible side effects, error handling, or permission requirements.

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-loads the core purpose, and uses no unnecessary words. Every sentence serves a clear function: stating the action and providing usage guidance.

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

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

Given the tool's simplicity (one optional parameter) and the presence of an output schema (per context signals), the description covers the essential context: what it does, when to use it, and a parameter default. It could be slightly more complete by mentioning error conditions or the effect of an invalid projectId, but it is adequate for a focused rebuild tool.

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

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

Schema coverage is 100% with one parameter. The description adds value beyond the schema by stating 'defaults to normalized workdir,' which is not in the schema description. This gives the agent useful context not provided by the schema 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 explicitly states 'Rebuilds entries/index.json from entry files on disk' with a specific verb and resource. It distinguishes from siblings by specifying the use case for index drift, which is unique among sibling tools like list-entries and get-slice.

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 clearly states when to use the tool: 'Use when list-entries or get-slice miss entries that exist as files (index drift).' It also provides an exclusion: 'Does not modify entry bodies,' helping the agent understand when not to use it or what alternatives might be 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 and does so excellently. It discloses that orphan entries are deleted, module names and dataFlow are untouched, default dryRun behavior, and the types of mutations. No contradictions with metadata.

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 well-structured with a clear first sentence stating purpose, then workflow steps, then specifics. It is relatively concise for the complexity, though could be slightly tighter. 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?

Given the tool's complexity (multi-step refactor, many operation types), the description covers most aspects. It doesn't detail return values, but an output schema exists. The preview step is mentioned but not fully described in terms of response format. Still, 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?

Schema coverage is 100%, so baseline is 3. The description adds value by explaining the workflow ordering, relationship between dryRun and confirm, and operation constraints (max 10). This goes beyond the schema's descriptive fields.

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

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

The description clearly states the tool's purpose: 'Preview or apply in-repo refactor sync to architector data'. It lists specific mutation types (move-file, replace-path-prefix, etc.) and distinguishes from sibling CRUD tools by focusing on refactoring operations.

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 4-step workflow (scan, build ops, dryRun, apply) and explains the default dryRun=true and confirm requirement. While it doesn't explicitly contrast with siblings, the specialized purpose implicitly guides usage. The note 'no workspace access' provides 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?

Discloses max 50 entries, idempotency, matching by upsertBy, and deleteOrphans behavior. While annotations are absent, the description adds context beyond schema. Missing details on error handling or permissions but adequate given output schema existence.

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?

Three sentences with no redundancy. Key constraint (max 50) is front-loaded, followed by usage patterns and matching logic. Every sentence provides essential guidance.

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

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

Covers main use case and batching strategy well. With 6 parameters, nested objects, and output schema, the description is comprehensive. Minor improvement: could explicitly state 'replace' action, but title suffices.

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

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

With 100% schema coverage, baseline is 3. Description adds value by explaining batching strategy, deleteOrphans usage, and default upsertBy, enhancing semantic understanding beyond property descriptions.

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

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

Explicitly states it performs idempotent sync of entries with optional orphan deletion. Distinguishes from siblings like delete-entries and set-entries by batching limit and deleteOrphans parameter.

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

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

Provides explicit guidance on when to use replace-entries vs alternatives (delete-entries + set-entries) and how to handle large catalogs with batching and deleteOrphans false/true pattern.

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 the description carries full burden. It discloses return fields (snippet, matchedIn, slices, moduleName) and default limit. Could add more details like case sensitivity, but sufficient for a search tool.

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

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

Two sentences, front-loaded with key purpose, no wasted words. Efficiently conveys 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?

With output schema present, description only needs to indicate return fields, which it does. Covers search behavior and filter usage adequately; missing pagination details but schema handles that.

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 covers all 7 parameters (100% coverage). Description adds value by explaining search scope (fields: title, summary, kind, tags) and that filters narrow context, beyond the schema's descriptions.

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

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

The description clearly identifies the tool as a compact navigation search over entries, specifying searchable fields (title, summary, kind, tags) and distinguishing from siblings like get-entry and get-slice.

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?

Explicit guidance is given: use get-entry for full payload, prefer get-slice when category known, and filters narrow agent context. Default limit is also 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?

No annotations are provided, so the description fully bears the burden of disclosing behavior. It covers the 50-entry limit, the need for prior module creation, the default moduleName propagation, and the recommended validation step. It also outlines the re-import strategy, which clarifies the tool's role in a multi-step workflow.

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

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

The description is dense but not overly long. Every sentence provides unique guidance or constraint. It is front-loaded with the most critical requirement (modules must exist first). Minor redundancy: 'set-entries in 50-entry chunks' is repeated, but acceptable for emphasis.

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 parameters, no enums, and an output schema present, the description covers all necessary context. It explains prerequisites, constraints, post-actions (validate), and relationship to sibling tools. No gaps identified.

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%, but the description adds significant value: explains that top-level moduleName serves as default for refs.moduleName, that entries must have kind/title/summary required fields, and that max 50 entries per call. It also clarifies the relationship between moduleName and refs.moduleName, which is not explicit 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's purpose: creating/upserting entries with vertical structure by associating them with modules via refs.moduleName. It distinguishes itself from siblings like replace-entries by explicitly mentioning when to prefer set-entries over replace-entries, and from set-entry by implying batch operation.

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

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

Provides explicit when-to-use instructions: create modules first, set refs.moduleName to existing modules, run validate after edits. Gives clear alternative strategies: for full re-import, use delete-entries then set-entries in chunks; or replace-entries with deleteOrphans=false until final batch. Also advises splitting large catalogs into 50-entry chunks to avoid oversized payloads.

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. Describes upsert behavior, linking constraints (refs.moduleName must exist), and warns against misusing fields (e.g., summary vs description). Could add more on 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?

Long but every sentence adds value; front-loads the critical prerequisite about module creation. Could be slightly more concise, but no wasted content.

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

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

Covers prerequisites, post-actions, upsert behavior, parameter constraints, and common mistakes. Output schema exists, so return values are already described. Completes the picture for a complex tool with 8 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 high (88%), so baseline 3. Description adds semantic guidance beyond schema, e.g., explaining that refs.moduleName links by name, not summary, and giving an example of kind, title, summary 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?

Explicitly states 'Creates or updates one canonical project fact (entry)' and distinguishes from sibling tools like set-module-details. Provides concrete examples (e.g., http-endpoint) and clear resource 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?

Clearly specifies when to use ('discovered a concrete fact'), when not to ('do not use for module structure'), and alternatives ('use set-module-details'). Includes prerequisites and post-actions like 'Run validate after edits'.

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 dependsOn is canonical and providesTo is recomputed, and that it syncs module file dependencies. However, it does not mention permissions, destructiveness, or other side effects, leaving some 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?

Two sentences with no wasted words: the first states the core action and key behavioral notes, the second adds side effects and usage guidance. Front-loaded and 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?

Given the tool's complexity (5 parameters, 1 required, no enums, has output schema), the description covers the main behavioral aspects. It could mention the default for syncInverse (true), but the schema already does. Adequate for an AI 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 100% coverage, but the description adds meaningful context: it explains that dependsOn is the canonical input and providesTo is recomputed, which clarifies the syncInverse parameter's effect. This goes beyond the schema's descriptions.

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

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

The description clearly states it patches dataFlow for one module, explains that dependsOn is canonical and providesTo is recomputed, and distinguishes it from set-project-architecture for single-module graph edits.

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 advises using this tool over set-project-architecture for single-module edits, providing clear context for when to use it. It does not include explicit 'when not to use' scenarios, but the alternative is clearly named.

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 discloses the max 50 facts per call, automatic setting of refs.moduleName, and the emptiness of get-slice without entries. Could be more explicit about overwrite vs merge behavior on updates.

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 paragraph with clear front-loading of core purpose, followed by important constraints and alternatives. Uses caps for emphasis. Slightly dense but 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?

Given 10 parameters, high schema coverage, and presence of output schema, the description covers the essential use cases, batching, and relationships. Lacks details on projectId defaulting and exact update semantics, but overall sufficient.

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

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

Schema coverage is 100%, baseline 3. The description adds meaning beyond schema: explains the relationship between facts and entries, the 50-item limit, and that refs.moduleName is set automatically. Provides usage context for 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 starts with a clear verb and resource: 'Creates or updates one vertical module.' It distinguishes from siblings by noting 'Prefer over set-project-architecture for single-module edits.' Also explains what slices are built from, showing specific 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?

Explicitly states when to use this tool vs alternatives like set-entries. Provides batch splitting guidance, re-import strategy using delete-entries and replace-entries, and warns about the consequences of missing entries. This is comprehensive.

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 explains merge vs replace behavior, that dataFlow can be omitted to preserve existing, and warns that new modules still need entries. Could be more explicit about destructiveness and permissions, but covers key 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?

Description is appropriately sized for the complex tool, front-loading purpose and usage, then covering parameter behavior. Some redundancy but well-structured overall.

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 (6 params, nested schema, output schema exists), the description covers main use cases, parameter interactions, and provides context about projectId validation and subsequent steps. Minor gaps in return value description but compensated by 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%, baseline 3. Description adds meaning by clarifying the merge/replace semantics for modules and dataFlow parameters, and the purpose of each parameter beyond schema descriptions.

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

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

The description clearly states the tool creates or updates vertical module structure (components and dataFlow), distinguishing it from horizontal facts. It uses specific verb+resource and differentiates from sibling tools like set-module-details and set-entry.

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?

Explicit guidance on when to use this tool vs alternatives: 'For one module use set-module-details or set-module-data-flow. For bulk flow rebuild use rebuild-data-flow.' Also advises against using for APIs/scripts and provides fallback for wrong projectId.

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 carry the burden. It clearly states the slice is filter-only and items live in entries. It warns against storing duplicate entry text. However, it does not disclose if the tool overwrites existing slices or require 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?

Four sentences, each adding value. Front-loaded with core purpose. No fluff or redundant 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 27 sibling tools, description distinguishes from get-slice and mentions built-in slices. It covers main use case and constraints. Lacks details on overwrite behavior or relationship with other slice 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 coverage is 100%, so baseline is 3. Description adds value by explaining the slice is a filter and giving usage context for kinds and tags. It does not detail each parameter but reinforces overall 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 the tool saves a custom slice definition (filter only, not items). It distinguishes from built-in slices and provides an example. The verb 'saves' and resource 'custom slice definition' are specific.

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 'Use when built-in slices are not enough' and gives an example, implying when to use. It also warns against storing duplicate entry text. However, it does not explicitly state when not to use or list all 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 provided, so description carries full burden. Discloses that it returns a compact report (summary, stats, issues by kind), lists all checks, and notes that it avoids loading the full project. Does not explicitly state read-only nature, but implied.

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 efficient, front-loading purpose and usage. It is slightly lengthy due to listing checks, but each sentence adds value. Could be more concise, but overall well-structured.

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

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

Given the 9 parameters, output schema exists, and no annotations, the description adequately covers usage context, behavioral traits, and parameter roles. It provides sufficient guidance for correct invocation.

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

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

All 9 parameters have full schema descriptions (100% coverage). The tool description adds context by listing the checks corresponding to boolean parameters and explaining moduleEntryMin, but does not significantly enhance the parameter semantics 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 the tool validates a project after specific setup steps and returns a compact report. It lists the checks performed, differentiating it from sibling tools like validate-architecture and validate-import.

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 mentions when to run the tool (after set-project-architecture, etc.) and suggests iterative use ('Fix issues[] then call validate again'). Does not explicitly state when not to use it, but context is clear.

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

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

No annotations provided, so the description must carry the burden. It only says 'same checks' but does not describe whether the tool is read-only, destructive, or any side effects. The name suggests validation, but the description lacks explicit 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?

Two concise sentences with front-loaded information: alias identification and usage guidance. No wasted words, but could include a brief summary of checks.

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?

Despite an output schema existing, the description fails to explain what the tool does beyond being an alias. With 9 parameters, the lack of context on the actual validation process makes it incomplete for an agent to understand 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 coverage is 100% with all parameters described. The description adds no meaning beyond the schema, 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?

The description clearly states it is an alias for validate with the same checks, distinguishing it from siblings by advising to prefer the primary validate tool. The purpose as a legacy alias for architecture validation is clear.

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

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

Explicitly says 'Prefer validate after edits. Legacy name kept for compatibility.' This directly tells when to use this tool (for compatibility) and when not (prefer validate), with the alternative named.

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, but the description covers behavioral traits: it is a dry-run ('without writing'), checks duplicate upsert keys and unknown moduleName refs, and enforces a max 50 entries. This fully informs the agent of what the tool does and does not do.

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, front-loaded with the core purpose, and every sentence provides essential guidance. 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?

Given the output schema exists (context signal), the description does not need to explain return values. It adequately covers purpose, usage, parameter behavior, and constraints, making it complete for the agent to invoke correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds context by linking parameters to behavior (e.g., 'Checks duplicate upsert keys' relates to checkDuplicates, 'unknown moduleName refs' to checkModuleExists) and by noting the max 50 entries, which corresponds to the entries array maxItems.

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 performs 'dry-run validation for a proposed import batch (max 50 entries)', specifying the verb (validate), resource (import batch), and scope (dry-run, max 50). It distinguishes from sibling tools like set-entries and replace-entries by emphasizing no 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?

Provides explicit when-to-use (before actual import) and alternatives: 'For full re-import: delete-entries once, then set-entries in 50-entry chunks; or replace-entries with deleteOrphans=false until the final batch (deleteOrphans=true).' Also advises splitting large catalogs into batches of ~50 to avoid oversized payloads.

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