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

No annotations are provided, so the description carries the full burden. It does disclose one meaningful behavioral constraint: the tool should not invent runtime proof. However, it says nothing about whether the operation is read-only, what side effects exist, what happens with incomplete inputs, or how results are returned.

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

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

The description is a single sentence that front-loads the main action and includes a concise guardrail. It contains no filler or repetition, though the extreme brevity does contribute to the tool being under-specified 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 two undocumented object parameters, no annotations, no output schema, and a cluster of closely related sibling tools, the description is too thin for an agent to invoke the tool correctly. It explains the purpose but not the input structure, return value, or how it relates to similar tools.

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

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

The input schema has zero description coverage and the two parameters, 'stages' and 'statuses', are both untyped empty objects with no documentation. The description does not mention either parameter or explain what shape the nested objects should take, so it adds no semantic value 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 verb ('Score') and a clear resource ('the seven attribution lifecycle stages'), which makes the tool's core purpose understandable. The phrase 'without inventing runtime proof' adds a distinguishing behavior but does not explicitly contrast it with siblings such as validate_attribution_pipeline, so it stops short of full differentiation.

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

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

There is no guidance on when to use this tool versus alternatives like validate_attribution_pipeline or detect_attribution_gaps. The description implies it scores existing proof rather than creating it, but it never states explicit conditions, prerequisites, or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only names the calculation topic and does not state whether the operation is read-only, whether it writes or modifies anything, what the return value looks like, or how sessions are processed. This is a significant gap for a tool with no structured annotation safety hints.

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

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

A single, front-loaded sentence with no filler. It names the operation and the three coverage dimensions efficiently. Under-specification is a completeness issue, not a conciseness issue.

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 there is no output schema and no annotations, the description is too sparse to fully orient an agent. It does not describe the expected input shape, the computed result, or any edge cases. The tool may be callable, but an agent cannot confidently understand what coverage means or what a successful result looks like.

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

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

Schema description coverage is 0%, and the description never mentions the 'sessions' parameter. An agent is left without any explanation of what sessions should contain or how they relate to coverage calculation. The description provides no compensating parameter 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 states a specific verb ('calculate') and a specific resource ('coverage' across capture, persistence, and attachment). This is meaningful and helps distinguish it from sibling tools like diagnose_missing_click_ids or detect_attribution_gaps, though 'coverage' itself is somewhat abstract without a defined denominator.

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

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

Usage is implied: an agent would reasonably infer this tool is for computing coverage metrics. However, the description gives no explicit when-to-use or when-not-to-use guidance, and it does not contrast with nearby siblings such as verify_capture or validate_attribution_pipeline.

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, and 'Return' does imply a non-mutating, read-only operation. However, it does not disclose the shape of the returned schema, whether the allowlist includes deprecated or lifecycle-stage values, or any limitations. It is not misleading, but minimal.

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

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

One tight sentence that front-loads the verb and resource. There is no filler, repetition, or irrelevant detail.

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

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

For a parameterless informational tool, the description names what the tool returns, but with no output schema present it would benefit from a bit more context about the schema contents or typical use cases. It is adequate for a simple lookup tool but leaves the agent to guess what 'lifecycle schema' includes.

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

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

The tool has zero parameters, so schema coverage is trivially complete and the description need not explain param semantics. The baseline for a parameterless tool is 4, and no further parameter documentation is required.

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 ('Return') and a concrete resource ('canonical click ID allowlist and lifecycle schema'), making it clear this is a read-only metadata tool rather than a generator or validator. It is distinguishable from siblings like generate_nextjs_integration and validate_attribution_pipeline by its informational intent, though it does not explicitly call out that distinction.

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

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

The description gives no guidance on when to invoke this tool versus the many sibling tools such as validate_attribution_pipeline, diagnose_missing_click_ids, or generate_nextjs_integration. An agent must infer that fetching the canonical schema is a prerequisite or reference step, but the description does not state this.

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?

Without annotations, the description carries the behavioral disclosure burden. It does reveal a key behavior — explaining rather than querying a provider — but does not describe what the explanation contains, what side effects exist, or what happens with the provided eventId. The negative behavior is disclosed, but little else is.

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

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

