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

Annotations declare readOnlyHint=true, so the tool is known to be harmless. The description adds value by explaining what each mode returns (e.g., 'real implementation examples', 'missing standard methods'), offering behavioral context beyond the schema. It doesn't discuss performance or limitations, but the read-only nature is covered by 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 well-structured with a brief opening and a bulleted list of modes. It is concise enough for a multi-mode tool and front-loads the core action. Every sentence adds information, though the list is somewhat lengthy.

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

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

Without an output schema, the description compensates by explaining the return type of each mode (patterns, code examples, gaps, usage). Given the tool's complexity (10 params, 4 modes) and the read-only annotation, the description is sufficiently complete for an agent to select and invoke the tool correctly. Minor gaps remain around edge-case behavior, but not critical.

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 repeats mode-to-parameter associations (e.g., '[patterns]', '[api-usage]') but does not add substantive meaning beyond what the schema already provides. Each parameter's purpose is already documented 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 function: 'Learn from the existing codebase' and then enumerates four distinct modes with concrete outcomes (patterns, implementations, completeness, api-usage). It distinguishes itself by naming these modes, though the verb 'learn' is somewhat abstract and it doesn't explicitly contrast with sibling tools like get_method or object_patterns.

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

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

It provides an explicit usage directive: 'call BEFORE generate_object(mode="pattern")' for the patterns mode. Other modes are described with their purposes, implying appropriate use cases, but no exclusions or comparisons to alternative tools 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?

The description clearly discloses that the tool blocks until done and warns against polling, which adds real behavioral context. It also explains the effect of fullBuild on stale-symbol errors. Annotations already cover read-only/destructive hints, so the description builds on them without contradiction.

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

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