The description is a single sentence with no filler and front-loads the core action. It is appropriately short, though the brevity comes at the cost of omitting input/output details that would make it more useful.

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 one parameter, no output schema, no annotations, and many sibling tools, the description is far too thin. It does not explain what the input should be, what the output looks like, or how this tool differs from related verification tools. An agent would struggle to invoke it correctly based on this definition alone.

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

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

Schema coverage is 0% and the description makes no mention of eventId at all. The agent cannot tell from the description what eventId means, why it is optional, or how it relates to verifying a conversion. The parameter is currently a bare string with no added semantic value.

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

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

The description states a clear action — explaining how to verify a conversion — and adds an important scoping detail: no provider querying is involved. It does not explicitly tie the action to the 'status' implied by the tool name or mention the eventId resource, so it is clear but not fully precise.

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 one contextual clue ('without querying a provider') but provides no explicit guidance on when to use this tool versus alternatives like verify_conversion_delivery or diagnose_missing_click_ids. It does not say when not to use it or name any sibling 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?

With no annotations, the description must disclose behavior, but it only says 'find', implying a read-only analysis. It does not state whether it modifies anything, what it returns, or how it interacts with the provided files/evidence/packageJson. The behavioral surface is underspecified.

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

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

The description is concise, but it is under-specified rather than appropriately concise. It delivers a single clause without structure or emphasis, and the lack of parameter context makes it feel incomplete rather than economical.

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 four parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain the input semantics, expected output, or how it relates to other attribution tools. An agent cannot reliably use this tool from the description alone.

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

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

Schema description coverage is 0%, so the description must explain the four parameters, but it mentions none. The agent has no idea what 'files', 'evidence', 'framework', or 'packageJson' mean for this tool, nor how they affect the search for gaps.

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

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

The description states a clear verb ('Find') and resource ('unproven or missing attribution lifecycle stages'), but it is vague about what constitutes a lifecycle stage and how this differs from siblings like validate_attribution_pipeline or diagnose_missing_click_ids. It does not reference the inputs (files, evidence, framework) that would clarify its scope.

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

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

No guidance is provided on when to use this tool versus the many related siblings. There are no exclusions, prerequisites, or context cues. An agent would have to guess which tool fits a given scenario.

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 of behavioral disclosure. 'Diagnose' implies a read-only analysis, but this is not explicit, and there is no mention of side effects, required permissions, or what the tool returns. The description is too sparse to be transparent about behavior.

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

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

The description is a single short sentence, which is concise, but it is so under-specified that it fails to earn its place. It provides almost no actionable information, so this is under-specification rather than good 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 a 5-parameter tool with a nested object and no output schema or annotations, the description is extremely incomplete. It explains neither the parameters' roles nor the expected result, leaving an agent unable to call the tool effectively.

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

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

Schema description coverage is 0% – the description mentions none of the five parameters, including the nested 'landingQuery' object. The schema itself only provides names and types, not meaning, and the description does nothing to compensate. An agent has no idea what 'safari', 'crossDomain', etc. mean for the diagnostic.

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 verb ('diagnose') and a resource ('click ID loss boundaries'), which is not a tautology, but 'boundaries' is vague and doesn't clarify what specific diagnostics are performed. It doesn't distinguish from siblings like 'detect_attribution_gaps' or 'validate_attribution_pipeline'.

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

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

No usage guidance is provided. There is no mention of when to use this tool versus alternatives, no prerequisites, and no context about the diagnostic workflow. The description gives no indication of when this tool is appropriate.

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 behavioral disclosure burden. It only says 'generate', implying creation, but does not disclose side effects, whether it modifies the project, requires consent configuration, or any operational implications. This is a significant gap for a code-generation 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?

The description is a single short sentence, so it is concise in word count. However, it is under-specified; the brevity comes at the cost of essential information. It is appropriately front-loaded but not substantive enough for a useful definition.

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 (code generation, likely side effects, no annotations, no output schema, one parameter), the description is severely incomplete. It fails to explain what 'consent-gated' means, what the integration entails, what the cookieName is for, or what the output looks like. An agent cannot reliably invoke this tool correctly with the current description.

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

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

Schema coverage is 0%, so the description should explain the cookieName parameter. It does not. While the parameter name is somewhat self-explanatory, the description adds no value about its purpose, format, or optionality. The pattern constraint is only in the schema, not elaborated in the description.

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

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

The description uses a clear verb ('Generate') and a specific resource ('consent-gated Next.js attribution integration'), which distinguishes it from the sibling generate_shopify_integration. However, it does not explicitly differentiate itself from other generation tools beyond the platform mention, so it's not a 5.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites, contexts where the Next.js integration is appropriate, or when to choose generate_shopify_integration instead. The agent is left to infer usage from the tool name alone.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It reveals only that the integration is 'consent-gated,' but does not describe side effects, output behavior, permissions, or what the generated integration entails beyond the phrase.

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

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

The description is a single, front-loaded sentence that economically communicates the core purpose. It is appropriately brief, though it sacrifices necessary usage and parameter detail.

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

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

Given no annotations, no output schema, and an undocumented parameter, the description is too thin for reliable agent use. It gives enough to know the integration type but not enough to know how to call it correctly or choose among generation siblings.

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

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

Schema description coverage is 0% and the description provides no explanation of eventName. The description adds no meaning to the single parameter, leaving the agent to infer semantics from the name 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 names a specific verb ('Generate') and a specific resource ('consent-gated Shopify Web Pixel and order webhook attribution integration'). This clearly distinguishes it from sibling generate_nextjs_integration by platform and integration type, even without explicitly naming the sibling.

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

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

There is no guidance about when to use this tool versus generate_nextjs_integration or other siblings. No prerequisites, scenarios, or exclusions are stated. The platform is implied by 'Shopify,' but no explicit routing guidance is provided.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not state whether the operation is read-only, whether it has side effects, what it returns, or any constraints. The tool presumably inspects a snapshot without mutation, but this is not explicit.

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

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

The description is a single, front-loaded sentence with no wasted words. It is concise and to the point, though it may be too brief for a tool with multiple parameters.

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

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

The tool has four parameters, nested objects, an enum, and no output schema. The description provides almost no context about what the tool does in detail, what inputs are expected, or what the result looks like. It is severely inadequate for an agent to call this 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 0%, and the description adds no meaning to any of the four parameters (files, tests, framework, packageJson). It only refers to a 'project snapshot' without explaining what each parameter represents or how they relate to attribution capabilities.

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 clear action (inspect) and resource (caller-provided project snapshot) with a specific goal (attribution capabilities). It is not a tautology and conveys the tool's function, but it does not distinguish it from sibling tools that also deal with attribution, such as diagnose_missing_click_ids or detect_attribution_gaps.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention any context, prerequisites, or exclusions, leaving the agent without direction on how to choose between this and the many related tools.

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

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

No annotations are provided, so the description carries the full burden. 'Evidence-aware' hints at some internal logic but doesn't disclose what it does with evidence, whether it mutates state, or what side effects (if any) it has. No mention of read-only nature, output format, or dependencies.

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

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

Single sentence, zero fluff, action verb front-loaded. Perfectly concise for the amount of content provided.

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 planning tool with no output schema and no annotations, the description is too sparse. It doesn't describe the structure of the plan, what 'evidence-aware' means in practice, or how the output relates to sibling generate tools. An agent would not know what to do with the result or how to verify it.

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

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

Schema coverage is 0%, so the description must compensate for the single parameter. It mentions 'framework-specific' but doesn't explain how each enum value (nextjs, node, shopify, generic) affects the plan or what the plan will include. The parameter meaning is only implied, not clarified.

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 (Create), a resource (installation plan), and qualifiers (framework-specific, evidence-aware). It implies a planning action distinct from the generate siblings, but doesn't explicitly name them or contrast with them.

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

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

No guidance on when to use this tool versus the generate_* siblings. It doesn't say 'use this before generating an integration' or list any prerequisites or alternatives. The agent must infer usage from the tool name 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 are provided, so the description carries the full burden of behavioral disclosure. It does not state whether the tool is read-only, whether it mutates records, what side effects may occur, or what the reconciliation output looks like.

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

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