Three dense sentences, each earning its place. The key behavioral constraint (blocks, call once, don't poll) is front-loaded, and the fullBuild fix is stated as a specific conditional. No filler or redundant restating of the tool name.

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

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

For a 7-parameter tool with no output schema, the description plus rich input schema covers the important behavioral caveats: blocking, single-call usage, whole-model compilation, and stale-symbol remediation. It is slightly incomplete in not mentioning the dbSync requirement after schema changes, though the schema handles that thoroughly.

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 some interpretive value by explaining the full-model scope and a concrete use case for fullBuild, but most parameter meaning is already well documented in the schema. It does not materially clarify the other six parameters 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 a specific action (Build), a specific resource (D365FO model via xppc.exe), and explicitly distinguishes scope: compiles the ENTIRE model, not one project. This clearly separates it from project-level or verification tools like verify_d365fo_project.

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

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

The description gives strong operational guidance: call exactly once per build, do not poll, and use fullBuild:true for stale-symbol errors. It does not explicitly name sibling alternatives or state when to use an alternative tool, but the blocking semantics and fullBuild trigger provide clear usage 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?

Annotations already mark the tool destructive and non-read-only, but the description adds rich behavioral detail: UTF-8 BOM writes, auto-registration in .rnrproj, IRREVERSIBLE delete semantics, git checkout HEAD behavior for undo, immediate apply with no dry-run for modify, and Windows-only execution. This goes far beyond the annotations and materially changes how an agent should act.

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 long but densely packed and well-structured with per-action bullets, warnings, and navigation hints. Critical safety information is front-loaded and visually emphasized, and no sentence is filler given the tool's genuine complexity.

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

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

For a 5-action tool with 16 parameters and no output schema, the description covers most operational context: environment constraints, op-spec lookup, project-file behavior, failure signals via isError, and per-operation results. The only minor gap is that it does not describe the success return shape in more detail beyond these signals.

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

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

Schema description coverage is high at 94%, but the description adds essential semantic context: which params nest under params vs properties, how op-spec lookups supply operation-specific contracts, when filePath bypasses symbol-DB lookup, and critical anti-guidance like 'NEVER hand-build the prefix' and 'NEVER take modelName from search results.' This meaningfully exceeds 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 opens with a precise verb and resource: 'Create, modify, delete, undo, or generate a D365FO AOT object.' Each action is explicitly defined and distinguished from the others, making the tool's boundaries clear even without reading the schema.

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

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

The description gives actionable when-to-use guidance for each action: modify applies immediately so confirm first, delete is irreversible, undo discards ALL uncommitted changes, generate is the non-Windows fallback with 'Try create first.' It also tells the agent to fetch op-spec contracts via get_knowledge before invoking, which prevents guessing.

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

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

Annotations declare readOnlyHint=true and openWorldHint=false, so the tool is known to be read-only. The description adds behavioral context by detailing what each mode returns or analyzes (e.g., effective merged schema, available extension points, who already wraps). It also notes that showExistingExtensions 'roughly doubles the response', a practical performance trait. It does not contradict annotations and adds value beyond them, though it doesn't cover potential errors or latency.

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 compact bulleted list, front-loaded with a clear one-line purpose. Each mode is described in one or two sentences with no redundancy. The structure is scannable and every sentence earns its place, from the overall analysis purpose to mode-specific 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?

For a tool with 10 parameters and 5 modes, the description covers all modes and their intended use cases, including which parameters are relevant per mode. It explains outputs (e.g., merged schema, extension points, recommendations) sufficiently without an output schema. No missing critical information prevents an agent from calling the tool correctly, making it complete.

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

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

Schema description coverage is 100% with detailed per-parameter descriptions (e.g., mode: 'coc/events/table-merge/points need target; strategy needs goal'). The description adds mode-level context but does not introduce new parameter meanings beyond the schema. Since the schema already documents parameters thoroughly, the baseline of 3 is appropriate; the description names which modes use which parameters, slightly aiding selection but not adding substantial 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 states 'D365FO extensibility analyzer' and enumerates five distinct modes (coc, events, table-merge, points, strategy) with specific resources and goals. Each mode is tied to a concrete action (e.g., 'Chain of Command extensions + event subscriptions for a class/table'), making it unambiguous what the tool does and how it differs from generic search or analysis 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?

Every mode includes explicit usage context: 'Use before writing a CoC extension to check for conflicts', 'Use before adding handlers to check for duplicates'. The strategy mode states it 'recommends the best extensibility mechanism for a goal', and the description explains which parameters each mode requires. This provides clear when-to-use guidance for each variation, effectively distinguishing from siblings.

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

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

Annotations already declare readOnlyHint=true, so a read operation is understood. The description adds meaningful behavioral detail beyond that: the method-name-matches-every-type over-reporting behavior, that label results span every object type (not just code), and the DYNAMICSXREFDB/full-server-mode requirement. This enriches the safety/behavioral profile without contradicting 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 long but every sentence earns its place — method scoping, label semantics, and prerequisites are all operationally critical for correct invocation. It is front-loaded with the core purpose and scoping rule before edge cases. Slightly dense but no filler.

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

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

Comprehensive for a read tool whose annotations already cover safety: all target types, method-scoping edge cases, label behavior, and the xref prerequisite are covered. The only gap is that with no output schema, the return format/pagination behavior (relevant given the limit param) is not described. Otherwise nothing an agent needs to call it correctly 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?

Despite 100% schema coverage, the description substantially enriches parameter meaning. It explains the targetName scoping rule for methods (Owner.method vs bare name vs AOT path), the exact label id format ('@WAX2194' or '@MyLabelFile:MyLabel'), and how ownerName scopes a bare method name. It also clarifies targetType's 'label' value and the '@…' shortcut. This goes well beyond the schema's one-line parameter 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?

States a specific verb and resource: 'Find all references (where-used) to a class, method, field, table, enum, or LABEL.' This clearly distinguishes it from siblings like search (general search), get_object_info, and validate_code. The 'Essential for impact analysis before refactoring' line reinforces the distinct role. No tautology.

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 strong usage context — 'Essential for impact analysis before refactoring' — plus concrete invocation patterns (Owner.method, ownerName, AOT path) and an explicit over-reporting warning for bare method names. Covers label usage and its xref database prerequisite. It doesn't name which sibling to use instead in specific cases, but the guidance is otherwise explicit and actionable.

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 clearly discloses that pattern mode is 'text only, no write', and it labels outputs for most modes (text, XML, X++ snippets). It also reveals that missing required parameters cause the tool to return that mode's complete spec. However, scaffold mode's write-vs-return behavior is not explicitly stated, leaving some ambiguity about side effects beyond what the annotations convey.

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

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

The description is dense but well-organized with a front-loaded purpose statement and a clear bullet list of modes. Every sentence carries routing, parameter, or behavioral information; no filler or redundant restatement of the schema is present. The length is proportional to the tool's six-mode complexity.

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 no output schema and six distinct modes, the description is remarkably complete: it explains each mode's intent, output form, required setup, and related tools. It intentionally outsources full mode contracts to get_knowledge, which is a reasonable and explicit completeness mechanism. The only slight gap is scaffold's output behavior, but the overall guidance is sufficient 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?

Even though the schema covers 83% of parameters, the description adds substantial meaning: it explains what `name` means for each mode, clarifies that `params` is one nested object, decodes pattern enum abbreviations, and notes that modelName is auto-detected. This goes well beyond the raw schema and helps an agent construct valid calls.

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

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

The description opens with a specific verb and resource, 'Generate X++/AOT code', and immediately enumerates six distinct modes with their concrete outputs. It also explicitly contrasts this tool with d365fo_file(action="generate") for existing objects, making it easy for an agent to distinguish it from a sibling tool.

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

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

The description gives an explicit workflow for pattern mode: call analyze_code(mode="patterns") first, then generate_object(mode="pattern"), then d365fo_file(action="create"). It also directs agents to get_knowledge for mode contracts and identifies d365fo_file(action="generate") as the alternative for existing object XML, providing clear when-to-use guidance.

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

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

The annotations cover read-only safety, and the description adds behavioral guarantees beyond that: knowledge is a 'queryable rulebook', error mode promises 'structured root cause + step-by-step fix + corrected X++ example', and bp-moniker is 'backed by names/text extracted from a real D365FO install — never invents a moniker'. No contradiction with readOnlyHint or openWorldHint.

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 bulleted and front-loaded with the core instruction ('Choose a kind'), then each mode gets a compact, purposeful sentence with no filler. The length is justified by the four distinct behaviors and the need to route callers 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?

For a 10-parameter tool with no output schema, the description covers the input space thoroughly: all four kind values, their intended use, the output shape for error mode, the index behavior for op-spec, and the rendered Diagnostic block for bp-moniker. The remaining details are already captured by the high-coverage input 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 already high (90%) and each parameter has a mode-tagged description, so the baseline is 3. The description earns an extra point by explaining why op-spec exists, by defining what each kind means for parameter selection, and by adding the 'omit topic for index' rule that clarifies an otherwise underspecified optional 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 states a specific action ('knowledge lookup') plus four clearly delineated resource kinds, each with its own purpose: rulebook, error diagnostics, op-spec contract, and bp-moniker validation. It explicitly references the sibling tools d365fo_file and generate_object, making it easy for an agent to distinguish this from nearby 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?

Each bullet gives an explicit when-to-use rule: knowledge before generating code, error instead of guessing, op-spec after picking the operation and before the call, bp-moniker for validate/search/suppress. It even explains that d365fo_file and generate_object deliberately omit inline parameters, making this lookup a required prerequisite rather than an optional convenience.

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

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

Annotations already mark readOnlyHint=true, and openWorldHint=false, so the read-only safety profile is established. The description adds substantial behavioral context beyond that: batching with max 10, parallel execution, per-object sections, automatic dot-suffix stripping for extensions, the members shortcut for classes, and the method-signature option needed before writing CoC extensions. This richly discloses how the tool behaves.

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 long but dense and appropriately front-loaded with the core purpose. Every sentence carries operational value, and guidance like 'never loop single calls' is a necessary addition. It could be slightly improved with clearer visual separation of the many rules, but no sentence is wasted.

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

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

For a tool with no output schema and high complexity, the description covers the main calling patterns, type taxonomy, extension behavior, and key options. It gives only a high-level picture of return values ('per-object sections back', 'fast IntelliSense-style member-name list'), which is probably sufficient for invocation but leaves some response-shape detail unspecified. Still, the description is complete enough for an agent to select and call 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?

Although schema coverage is 100%, the description adds significant semantic value beyond the schema: it clarifies that objects[] is the preferred batch form, explains how extension types treat base vs. extension names, lists what each options flag is used for, and gives concrete examples like {"members":"names"} and {"method":"validateWrite","include":"signature"}. This goes well beyond the schema's own 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 opens with a specific verb and resource: 'Read D365FO object metadata.' It also enumerates the supported object types and distinguishes the read-oriented purpose from sibling tools by implication. However, it does not explicitly name or contrast any sibling (e.g., search, find_references), so differentiation is clear but not stated.

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

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

The description gives strong operational guidance: use objects[] for 2+ objects, never loop single calls, pass base or full extension names, and use type-specific options. It also includes an explicit 'never shell out' directive. It does not, however, tell the agent when to prefer this tool over specific siblings such as search or find_references, so exclusion guidance is incomplete.

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

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

Beyond readOnlyHint=true, the description reveals useful traits: it flags placeholder model names and missing EXTENSION_PREFIX, is the authoritative source for the target model, and treats the changes parameter as review-only ('not a way to verify a write'). This gives agents expectations about validation and reliability.

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

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

The description is compact and front-loaded with the most important instruction ('ALWAYS call FIRST at session start'), then lists return values, flags, and source authority in four tight sentences. No filler or repetition.

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

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

For a no-output-schema tool, it names the key returned fields, flags edge conditions (placeholder model, missing prefix), and tells the agent where the information sits in the session workflow. Combined with the rich parameter schema, 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 description coverage is 100%, so the input schema already fully documents all four parameters. The description adds only a small usage note about passing projectName/projectPath, but does not materially extend the parameter semantics beyond what the schema provides.

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

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

The description names a specific verb and resource ('get workspace info') and states precisely what it returns: model name, package path, framework directory, project path, environment type, and EXTENSION_PREFIX. It also distinguishes itself from siblings by declaring it the 'Authoritative source for target model — not search results,' and by being the mandated first call.

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

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

It gives an explicit invocation rule ('ALWAYS call FIRST at session start'), tells when to pass projectName/projectPath ('when you have the project's name or path'), and warns against using search results for the target model. The schema's diagnostics and changes parameters further state when to use them (debugging vs review-only), so an agent knows when to call this vs 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?

Annotations already mark the tool as destructive and not read-only, and the description adds concrete behavioral details: update overwrites existing labels, rename affects .label.txt + X++ + XML + index, bulk failures do not abort the batch, and write plumbing is auto-resolved unless overridden. This is far beyond what annotations alone provide, and there is no contradiction.

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

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

The description is front-loaded with the core purpose and then organized by action in a scannable bullet list. It is long, but the tool has 14 parameters and five distinct action modes; the density is justified. One small deduction because some parameter-level details like 'Default one line per label' could have been left to the schema descriptions.

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 all five actions, their key parameters, write plumbing, bulk mode, and even output hints for search truncation. However, there is no return-value explanation for create/update/rename and no output schema, so an agent does not know exactly what those write calls respond with. Given the tool's complexity, that is a minor but real 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 93%, but the description adds substantial extra meaning: array queries mean multiple phrasings, labelId accepts @SYS or @Model:Label spellings, labelFileId semantics differ for new vs existing files, label IDs should describe meaning rather than model prefixes, and bulk mode expects shared fields at the top level. It even explains the required createIfMissing=true behavior despite that parameter not being a direct named schema property.

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 presents 'Unified label operations — read and write' and enumerates five distinct actions with specific verbs: search, info, create, update, rename. It also distinguishes itself from sibling d365fo_file by explaining when no label call is needed, so an agent can tell what this tool is for.

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

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

The description gives explicit when-to-use guidance: search is 'never needed before a create,' createIfMissing=true replaces search-then-create, write operations are labeled as write, and rename advices dryRun first. It also names alternatives like d365fo_file create/modify and tells the agent when to use get_knowledge for overrides.

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

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

The readOnlyHint annotation already covers the non-destructive nature. The description adds useful behavioral context: validation returns FP001-FP010 checks, analyze uses the Microsoft decision tree and names reference forms, and validate is meant to precede d365fo_file creation. It would be stronger if it explained the repair action's in-memory behavior explicitly, but there is no contradiction with the annotations.

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

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

The description is dense but well-structured with domain bullets and action sub-bullets. It front-loads the domain decision and avoids repeating parameter-level detail already in the schema. For a 12-parameter, multi-domain tool, this is appropriately sized and scannable.

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?

Considering the complexity and the read-only annotation, the description is nearly complete: it covers all major domains, the main actions, output-like evidence (reference forms, FP codes), and a cross-tool dependency. The one clear gap is the undocumented 'repair' action, which prevents a perfect score.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by showing how parameters combine by domain and action, e.g. recommend for new forms, tableGroup/similarTo for table patterns, and pattern=<id> for report/mobile-app. It does not discuss repair or limit, but the schema documents those clearly.

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 is a detailed pattern toolkit manual: each domain (table, form, report, mobile-app) is tied to concrete operations such as analyze, spec, validate, and recipe generation. It clearly scopes the tool to D365FO pattern concerns and even names the related d365fo_file create action for the validation flow.

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

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

It gives strong usage guidance inside the tool: 'For a NEW form pass recommend (preferred)', 'Call before d365fo_file action=create', and it explains when to filter by formPattern/dataSource/similarTo. However, the schema's action enum also lists 'repair' yet the description completely omits that action, so guidance for one alternative is missing.

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

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

Annotations declare readOnlyHint=true, so safety is covered. The description adds useful behavioral details beyond the annotations: groundingToken has a 30-minute TTL and is required for extension/new-object writes when GROUNDING_ENFORCE=true. It does not describe the full response shape, but the token and its lifecycle are disclosed.

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

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

The description is dense but well-structured: the core value proposition and token requirement are front-loaded, then each mode gets a concise bullet with concrete outputs. Every sentence contributes useful information with no filler.

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

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

Despite no output schema, the description enumerates exactly what each mode returns: signatures, wrappers, collision checks, naming advice, EDT suggestions, tests, and the red-first cycle. It also explains parameter behavior such as operation defaults and objectType auto-detection, making it sufficient 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 coverage is 88%, and the input schema already documents each parameter with mode-specific meanings and examples. The description adds high-level mode context but does not materially improve parameter-level understanding beyond what the schema already 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 identifies 'prepare' as a one-call context aggregator that returns a groundingToken, and it defines distinct change/create/test modes with concrete outputs. It also differentiates itself from the sibling loop by explicitly stating it replaces analyze→search→info→generate.

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

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

The description gives explicit mode-specific guidance: change for modifying existing objects, create for new objects, and test for writing SysTests. It also names the multi-tool alternative it replaces, making selection straightforward.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the read-only nature is covered. The description adds useful behavioral context: the ordering constraint relative to builds, the kind of findings returned, and the relationship to the integrated build check. It does not cover failure modes or permissions, but the read-only annotation lowers the burden.

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

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

Two sentences deliver purpose, output examples, a usage precondition, and the key alternative in a compact way. There is no filler, and the most important scoping guidance appears early.

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

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

There is no output schema, so the description correctly covers what the tool returns: BP warnings and errors with rule codes. It also communicates when to call it and why separate calls are often unnecessary. It could mention result grouping or what happens when all parameters are omitted, but the schema already covers parameter auto-detection and batching.

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 all four parameters (objects, modelName, packagePath, projectPath) are already documented with meaningful descriptions, including auto-detection and preferred batching of objects. The description does not need to repeat these details, and it adds only output-related context. 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 specific action: running Microsoft Best Practices checker (xppbp.exe) on a D365FO project, and what the output is: BP warnings and errors with rule codes. It also distinguishes itself from the sibling build_d365fo_project by noting that build already integrates this check.

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

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

The description explicitly says when the tool should be used — AFTER a build, not after a write — and notes that build_d365fo_project(bpCheck:true) already folds this check in, so a separate call is rarely needed. This gives an agent clear routing guidance toward the preferred alternative.

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

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

The description adds meaningful behavioral detail beyond the annotations by specifying that execution happens via SysTestConsole.exe in unattended mode and that results are returned per method. This tells the agent what kind of operation this is and what to expect without contradicting the annotations.

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

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

The description is a single, well-structured sentence. It front-loads the action and target, then adds the execution mechanism and result format 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?

With no output schema, the description does need to convey what the caller receives, and it does so by stating 'returning per-method results'. It also covers the core execution context. However, it does not describe the output shape beyond per-method results, which is a minor gap for a test runner with 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 description coverage is 100%, so all four parameters are already documented in the input schema. The description does not add additional parameter-level meaning, but it also does not need to; the baseline of 3 is appropriate when the schema fully carries 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?

The description names a specific verb ('Execute'), a specific resource ('D365FO unit test class'), and a concrete mechanism ('SysTestConsole.exe (/unattended)'). It also states the observable outcome ('returning per-method results'), making the tool's purpose unambiguous and distinct from sibling build/validation 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 makes the usage context clear: it is the tool for executing a D365FO unit test class and getting per-method results. While it does not explicitly name alternatives or exclusions, none of the sibling tools perform unit-test execution, so the context is sufficient without needing an explicit when-not-to-use clause.

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

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

Beyond readOnlyHint, the description explains batch parallelization/dedup/cross-reference behavior and warns that extension results report SOURCE models that must never be used as create/modify targets. It also documents ignored parameters in batch mode. This is meaningful behavioral disclosure beyond the annotations.

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

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

The description is compact, scannable, and front-loads the core statement followed by three mode bullets and one routing sentence. Every sentence adds decision-relevant information; no filler or repetition.

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

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

For a read-only search tool with no output schema, it covers return content (name, type, model), mode-specific parameter behavior, the extension-model warning, and the relevant sibling. Nothing essential for selecting or invoking the tool 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%, so the baseline is 3. The description adds mode-level semantics that connect parameters (query vs queries[], scope ignored in batch, extensions + prefix), plus the source-model caveat, which goes beyond the schema descriptions and helps agents construct valid calls.

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

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

The description opens with a specific verb and resource—'Search pre-indexed D365FO objects by name or keyword'—and goes on to name the sibling alternative get_object_info when exact names are known. This makes the tool's job unambiguous and distinguishes it from nearby lookup tools.

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

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

It explicitly defines three modes and when each applies (single, batch, extensions), states the max batch size, and closes with a concrete routing rule: use get_object_info when exact name and full details are needed. This is actionable selection guidance rather than implicit context.

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

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

The readOnlyHint annotation already communicates non-destructive behavior, so the description's additional detail is valuable: it discloses the traversal paths (Role → Duties → Privileges → Entry Points and object → menu items → privileges → duties → roles). This exceeds what the annotations alone provide and helps the called tool behave predictably, though it doesn't cover potential errors or edge cases.

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

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

The description is compact and well structured, using bullet-like mode definitions with clear arrows to show hierarchy. Every sentence and clause contributes practical information, and the most important routing instruction ('Choose a mode') 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?

Although there is no output schema, the description gives a fairly concrete picture of what the caller can expect: full artifact hierarchies for artifact mode and reverse access chains for coverage mode. Combined with the input schema, this is sufficient for most call intentions, though a few details such as exact response shape or limit behavior are absent.

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

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

Schema description coverage is high (83%), and the schema already explains each parameter, including mode-specific requiredness, defaults, and enums. The description reinforces the conceptual meaning of the modes and their output chains, but doesn't add significant parameter-level detail beyond what the schema already provides. Thus it earns the baseline 3.

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

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

The description clearly identifies the tool as a D365FO security lookup and breaks down two distinct modes: artifact lookup and coverage analysis. Each mode specifies exactly what is returned, including the full hierarchy and reverse chain, making the tool's purpose unambiguous and differentiating it from generic lookup 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 gives clear context about when to use each mode: 'artifact' for hierarchy details on a security artifact, and 'coverage' for reverse access chains on an object. It does not explicitly name alternative tools or exclusions, so it stops short of a perfect 5, but the mode guidance is strong enough to guide correct invocation.

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

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

Annotations already provide idempotentHint=true and destructiveHint=false, and the description adds meaningful behavioral context beyond those: each call triggers a bridge refresh cost, calling it after create/modify is a wasted round trip, and omitting filePath changes the operation to a bridge/cache refresh only. This gives the agent a clear mental model of what the tool actually does and its 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 three sentences, each with a distinct purpose: stating the tool's role, giving an explicit exclusion, and explaining an optional invocation mode. No unnecessary words or redundancy. Information is front-loaded and easy to scan.

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 low-complexity tool with one optional parameter, no output schema, and rich annotations, the description covers purpose, usage boundaries, and both invocation modes. There is no missing information that an agent would need to correctly select and invoke 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?

The schema already documents filePath with type, array support, and batching guidance, so the baseline is 3. The description adds critical semantics beyond the schema: omitting filePath performs a bridge/cache refresh only, and the filePath should identify files changed outside this server, which shapes what value the agent should pass. This is valuable supplementary meaning.

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

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

The description names a specific verb ('Index'), a specific resource ('D365FO XML file(s)'), and a precise scope ('changed OUTSIDE this server'). It also differentiates the tool from sibling d365fo_file create/modify by explaining that those operations already refresh the index. An agent can clearly tell what this tool is for and what it is not for.

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

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

The description explicitly states when to use the tool ('changed OUTSIDE this server') and when not to call it ('Do NOT call after d365fo_file create/modify'), naming the alternative tool. It also documents the special mode where filePath is omitted for a bridge/cache refresh only. This is direct, actionable usage 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?

Beyond the readOnlyHint annotation, the description adds rich behavioral context: offline operation, no xppbp.exe, index-only reference resolution, structured violation output, and coverage of specific rule families. This makes the tool's side-effect-free and execution model 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 well-structured with a concise opening line and bullet-separated modes. It front-loads the core purpose, then gives mode-specific detail and final actionable timing guidance. Every sentence contributes useful information without unnecessary repetition.

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

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

For a tool with no output schema, the description explains the syntax-mode return shape and the overall verification behavior. It is slightly less explicit about the exact return format for references mode, but the usage context, parameter intent, and integration behavior are otherwise well covered.

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

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

The schema already covers all parameters at 100%, so the baseline is 3. The description adds meaningful semantics beyond the schema, especially for mode ('both' preferred), codeType ('xml-table' checks XML refs), and the behavior of references mode. It doesn't enrich the context parameter, but the overall value exceeds baseline.

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

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

The description states a specific verb and resource: a static validator for generated X++/XML. The mode breakdown (syntax vs references) and the 'no xppbp.exe' note clearly distinguish it from related siblings like run_bp_check and find_references.

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

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

The description gives explicit timing guidance: call mode='both' AFTER generating and BEFORE writes, and fix errors in the same turn. It also notes that write tools run references internally when GROUNDING_ENFORCE=true. It does not explicitly contrast with sibling alternatives, so it stops short of a 5.

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

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

The readOnlyHint annotation already signals safety, and the description adds useful behavioral detail by mentioning conflict detection against the symbol index and the categories of naming rules checked. No contradictions exist between description and 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 a single, tightly worded sentence that front-loads the action and resource, then lists the validation checks. Every phrase adds useful information with no filler.

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

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

Given the moderate complexity, complete parameter schema, and readOnlyHint annotation, the description is largely sufficient for selecting and invoking the tool. It could explicitly mention the return format or that results indicate pass/fail with reasons, but that is a minor gap because the tool's purpose is clear.

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 all four parameters are already documented. The description reinforces concepts like ISV prefix and extension naming, but does not add significant new parameter-level meaning beyond what the schema provides.

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

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

The description states a specific verb ('Validate'), a clear resource ('a proposed D365FO object name'), and enumerates the exact validation dimensions (extension naming, ISV prefix, type-specific suffixes, symbol-index conflict detection). This clearly distinguishes it from sibling tools like validate_code or generate_object without 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?

The description provides clear context: this tool is for checking a proposed object name against naming conventions before use. It does not explicitly name alternatives or state when not to use it, but the purpose is specific enough for an agent to infer when it applies.

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

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

Annotations already establish readOnlyHint=true, and the description adds useful behavioral context: the tool runs after build, is read-only verification, and supports scoped vs whole-project verification. It does not describe result/output or failure behavior, but this is a minor gap given the read-only nature.

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

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

The description is dense but every sentence earns its place: core purpose, alternative tool, timing, and the important omit-objects behavior. It is front-loaded with the primary verification action and keeps all guidance relevant.

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

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

For a read-only verification tool with three optional parameters and no output schema, the description supplies sufficient context for correct selection and invocation. It covers scope, timing, prerequisites, and the key alternative, so an agent can act without further clarification.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaning beyond the schema by clarifying that omitting `objects` verifies every object in the project and that projectPath is needed for project-reference checking or can be auto-detected/configured. This goes beyond the raw 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 states a specific verb and resource: verify D365FO objects exist on disk at the correct AOT path and are referenced in the .rnrproj project file. It clearly distinguishes this from related tools like d365fo_file by noting it runs after a build rather than after a write.

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

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

The description gives explicit when-to-use guidance: after a build, not after a write, and names d365fo_file as the alternative that already verifies its own write inline. It also explains the omit-objects behavior for verifying the entire project and notes the projectPath requirement, leaving little to inference.

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