The description is a single clear sentence with no filler. It is front-loaded with the verb and the primary resources, making it easy to parse, though it is minimal.

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

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

Given two undocumented array parameters, no annotations, and no output schema, the description is not sufficient for an agent to confidently call the tool. Missing details include input format, matching logic, return values, and any side effects.

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

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

Schema description coverage is 0%, and the properties 'crm' and 'crm' and 'destination' are only typed as arrays with no descriptions. The description loosely maps 'crm' to CRM conversions and 'destination' to destination conversion records, but it does not explain the expected structure, required fields, or how the two arrays relate.

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 ('Reconcile') and names the resources involved: CRM conversions and destination conversion records. It is clear enough to distinguish this from unrelated siblings, though it does not explicitly differentiate it from similar validation/diagnosis 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 no guidance on when to use this tool versus alternatives like validate_attribution_pipeline or detect_attribution_gaps. There are no explicit conditions, exclusions, or references to sibling tools, leaving usage largely to inference.

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

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

With no annotations, the description carries the burden of behavioral disclosure, and it does meaningfully state that no network side effects occur. However, it does not disclose what is returned, whether local state changes, or how errors are reported. Some important behavioral traits are still unspecified.

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

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

A single sentence with no filler. Both the purpose and the key side-effect constraint are front-loaded and every word contributes to scoping the tool.

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

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

The tool has five parameters, a nested object, and no output schema or annotations, so the description must carry more context. The minimal description omits the required eventId semantics, the structure of clickIds, the return value, and when this tool is preferable to send_sale or send_qualified_lead.

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

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

Schema description coverage is 0% and no parameter is explained in the description. The description does not add meaning for eventId, value, clickIds, currency, or eventName beyond their bare schema names, leaving the agent to guess their roles.

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 ('Build') and resource ('destination-neutral conversion payload'), and explicitly states the tool has no network side effects. This distinguishes it from sending/verifying siblings like send_sale, send_qualified_lead, and verify_conversion_delivery, making the tool's role 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?

The phrase 'destination-neutral' and 'without network side effects' imply this is for constructing a payload before sending, but there is no explicit when-to-use or when-not-to-use guidance and no named alternatives. The intended usage is reasonably clear but left to inference.

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 disclosure burden. It explicitly reveals a critical behavioral trait: the tool has no network side effects, which is non-obvious from the name 'send_qualified_lead'. It does not state whether the built payload is returned or persisted, but the core side-effect guarantee is clearly 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 a single front-loaded sentence with no filler; the verb and object come first and the side-effect qualifier is placed last. It is slightly too spare for a four-parameter tool with no schema descriptions, but it earns its place and is not padded.

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

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

Given the absence of annotations, no output schema, and four parameters including a nested object, the description is insufficient for correct invocation. It does not describe what the generated payload should look like, what valid inputs are, or how this relates to the send_* siblings beyond the side-effect hint.

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

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

Schema description coverage is 0% and the description adds no meaning to the four parameters (eventId, value, clickIds, currency). It does not explain the role of the required eventId, the structure of clickIds, or the format of value/currency, so an agent has no parameter-level guidance.

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

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

The description uses a specific verb ('Build') and a specific resource ('qualified lead conversion payload'), and the qualifier 'without network side effects' clearly distinguishes it from sibling tools like send_conversion and send_sale. It fully disambiguates from the send_* family.

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

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

The phrase 'without network side effects' implies this tool is for constructing a payload rather than delivering it, giving some contextual guidance. However, it never explicitly states when to prefer this over send_conversion/send_sale or when not to use it, leaving the routing to inference.

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 a key behavioral trait (no network side effects), which is valuable. However, it doesn't mention validation, return value, or error behavior. For a builder tool, that's a significant gap.

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

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

The description is one sentence, extremely concise, and front-loads the purpose. There is no fluff. However, it may be too sparse for the complexity, but that's a completeness issue, not conciseness.

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

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

Given 4 parameters (one required), no output schema, and no annotation, the description is far from complete. It doesn't explain the parameters, the return value, or any edge cases. An agent cannot correctly invoke this tool based solely on this description.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameters. It does not mention any of the four parameters (value, eventId, clickIds, currency) at all. The agent has no guidance on what these mean or how they relate to building the payload.

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

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

The description clearly states a specific verb ('build') and resource ('sale conversion payload'), and the phrase 'without network side effects' differentiates it from sibling tools like send_conversion that likely perform network sends. This is a clear, non-tautological statement.

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

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

The description implies usage: build a payload without sending. However, it doesn't explicitly name alternatives or state when to use this vs. send_conversion or send_qualified_lead. The 'without network side effects' hints at the use case but leaves the decision to the 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?

There are no annotations, so the description must carry the full behavioral burden. 'Simulate... locally' hints at a non-production, non-external operation, but the description does not disclose what the tool actually does with the 8 inputs, whether it returns output, what side effects it may have, or what 'journey' entails.

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

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

The description is a single sentence with no wasted words and the verb is front-loaded. However, for an 8-parameter tool with no annotations and no output schema, one sentence is under-specified rather than appropriately concise.

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

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

This description is far from complete given the tool's complexity: 8 parameters with 0% schema coverage, nested objects, no annotations, and no output schema. There is no guidance on behavior, parameter relationships, expected result, or prerequisites. An agent would lack the information needed to invoke it correctly.

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

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

Schema description coverage is 0% and none of the 8 parameters (url, leadId, consent, formFields, eventId, orderId, accountId, redirectPreservesQuery) is mentioned or explained. The description adds zero meaning beyond the parameter names, leaving agents with no help understanding 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 a specific action ('Simulate') and a concrete object ('a synthetic click-to-account attribution journey'), which makes it distinctive from diagnosis and validation siblings. The key word 'locally' adds useful scoping to the purpose, though the meaning of 'journey' is a bit abstract.

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 no guidance about when to use this tool versus alternatives like validate_attribution_pipeline, capture_click_id_schema, or diagnose_missing_click_ids. It only implies local simulation or testing, with no explicit conditions or exclusions.

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

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

No annotations are provided, so the description must disclose behavioral traits. It does not state whether the operation is read-only, whether it mutates any data, what happens on validation failure, or what the return format is. The term 'validate' implies a check, but the absence of explicit side-effect information is a significant gap for an unannotated 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?

The description is a single short sentence, which is concise but under-specified. It is not front-loaded with the most critical information (e.g., required parameters or side effects). While brevity is good, the extreme lack of content makes it inadequate.

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 four parameters, nested objects, no output schema, and no annotations, the description must be comprehensive to guide correct usage. It offers only a vague statement about validation, leaving critical details like input structure, expected behavior, and error handling entirely unaddressed. This is highly inadequate for a tool of this complexity.

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

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

Schema description coverage is 0%, and the description provides no information about any of the four parameters (eventId, stages, consent, clickIds). The agent receives no guidance on what these parameters mean, how they relate, or how to populate them. The description completely fails to compensate for the lack of 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 ('validate') and resource ('declared attribution lifecycle stages and consent'), which is clear enough to convey the general purpose. However, it does not explain what 'validate' entails (e.g., consistency checks, data format validation) or how it differs from sibling tools like 'diagnose_missing_click_ids' or 'detect_attribution_gaps'. It is not a tautology but lacks specificity.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention any conditions, prerequisites, or exclusions. It simply states the action without context, leaving the agent to infer the appropriate scenario.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. The description only states the tool's purpose; it does not say whether the tool compares expectedClickId with captured values, what it returns, whether it throws errors, or whether it has side effects. This is a significant transparency gap for an unannotated 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?

The description is a single front-loaded sentence with no unnecessary words. It efficiently conveys the core purpose and the consent-related context without padding 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 tool has four parameters, nested objects, no output schema, and no annotations, the description is too minimal to be a complete guide for correct invocation. It does not explain the verification semantics, the expected shape of captured, the role of the key enum, or what outcome an agent should expect.

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

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

Schema description coverage is 0%, so the description must compensate for missing parameter documentation. Although the parameter names such as expectedClickId and captured are self-explanatory, the description does not explain how these parameters relate to each other, what type captured should be, or how consent and key factor into the verification logic.

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: verifying that a click ID was captured intact after consent. It clearly differentiates this from sibling verification tools like verify_conversion_delivery and verify_crm_attachment by focusing on the click ID capture itself, though it does not name those alternatives explicitly.

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

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

The phrase 'after consent' gives a hint about when the tool is relevant, placing it in the post-consent capture flow, but there is no explicit guidance about when to prefer this tool over the many similar verification and diagnosis siblings. No alternatives are named and no exclusion conditions are stated.

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

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

With no annotations, the description carries the behavioral disclosure burden. It does disclose a meaningful behavior—returning unknown when no explicit receipt is available—but it does not clarify possible classifications, error behavior, or whether any side effects occur.

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 entire description is one efficient, front-loaded sentence. It communicates the operation, the input condition, and the fallback result with no wasted words.

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

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

There is no output schema, so the description should specify what classification values or return shapes the agent can expect. It only mentions the 'unknown' fallback, leaving the main delivery classifications and any error conditions undescribed.

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

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

The schema has one undocumented nested object parameter, providerReceipt, and schema description coverage is 0%. The description only hints at it via 'explicit receipt' without explaining the required shape or fields, leaving the agent to guess what a valid receipt must contain.

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 ('Classify') and a specific resource ('provider delivery'), and it identifies the input source as an explicit receipt. The fallback 'or return unknown' adds scope, though it does not explicitly contrast with sibling tools like check_conversion_status.

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

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

There is no guidance on when to prefer this tool over alternatives such as check_conversion_status or verify_capture. The phrase 'from an explicit receipt' implies a precondition, but no explicit when-to-use or when-not-to-use information is provided.

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

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

No annotations are provided, so the description carries the full burden. It only states the purpose without disclosing whether this is read-only, what side effects exist, authentication needs, or what happens if verification fails. 'Verify' hints at a non-destructive check, but the agent is left to assume.

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

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

A single sentence with zero fluff or redundancy. The core action is front-loaded. However, it is too terse to be fully useful, but that is a completeness issue, not a conciseness failure.

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

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

The tool has nested object parameters, no output schema, no annotations, and no parameter descriptions. The description provides only a one-line purpose with no information on required input structure, behavior, or return values. It is inadequate for a tool of this complexity.

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

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

Schema description coverage is 0%, so the description must compensate. It does not explain the meaning or structure of the two required parameters ('expected' and 'record') at all. An agent cannot infer what values to provide or how they relate to the verification process.

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 ('Verify') and resource ('attribution reached a CRM/account record'). Distinguishes from similar siblings like verify_form_attachment, verify_capture, and verify_conversion_delivery by targeting CRM records. Not a tautology, though 'attribution' is somewhat vague.

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

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

No guidance on when to use this tool instead of alternatives such as verify_conversion_delivery or reconcile_conversions. The name implies a verification use case, but no context or exclusions are provided.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the purpose ('Verify that attribution was copied into form fields') but says nothing about return values, error behavior, side effects, prerequisites, or what happens on success/failure. This is a significant gap for a verification 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?

The description is extremely concise (one sentence), which is superficially efficient, but it under-specifies the tool. The brevity is not 'appropriate' because it omits essential details; it resembles an under-specification rather than effective conciseness.

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

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

The tool has nested object parameters, no output schema, and no annotations. The description is completely inadequate for an agent to understand how to call it correctly, what inputs are expected, or what the tool returns. It lacks even basic context about the verification process.

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

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

The schema has 0% description coverage for its three parameters (fields, attribution, requiredKeys), and the description does not mention any of them. There is no explanation of what each parameter represents, their format, or their role in verification, leaving the agent unable to construct valid inputs.

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 (verify) and a specific target (attribution copied into form fields), which gives some clarity about the tool's function. However, it does not differentiate from sibling verify_* tools like verify_capture or verify_crm_attachment; the reference to 'form fields' provides partial distinction but leaves ambiguity about what 'attribution' encompasses.

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

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

There is no guidance on when to use this tool versus the many sibling tools (e.g., verify_capture, verify_conversion_delivery). No conditions, alternatives, or exclusions are provided, leaving the agent to infer the appropriate context without support.

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