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

The description adds value by specifying the functional outcome: 'remove it from active customer operations.' This is behavioral context, though the critical risks (destructive, non-idempotent) are already handled by 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, concise sentence that front-loads the action and the consequence without unnecessary 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 that it is a simple 1-parameter mutation tool and annotations cover the high-level risks, the description provides enough information for an agent to select it confidently. Missing operational context, however, 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?

Since schema coverage is 100%, the description's role is to add semantics. It merely reiterates that the input is the 'AttriKit app id,' which is already specified in the input schema description. Baseline score applies due to high coverage.

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

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

The description clearly defines the action as 'Archive' and specifies the resource (an app), which helps differentiate it from simple deletion tools like delete_integration. However, it does not provide strong context distinguishing 'archive' from 'soft-delete' versus 'hard-delete'.

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

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

The description offers no guidance on when to use this tool in a workflow, such as business justification for archiving. It lacks comparison or context regarding other state changes like deactivation or retirement.

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 general hints (destructive, read-write), the description specifies exactly what configuration secrets are managed. It adds functional context regarding the persistence of the `signing_secret` when omitted, which is a specific operational trait.

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

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

The description is a single, dense sentence that is perfectly sized and front-loaded. Every word contributes to defining the tool's scope and behavior.

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 rich annotations and detailed input schema, the description provides excellent coverage, defining the target of configuration and the logic behind key optional fields.

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

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

The description explains the purpose of three of the five key parameters (provider app id, authorization secret, and webhook signing secret), adding semantic value beyond the basic strings defined in the input 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 action (Store/Configure) and the resource (RevenueCat provider app ID, authorization secret). It is highly specific and easily distinguishable from sibling tools like get_revenuecat or create_integration.

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

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

It provides clear conditional guidance on the `signing_secret` parameter: if it is omitted, the currently stored secret will be maintained. This directs usage for that specific field.

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 readOnly=false, idempotent=false, and destructive=false, so the safety profile is covered. The description adds a genuinely important trait beyond that: the secret is returned only once, which tells the agent to capture it immediately. It omits that retries are non-idempotent and that idempotency_key exists for safe retry.

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 short sentences, front-loaded with the action and the key behavioral caveat. Nothing 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?

With no output schema, the description should say more about the response than just the secret. It does not mention the returned key id/label or the non-idempotent retry behavior, leaving gaps for a mutation tool.

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

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

Schema coverage is only 25%, so the description must compensate. It does explain the scopes parameter (read-only vs read/write) and implies app_id via 'workspace or app key', but says nothing about label or idempotency_key beyond the schema's own note.

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) and resource (workspace or app key) with the read-only vs read/write distinction, which separates it from rotate_publishable_key and list_api_keys. It does not explicitly name a sibling, so it stops short of 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?

There is no statement of when to use this versus rotate_publishable_key, get_publishable_key, or list_api_keys, and no prerequisites or exclusions. The read-only/read-write phrasing hints at a choice but gives no guidance on selecting it.

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

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

The description adds real value beyond the annotations by disclosing the return payload: a publishable key plus a one-time app-scoped management key, which signals that a secret is issued and will not be retrievable later. That is a meaningful behavioral fact an agent needs. It does not, however, cover error behavior or permission requirements, which keeps it from a 5.

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

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

Two sentences, zero waste, with the purpose front-loaded and the return contract second. Nothing is padded or restated.

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 mutation with 4 required fields and no output schema, the description covers the return shape but leaves most required inputs and the meaning of store_url/bundle_id unexplained. It is adequate to identify the tool but thin for correct invocation.

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

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

Schema description coverage is only 14%, so the description must compensate and it largely does not. It only echoes the platform enum ('iOS or Android') and says nothing about required inputs like bundle_id format, store_url, timezone, or the device_matching_mode/idempotency_key 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 gives a specific verb and resource (create an app) and narrows it to the iOS/Android platform scope, plus notes it is the programmatic path ('without the web UI'). It is clear against siblings like update_app and archive_app, though it does not explicitly name any alternative.

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?

'Without the web UI' implies the intended context (API-driven provisioning) but the description never states prerequisites, when to prefer this over other flows, or what to do on retry. Usage is inferred rather than guided.

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 the write/open-world/non-destructive profile, and the description adds real value on top: an auth requirement and a detailed disclosure of the return shape, including exactly when tracking_url is null. It stops short of mentioning rate limits, retry behavior, or that the operation creates a persistent server-side resource, which keeps it from a 5.

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?

Front-loaded with the purpose in the first sentence, then the auth requirement, then the return semantics. The long parenthetical enumerating meta/tiktok/google placement is dense but earns its space by preventing a common misuse; only the nested clause structure costs it a point.

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

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

There is no output schema, and the description compensates fully by explaining both returned fields, their distinction, and the null case. Combined with a fully documented 8-parameter schema, an agent has everything needed to call this correctly and interpret the result.

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

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

Schema coverage is 100%, so baseline would be 3, but the description adds genuine meaning by clarifying that `url` is only the App Store destination the caller passed — pinning down what destination_url actually represents — and by mapping network values to where the tracking_url belongs in each ad platform.

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: 'Create a web-to-app tracking link for an ad campaign.' The scope (campaign link, not a general link) is clear enough that an agent can distinguish it from list_links or update_link_status, though no sibling is named 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?

Gives a concrete prerequisite ('Requires a write-scoped API key') and a fallback path when the server cannot produce a link ('then create the link in AttriKit, Links'). It does not state exclusions against siblings such as list_links, but the context for when this tool applies is unambiguous.

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 cover the safety profile (mutating, open-world, non-idempotent, non-destructive), and the description adds real behavioral context: AttriKit always sends, source selection silently drops the other copy, renewal_event and delivery_scope defaults, and that Google rejects 'custom'/'attributed'. It does not explain idempotency-key/retry behavior or failure modes (invalid credentials, all-eight requirement is only in the schema), leaving some gaps.

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

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

Front-loads the core action and then unpacks the tricky event-routing semantics; dense but nearly every sentence informs configuration. Slightly long, but the length is justified by genuinely ambiguous routing behavior.

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

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

For an 8-parameter mutating tool with a nested object and no output schema, the description is thorough on the hardest decisions (source selection, defaults, network-specific rejections). It omits credential format, the all-eight-families requirement (only in schema), and idempotency behavior, but is otherwise sufficient to call 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?

With 50% schema coverage, the description carries much of the load, thoroughly defining the attrkit/revenuecat/customer source semantics, the per-family drop rules, and the default behavior of delivery_scope and renewal_event. It leaves network, account_ref, credential, enable and idempotency_key unexplained, so it doesn't fully compensate for the coverage gap.

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 — store encrypted network credentials and choose, per event family, which source's copy is forwarded. It clearly distinguishes this act (creating/seeding an integration's routing) from siblings like update_integration, delete_integration and configure_revenuecat by explaining AttriKit does the sending while the owner only picks the copy.

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?

Gives strong conditional guidance, e.g. 'If your app reports subscriptions only through RevenueCat, set trial, subscription, purchase and refund to revenuecat, or none of them reach the network,' and notes Meta/TikTok optionality. It does not, however, explicitly route an agent to update_integration for modifying an existing integration or state prerequisites/alternatives among siblings, so it stops short of full when/when-not guidance.

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

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

Annotations already declare the mutation profile (readOnly=false, destructive=false, idempotent=false, openWorld=true). The description adds two genuinely useful facts not in the annotations: the URL is SSRF-validated (internal addresses will be rejected) and the signing secret is returned only once and cannot be re-fetched. It stops short of explaining idempotency_key behavior or failure modes.

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

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

Two sentences, front-loaded with the action and the highest-risk behavior (one-time secret). Nothing 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?

It covers the two highest-stakes facts (SSRF validation, one-time secret), but with 5 params at 20% coverage and no output schema, an agent still lacks guidance on app_id scoping, event_types selection, and what the response contains besides the secret.

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

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

Schema description coverage is only 20% — just idempotency_key is documented. The description does not explain url, app_id, description, or event_types, and only obliquely signals that url is validated. With 5 params and low coverage, the description should compensate and does not.

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+resource ("Create ... webhook subscription") and adds a qualifier (SSRF-checked). It is obviously distinct from list_webhooks/delete_webhook, though it never names them 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?

There is no statement of when to use this versus list_webhooks/delete_webhook, nor any prerequisite (e.g. required scopes, whether an app must exist first). Only the implicit "create" semantics convey usage.

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

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

Annotations already declare destructive=true, idempotent=false, and readOnly=false. The description adds useful behavioral context by stating the disabled-state precondition, but it does not explain what data or side effects accompany deletion.

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 definition is two short sentences with the core action and prerequisite front-loaded. There is no redundant or low-value text.

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

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

Annotations cover the destructive safety profile and the description covers the disabled precondition, but the lone required parameter remains unexplained and the description does not clarify deletion effects. For a destructive mutation tool, this is adequate but incomplete.

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

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

The schema has 0% description coverage and one required parameter, connection_id. The description never mentions connection_id or clarifies whether it is an integration ID, connection ID, or external network identifier, so parameter meaning is only weakly implied.

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: 'Delete ... integration.' It clearly differs from create/list/update siblings by naming deletion, though it does not explicitly distinguish ad-network scope or name alternatives.

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

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

It provides a clear usage condition and prerequisite: only disabled integrations can be deleted, and enabled ones must be disabled first. It does not name the mechanism or tool for disabling, so an agent must infer the next step.

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 destructiveHint=true, idempotentHint=false, and openWorldHint=true, so the safety profile is known from structured data. The description adds nothing beyond that: it doesn't say whether deletion is permanent, what happens to queued deliveries or delivery history, or whether re-deleting errors out.

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?

It is a single short, front-loaded sentence with no filler, but that brevity comes from under-specification rather than efficiency—the one sentence adds almost no information.

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

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

For a destructive, non-idempotent mutation with no output schema and an undocumented parameter, the description should cover irreversibility, side effects, and how to supply the id. None of that is present.

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

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

Schema description coverage is 0% and the single parameter subscription_id is documented only by its UUID format and pattern. The description never mentions the identifier, where to obtain it, or that it is required, so it fails to compensate for the coverage gap.

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 sentence only restates the tool name and title ("Delete" + "webhook subscription") with no additional scope, effect, or distinguishing detail. It does not separate this from siblings like list_webhooks or create_webhook beyond the obvious verb.

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 versus list_webhooks (to find the id), create_webhook, or any alternative removal path. No preconditions, no note about what to do if the subscription doesn't exist.

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 that this is a safe, read-only, idempotent export, and the description adds important behavior beyond them: row-cap semantics, ordering, paging, default limit, next_cursor protocol, and format-specific return content. 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 front-loaded with the core action and then explains version-specific behavior. It is dense but generally earns its space, covering defaults, cap risk, formats, and pagination without obvious 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?

Because there is no output schema, the description needs to explain return behavior, and it does: version 1 yields a seven-column CSV capped at 100,000 recent in-range rows, while version 2 yields wide records with campaign, ad, evidence, and revenue columns in csv or ndjson, oldest first, with pagination. That is sufficient for an agent to call and paginate the tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaningful protocol semantics beyond the schema. It explains that limit, format, and cursor are version-2-only, that cursor must be sent back with the same app_id, from, and to, and that absence of next_cursor means the final page.

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 resources: export one app's events and installs over an inclusive date range. It clearly distinguishes version 1 CSV behavior from version 2 wide-record paged behavior. It does not explicitly distinguish this bulk export from sibling listing tools such as list_recent_events or list_event_deliveries.

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

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

It gives clear usage context: version 1 is the default seven-column CSV with a 100,000-row cap, and version 2 is for wide records with format, limit, and cursor. It also advises narrowing the date range when a complete snapshot is required. It does not state when to choose this over sibling listing or delivery 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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds no behavioral context such as authentication needs, missing-app behavior, or what "configuration" includes.

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 is appropriately sized for a simple getter, even if it is terse.

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

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

The tool is simple and annotations plus schema cover much of the contract. However, with no output schema, the description does not characterize the returned configuration or failure modes, leaving a meaningful 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 description coverage is 100%, and app_id is documented as "The AttriKit app id." The description adds no additional meaning beyond the schema, so the baseline of 3 applies.

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: "Return one app's configuration." The singular "one app" distinguishes it from list_apps, though it does not explicitly name that sibling or clarify 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?

Provides no explicit when-to-use guidance, no exclusions, and no mention of list_apps as the alternative for enumerating apps. Usage is only implied by the singular resource.

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 readOnly, idempotent, non-destructive and openWorld, so safety is covered. The description adds real value by disclosing the response contents (evidence-class breakdown, MER, revenue) and surfacing 'data freshness' as a returned signal, which matters for a metrics rollup. It does not mention rate limits or the default window 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?

One sentence, front-loaded with the verb and scope, with the payload enumerated compactly. Nothing is redundant with the title or schema.

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's enumeration of returned metrics is the right thing to include and it does so. Minor gaps remain: 'MER' is unexplained and the default reporting window (when period is omitted) is deferred entirely to the 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% and every parameter is documented there, including the period/from-to 400 conflict and the enum values. The description adds no parameter-level meaning beyond the schema, so the baseline of 3 applies.

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?

A specific verb ('Return') plus a precisely scoped resource ('account-level attribution overview'), followed by an enumeration of the payload (evidence-class installs, MER, revenue, data freshness). The 'account-level' framing implicitly separates it from the sibling lookup_customer_attribution, which is per-customer.

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 only implied: 'account-level' suggests this is the rollup view rather than a per-customer lookup, but the description never names an alternative or states when to prefer this over lookup_customer_attribution. It also says nothing about choosing between period and from/to, leaving the schema's mutual-exclusion note to carry that.

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?

This is a high-scoring area because it provides critical agent instructions. Specifically, telling the AI to 'Report the `call` VERBATIM — do not recompute or override it; when it says not_enough_data, say so' dictates complex processing rules that metadata alone cannot 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 highly efficient. It front-loads the main value proposition and immediately follows with the essential operational rules (verbatim reporting/handling missing data), resulting in zero wasted words.

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

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

Given that this is an automation tool, the description's behavioral transparency (how to report the call and handle edge cases) makes it fully complete for an agent seeking to utilize this specific feature.

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 description coverage is 100%, meaning the schema handles the technical details of parameters. The description provides valuable high-level context by stating these decisions are 'computed by the attribution engine,' which supports the data's origin without repeating schema details. This meets the baseline for full schema coverage.

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

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

The purpose is exceptionally clear: to return AttriKit's profit decisions (scale/cut/hold call and confidence). This clearly distinguishes it from generic list or retrieve campaign tools in the sibling set.

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 states the intended use case ('This is the tool to drive budget automation'). While it doesn't name specific alternatives, the highly specialized function is clear enough to define its primary role relative to general campaign data retrieval.

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, idempotentHint=true, destructiveHint=false, so the safety profile is covered. The description adds one meaningful signal beyond them: "recoverable" implies the key can be retrieved repeatedly and is not a one-time secret display. It does not note that the return is sensitive credential material that should not be logged or exposed client-side-inappropriately.

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; the object of the operation comes before the qualifier. It is tight, though the brevity leaves the differentiation and sensitivity notes that would make the sentence fully earn its place.

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

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

This is a simple one-parameter read tool with no output schema, so the description does not need to enumerate fields. Still missing is what an agent gets back (a plaintext key string) and whether it is safe to embed in a client SDK, which matters for a credential-retrieval tool that feeds directly into SDK configuration.

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?

Only one parameter is declared (app_id) at 100% schema description coverage, so the schema already carries the semantics. The description adds nothing about the parameter, such as whether a non-existent or archived app id yields an error, which is the baseline-3 outcome for a fully documented 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?

Uses a specific verb ("Reveal") plus a specific resource ("SDK publishable key for an app"), which is enough for an agent to distinguish it from most siblings. However, the closest sibling rotate_publishable_key is not named, so the read-vs-rotate distinction is left implicit in the word "recoverable".

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 only implied: an agent can infer this is the read path used when a publishable key needs to be fetched. There is no explicit statement of when to use this versus rotate_publishable_key, nor any prerequisites (app ownership, permissions) for the call.

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, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds useful context that the returned status is redacted and includes the AttriKit webhook URL, but it does not mention authentication or external-call 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, front-loaded sentence with no wasted words. It states the return content directly and efficiently.

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

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

For a simple read-only getter with one fully documented parameter and annotations covering safety, the description is largely complete. It states what is returned, though it does not describe the response structure, which is acceptable given there is 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%, and the single app_id parameter is documented in the schema. The description adds no additional meaning about the parameter, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb, "Return," and names the resources: RevenueCat status and the AttriKit webhook URL. It is clear what the tool retrieves, though it does not explicitly distinguish itself from the sibling configure_revenuecat 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 no explicit guidance on when to use this tool versus alternatives such as configure_revenuecat or list_webhooks. Usage is only implied by the read-oriented wording.

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 readOnly, idempotent, non-destructive and openWorld, so the safety profile is covered. The description adds behavior the annotations cannot convey: full-dump versus paged semantics, the ordering key (network, campaign, ad set, ad, day), and that next_cursor is null on the last page — all directly useful for correct invocation.

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

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

Two sentences, front-loaded with the resource list, then the paging contract. Every clause carries information (trigger, ordering, terminal cursor), though the second sentence packs several distinct rules into one dense chain and would scan better split.

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 carries the return-shape burden and does so for the important parts: the four data categories returned, the row ordering, and the next_cursor pagination contract. Minor gaps remain — no mention of auth/scope requirements or row-volume limits for the unpaged path.

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 earns above baseline by documenting the cross-parameter rule — any of from, to or cursor turns on paging — which the schema only states per-parameter ('alone it changes nothing') and never as a combined trigger.

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 ('Return') and enumerates the resources returned: imported ad spend, cost models, completeness and spend freshness. An agent can tell it is a read tool over spend data, but nothing in the text distinguishes it from siblings like import_spend, pull_network_spend, set_cost_model or get_attribution_rollup.

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 explains the operational condition that selects full-dump mode versus paged mode ('without from, to or cursor every row comes back at once'), which is real usage guidance. However, it never says when to reach for this tool rather than import_spend, pull_network_spend or get_attribution_rollup, so the choice between siblings is 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint. The description adds useful context beyond that by naming the required workspace-scoped read key and enumerating the returned billing data.

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?

It is a single efficient sentence that front-loads the core action and then lists the returned data, ending with the key prerequisite. There is no wasted text.

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

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

With no parameters, no output schema, and rich annotations, the description provides enough detail by enumerating the values returned and stating the auth requirement. Nothing essential for correct invocation 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?

There are zero parameters, so the baseline is 4. The description does not need to clarify parameter semantics and appropriately focuses on returned information.

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, 'Return', and a clear resource, the workspace's monthly qualified-install cap, alert email, billing period, and usage. It implicitly contrasts with set_usage_cap through its read-only wording, but it does not explicitly name that 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?

It states the authentication prerequisite but gives no explicit when-to-use guidance, exclusions, or alternative such as set_usage_cap for changing the cap. The read-only use case is inferable, but the description leaves 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?

Annotations only flag this as a non-destructive, non-idempotent, open-world write. The description adds nothing about the behavior that matters most for a spend import: whether rows for an overlapping date range are replaced, merged, or appended, and what happens on partial failure of a batch. It also omits the 5,000-row ceiling and the covers_from/covers_to range contract.

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 clean, front-loaded sentence with zero padding, which is fine structurally, but at this length the brevity is under-specification rather than economy. There is no wasted word, yet almost no word that does real work either.

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 12-parameter, 6-required batch-mutation tool with no output schema and near-zero schema description coverage, one sentence leaves the agent without what it needs to call this correctly. The reader learns the resource but not the date-range contract, the currency/network constraints, or the retry semantics.

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

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

Schema description coverage is only 17% across 12 parameters, so the description carries the burden and does essentially nothing — it neither explains the six required date/currency/range fields nor the partial-vs-final 'completeness' enum, the 'source' enum, or the retry-only 'idempotency_key'. Its single clause about campaign/creative level is the only parameter-adjacent signal it contributes.

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: import spend rows at campaign or creative granularity. An agent can grasp what the tool does, but the description never distinguishes it from the sibling 'pull_network_spend' (which fetches spend from the network rather than pushing rows in), so the boundary requires opening the schema to infer.

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 when-to-use guidance, no prerequisites, no exclusions. The high-value context — that campaign_id must be an AttriKit campaign UUID read from list_campaigns rather than a network id, and that the idempotency_key exists for safe retries — is buried in the schema or absent entirely, never surfaced in the description.

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 read-only, idempotent, non-destructive, open-world behavior, so safety is covered. The description adds only a list of output metrics and does not disclose pagination behavior, default windows, rate limits, or how date-range and period parameters interact.

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 compact sentence with no wasted text and leads directly with the primary return value. However, terms like 'evidence tiers' and 'modeled remainders' are not clarified, which slightly reduces clarity in such a terse statement.

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 list tool with no output schema, the description gives a high-level indication of returned metrics but does not explain row granularity, pagination, or response structure. The high schema coverage compensates for filter documentation, but an agent still lacks full context on what a response contains.

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 83%, so the schema already documents most parameters in detail, including the from/to versus period conflict and cursor pagination. The description adds no parameter-specific meaning beyond what the schema provides, making the baseline 3 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 a specific verb and resource: returning ad and ad-set performance metrics including ROAS, CPA, CPC, and related values. It is distinguishable from generic campaign or spend tools, though it does not explicitly differentiate itself from siblings such as list_campaigns or get_spend.

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

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

There is no explicit guidance on when to use this tool versus alternatives. The only implied usage is performance reporting, but no conditions, prerequisites, or sibling routing 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so safety is covered. The description adds genuinely new behavioral context beyond that: results are masked and plaintext secrets are never exposed, which sets expectations for what the caller can and cannot retrieve.

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 short sentences with no waste; the scope (workspace and app keys) is front-loaded before the security caveat. Every clause earns its place.

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

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

For a no-parameter read tool with no output schema, the description covers scope and the masked/secret guarantee, which is what an agent most needs. Minor gaps remain around result shape (fields per key) and whether pagination applies.

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 takes zero parameters, so there is nothing to document and the baseline of 4 applies. The description correctly does not invent parameter discussion.

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 (List) and resource (workspace and app management keys), and adds the qualifier 'masked' which clarifies the returned representation. It is clearly distinguishable from create_api_key, revoke_api_key, and rotate_publishable_key, though it never names those siblings 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?

Usage is implied by the verb — an agent can infer this is the tool for inspecting existing management keys. However, there is no explicit when-to-use versus get_publishable_key or list_apps, and no note about ordering, pagination, or result limits.

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, idempotentHint, destructiveHint=false, and openWorldHint, so safety behavior is covered. The description adds useful return-field context (id, name, platform, bundle id, store id, status) in the absence of an output schema, but says nothing beyond that about paging, limits, or auth.

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 definition is a single front-loaded sentence with no filler. The parenthetical field list is a slight density addition but earns its place given there is no output schema.

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

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

For a simple read-only listing tool, this is nearly complete: annotations cover safety, schema covers parameters, and the description covers returned fields. The only small gap is that paging behavior is left entirely to the schema rather than reinforced in the 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 100%, and both parameters have clear inline documentation covering ranges and cursor usage. The description adds no parameter-specific meaning, so the baseline of 3 is appropriate.

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

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

The description gives a specific verb (list) and resource (iOS and Android apps in the workspace) and enumerates the returned fields. It does not explicitly distinguish itself from sibling get_app or clarify list-all vs. filtered lookup, so it falls short of 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?

Usage is only implied: an agent can infer this is the way to enumerate all apps, but the description never says when to use this instead of get_app, nor does it mention prerequisites or workspace scoping. No explicit alternatives or exclusions are given.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description goes well beyond them: it distinguishes `call` vs `recommended_call`, explains what backs the recommendation, and warns that quantile-named fields are null unless a calibrated component supplied them. That is substantive behavioral context, short only of return format/pagination detail.

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?

Front-loads the purpose and is dense but nearly every sentence carries field-semantics value; the trailing 'spend, retention, and payback' clause is somewhat tacked on but still informative. Jargon density (envelope_lower, marginal_endpoint_sum_no_joint_coverage) is heavy but tied to real field names.

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

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

With no output schema, the description must explain return values, and it does so thoroughly for the headline profit/envelope fields and their caveats. It omits broader response shape and pagination behavior, which the schema partially covers, so it is strong but not exhaustive.

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 all six parameters (from/to/period/limit/cursor/app_id) are already documented in the schema, including mutual-exclusion of period vs from/to. The description adds nothing about parameters, so baseline 3 applies.

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 ('List ad campaigns') plus a distinctive scope ('honest profit surface'), which is more than a tautology. It does not, however, differentiate itself from siblings like list_ads or get_campaign_decision, so the agent must infer the boundary.

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?

Offers real guidance on interpreting the return (read aggregation_basis before quoting the low end; describe as a scenario when marginal_endpoint_sum_no_joint_coverage), but gives no explicit when-to-use versus alternatives and no selection criteria against sibling listing/decision 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?

Annotations already declare readOnly/idempotent/non-destructive, and the description adds real context on top: newest-first ordering, the full delivery state lifecycle including a transient 'held' state with an expected release time, representative suppression reasons (consent_suppressed, destination_event_too_old), and the auth scope required. That is exactly the extra behavior an agent needs beyond the 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?

Front-loaded with the return shape and grain, then the diagnostic use case and auth note in two short sentences. Slightly dense, and the enumerated state list partially duplicates the state enum already in the schema, 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?

With no output schema, the description carries the full burden of describing return values and it does so concretely (state, reason, attempts, last HTTP status, held-release time). Combined with 100% schema coverage on 10 parameters, an agent has everything needed to call and interpret 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 description coverage is 100%, so every one of the 10 parameters is already documented in the schema, including cursor paging, limit bounds and the state enum. The description adds no parameter-level detail (no interaction between from/to, no default for network), so the baseline of 3 applies.

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 precise verb and resource ('return one row per delivery of an event to a network connection') plus the row grain, ordering and returned fields. An agent can distinguish this per-delivery view from aggregate/feed siblings like list_recent_events or export_events without opening 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?

Explicitly frames the use case: 'Use it to answer why an event did not reach Meta, TikTok or Google', and adds a scope prerequisite ('Read scope is enough'). It does not name the competing sibling tools (list_recent_events, export_events) or say when not to use it, so it falls short of a 5.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true, and destructiveHint=false, covering the safety and idempotency profile. The description adds meaningful context by noting results are 'redacted' and include 'readiness,' but does not describe pagination, return shape, or whether any filters are supported.

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 tight sentence with zero waste. The key qualifiers ('redacted' and 'readiness') are front-loaded and immediately informative.

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

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

With no parameters and no output schema, the description gives a concise but sufficient picture of what the tool returns: redacted ad-network connections and their readiness. It could go slightly further by clarifying whether any filters or pagination exist, but for a simple list tool this is nearly complete.

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

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

The tool takes zero parameters, so there are no parameter semantics to clarify. The description appropriately stays high-level. A baseline of 4 applies for a parameterless tool with an empty 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 (List) and resource (ad-network connections), and adds two useful qualifiers: results are redacted and include readiness state. It is clear what the tool does, though it doesn't explicitly contrast itself with sibling integration tools like get_app or create_integration.

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

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

There is no explicit guidance on when to use this tool versus alternatives. An agent must infer from the name and sibling list that this is the read-only listing counterpart to create/update/delete_integration. No prerequisites, exclusions, or alternative-tool mentions 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?

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds genuine value by explaining what the returned fields mean (tracking_url is the ad-facing campaign link, null if unavailable; url is the store destination), but it says nothing about pagination behavior despite a limit/cursor pair existing.

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 short sentences, front-loaded with the action and scope, then immediately clarifying the two easily confused return fields. No filler.

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

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

With no output schema, the description takes on return-value explanation and does so for the two most confusable fields. The remaining gap is pagination: an agent must discover limit/cursor behavior on its own.

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

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

Schema description coverage is only 33% – app_id is documented but limit and cursor are not. The description only echoes the app-scoping idea already present in the schema and gives no guidance on page size or cursor usage, so it fails to compensate for the coverage gap.

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 ('List tracking links') plus an optional scope ('optionally for one app'), which is enough to separate it from the mutating siblings create_campaign_link and update_link_status. It does not explicitly name those siblings, so it stops short of 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?

'Optionally for one app' implies when to pass app_id, but there is no explicit statement of when to use this tool versus create_campaign_link, update_link_status, or list_campaigns. Usage is inferable but not spelled out.

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, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds a useful mental model (results mirror the Live dashboard), but says nothing about the default time window when no parameters are supplied, page size behavior, or whether unpaged results are capped.

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 zero filler. It is efficient, though the brevity edges toward under-specification rather than maximal usefulness.

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 all five parameters optional, the critical missing piece is what 'recent' means by default and what the agent gets back in unpaged mode. The rich from/to/cursor schema descriptions partially compensate, and no output schema exists, but the default-window question remains unanswered.

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 80%, so the schema does most of the work: from/to document the paged-mode switch and cursor documents pagination. The description adds nothing beyond that, and the one undocumented parameter (limit, 1-50) is left without meaning in either place.

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 ('Return ... recent attribution events and installs') and anchors it to a known surface ('the Live dashboard'). It is clear what the tool yields, but it never names how it differs from siblings like export_events or list_event_deliveries, which also deal with events.

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

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

There is no explicit when-to-use or when-not-to-use guidance and no named alternative. An agent must infer that this is the lightweight, dashboard-parity listing versus the bulk export tool, which is exactly the kind of routing decision the description should settle.

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 already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful context that results are "redacted," but it does not mention pagination, ordering, or return shape.

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 states the resource and the key qualifier ("redacted") immediately.

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

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

For a simple zero-parameter read-only list tool with rich annotations, the description is minimally adequate. However, with no output schema, it could say more about what the returned webhook subscriptions contain or whether results are paginated.

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 there are no parameter semantics to explain. The baseline for a parameterless tool is 4, and the description does not need to compensate for missing schema details.

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

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

The description states a specific verb and resource: "List redacted outbound webhook subscriptions." It is clear what the tool returns, but it does not explicitly distinguish itself from sibling tools such as create_webhook or delete_webhook.

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. It implies listing webhooks by name, but it does not state prerequisites, exclusions, or when create_webhook/delete_webhook would be more 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?

Beyond annotations, the description discloses the resolution rule (newest install only), the meaning of a 404 customer_user_not_found, the authorization requirement ('Read scope is enough'), and what each attribution_status value means. That is substantive behavioral context not available in the structured fields.

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?

Front-loaded verb and scope in one dense sentence, followed by a short error-semantics sentence; almost every clause carries information. The enumerated field/status list makes the opening sentence long but it is still readable.

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 carries the burden of describing the return payload, which it does by naming the fields and status values, and it covers the error case and permission requirement. Nothing an agent needs in order 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?

Schema description coverage is 100%, including the refusal rule for email/phone-like ids. The description mostly restates the schema's customer_user_id mapping and says nothing about app_id, so the baseline 3 applies.

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 ('look up the attribution of one of your users') and enumerates exactly what is returned (campaign, ad set, ad, network, match confidence, attribution_status). This clearly distinguishes it from aggregate siblings such as get_attribution_rollup.

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?

Explains the required lookup key (the customer_user_id passed to AttriKit.setUserID) and that the result is the user's newest install, plus the 404 condition and required read scope. It does not explicitly name a sibling alternative, 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?

Annotations declare it is a mutation (readOnlyHint=false), non-idempotent and open-world; the description adds real behavior beyond that: rows are kept only for campaigns whose network id AttriKit already knows, and if none match the call fails and imports nothing. That failure semantics disclosure is valuable. It doesn't explain what a successful import returns or how partial matches are handled.

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

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

Four sentences, each carrying distinct information: what it does, why you'd call it given scheduled polling, the campaign-id matching constraint, and the delivered-ads caveat. Front-loaded with the action and zero filler.

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

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

For a mutation with side effects and no output schema, the description covers the essential risks: failure with no import, the prerequisite that campaigns must already be linked, and the caveat that no rows exist before ads spend. Missing details on return shape and idempotency_key usage keep it short of full completeness.

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

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

With only 33% schema description coverage, the description must carry weight. It clarifies network (must be a configured Meta/Google/TikTok connection) and implies covers_from/covers_to via 'longer window', but app_id, connection_id and the idempotency_key are never explained, and the tension between an idempotency_key parameter and idempotentHint=false is left unaddressed.

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+resource: fetching and importing creative-level spend from a configured Meta/Google/TikTok connection, scoped to an app. It is clear what the tool does, but it never names the closely related siblings get_spend and import_spend, so an agent must infer the boundary from context alone.

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 states the triggering condition well: automatic polling already covers every enabled connection every 6 hours for today plus the prior 3 days, so this tool is for an immediate pull or a longer window. It gives no exclusions or explicit routing versus get_spend/import_spend, which leaves a gap for a toolset that contains near-duplicate spend 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?

Annotations already declare this is a non-read-only, non-destructive, non-idempotent open-world mutation, so the bar is lower. The description adds real value beyond that: it discloses that AttriKit freezes the period's range, spend, costs, revenue basis, and model version server-side and that callers cannot author provenance, which tells the agent the payload is trusted snapshot data. It does not say whether a repeat call creates a second receipt or what comes back.

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

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

Two sentences with no filler; the action is front-loaded and the provenance caveat follows immediately. Every clause carries information.

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

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

For a mutation with annotations present and no output schema, the description covers what is recorded and that provenance is server-controlled. It leaves the response undefined (no receipt id, no indication of what a repeat call yields), which an agent would still need to discover by calling.

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 every parameter is already documented, including the enum meanings for `call` and `period` and the uuid constraint. The description adds only a loose gloss on `period` ("the reporting period the caller reviewed") and nothing on app_id, campaign_id, or idempotency_key. Baseline 3 is appropriate when the schema does the heavy lifting.

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: records a scale/cut/hold decision for the reviewed reporting period. The second clause clarifies this is a server-frozen snapshot rather than free-form input. It never names the read counterpart get_campaign_decision, so sibling differentiation depends on the schema text rather than the description.

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?

"For the reporting period the caller reviewed" implies this is a write that follows a review, but the description never says to call get_campaign_decision first, nor does it state when not to call or how retries should be handled. Usage is inferable but not spelled out; the useful routing guidance lives in the schema's `call` and `period` descriptions instead.

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 destructiveHint=true, idempotentHint=false, and openWorldHint=true, so the safety profile is covered. The description adds one genuinely useful behavioral fact — revocation is immediate, with no grace period — but says nothing about permanence, whether an already-revoked key errors, or whether in-flight requests using the key start failing right away.

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 front-loaded sentence with the urgency qualifier first and zero filler. It is efficient but arguably too terse for a destructive operation, leaving no room for the one or two clauses that would have made it actionable.

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?

Complexity is low (single required parameter, no output schema, rich annotations), so the description does not need to explain return values. Still, for an irreversible destructive tool it omits the practical consequences an agent should know: that revocation cannot be undone and what happens when the key id is unknown or already revoked.

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%, but the schema itself constrains key_id to a UUID with an explicit pattern, which carries most of the meaning. The description's "by id" adds nothing beyond that — it does not say whether the id comes from list_api_keys or how to obtain it.

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

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

The description states a specific verb and resource ("revoke a management key") scoped by id, which cleanly separates it from list_api_keys, create_api_key, and rotate_publishable_key in the sibling set. It stops short of explicitly naming which sibling to use instead when the goal is rotation rather than revocation, so it lands just below the top mark.

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?

"Immediately" hints at urgency (e.g., compromised key) but the description never states when to revoke versus rotate or delete, nor any prerequisites such as ownership or admin scope. The agent must infer the selection logic entirely from the verb.

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 destructive=true, non-idempotent, open-world, so the safety profile is covered. The description adds genuinely non-obvious behavior beyond that: the old key is not killed instantly but survives to a grace deadline. It still doesn't say how long that window is or whether other keys are unaffected.

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; the action comes first and the return value second.

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 usefully states what comes back (the old-key grace deadline), which is the key piece an agent needs. It is thinner on operational detail such as grace length or whether the old key keeps working during the window.

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 app_id and idempotency_key are fully documented by the schema itself. The description adds nothing about either parameter and doesn't explain the tension between idempotentHint=false and the idempotency_key retry field.

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 pairs a specific verb ("Issue a new SDK publishable key") with a specific resource, which is unambiguous. It never names the closely related sibling get_publishable_key, so an agent could still hesitate between reading and rotating a key.

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

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

There is no explicit when-to-use statement, no prerequisites, and no named alternative (get_publishable_key, create_api_key, revoke_api_key all sit in the sibling list). The rotation intent is only inferable from the tool name and the word "old-key grace deadline".

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?

Goes well past the annotations by naming the exact outcome states (accepted / duplicate / suppressed), explaining each one's cause, reporting the resolved install_epoch_id, and specifying the 404 customer_user_not_found meaning. The duplicate narrative is consistent with idempotentHint=true, and 'nothing was collected' under denied measurement is a real disclosure the annotations cannot carry.

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 front-loaded sentences with no filler; the identifier mechanism comes first, then routing, then the response contract. The response sentence is dense, but every clause (status names, causes, install_epoch_id, 404) carries information an agent would otherwise have to guess.

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, and the description compensates by fully documenting return statuses and the error case. With 9 parameters, nested consent, and mutation semantics, this is about as complete as a description can be without duplicating the 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 89%, so the baseline is 3, but the description adds genuine call-level meaning: which identifier to supply, that no installation id is required, and what event_id repetition does. It also surfaces the consent.measurement gating that determines whether the event is stored at all.

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 ('Report an event ... from your own backend') and pins the identifier model (customer_user_id passed to AttriKit.setUserID; no device installation id). This clearly separates it from the read-side siblings list_recent_events and export_events, which is exactly the distinction an agent needs.

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?

Gives a clear context of use: server-to-server reporting from your own backend, using the id your app already registered. It also states the precondition of a write-scoped API key. It stops short of naming an explicit alternative or a when-not-to-use case (e.g. versus list/lookup tools), so it is strong but not fully routing.

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 a non-read-only, non-idempotent, non-destructive mutation, so the safety profile is covered. The description adds only the faint hint that cost inputs are 'versioned' (implying prior versions are retained), but does not state whether history is preserved, that effective_at controls when the new version takes effect, or that repeated calls create additional versions rather than overwriting.

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?

It is a single front-loaded sentence with no filler, so nothing is bloated. However, for an 8-parameter mutation with a nested object, this degree of terseness is under-specification rather than efficient concision.

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

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

No output schema exists and annotations do not cover versioning semantics, so the description carries the full burden for a complex mutation. It omits effective-dating behavior, unit conventions, retention of prior versions, and what assumptions is for — substantial gaps an agent needs before calling 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 only 25% (just app_id and idempotency_key are documented), so the description must compensate. It names the three cost concepts but never explains that commissions and fees are basis points (0-10000), what variable_cogs_kind's bps vs per_unit_minor mean, or what effective_at and assumptions do — leaving several required parameters unexplained in either place.

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 phrase 'Version commission, payment fees and variable COGS used in profit decisions' identifies the resources being versioned, but 'Version' as a verb is oblique and the fragment never says plainly that it creates a new cost model version for a specific app. Combined with the name and title an agent can infer the purpose, but the description alone is vague on the action.

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

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

There is no when-to-use guidance, no timing relative to profit-reporting workflows, and no mention of alternatives or prerequisites. The only clue to context is the trailing 'used in profit decisions', which does not tell an agent when to call this versus other configuration 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?

Annotations already disclose destructive=true, readOnly=false, and idempotent=false. The description adds useful operational context: the workspace-scoped write key requirement and the meaning of null values for clearing the cap. It could say more about side effects, but the key behavioral facts are covered.

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 definition is three short sentences with no wasted text. The primary operation is front-loaded, followed by the clearing behavior and authorization requirement.

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 mutation tool with no output schema, the description covers the core operation, clearing behavior, and auth requirement. It leaves minor gaps around partial-null semantics and idempotency-key usage, but overall it is sufficient to invoke the tool correctly.

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

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

Schema description coverage is only 33%, so the description carries extra burden. It explains the cap field's minimum and the alert email's purpose, and clarifies that null values clear the cap. The idempotency_key parameter is not mentioned in the description, but the schema itself documents it.

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

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

The description uses a specific verb and resource ('Set a monthly qualified-install cap') plus the associated alert email. This clearly distinguishes the mutation from the sibling read tool get_usage_cap without needing to name it 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?

It states how to set the cap, how to clear it by passing null for both values, and the authorization requirement. It does not explicitly name read alternatives such as get_usage_cap, but the usage context is otherwise clear.

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

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

Annotations already declare that this is a non-read-only, non-idempotent, non-destructive, open-world mutation. The description adds no behavioral context beyond the field list: it does not say whether omitted fields are preserved, whether changing store_url affects live links, or what side effects the update has.

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 boilerplate or repetition. It is appropriately concise, though the brevity partly reflects missing content rather than tightly packed information.

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

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

For an 8-parameter mutation with low schema coverage and no output schema, the description is too thin. It lacks partial-update semantics, idempotency guidance, and any explanation of how the update affects published apps or related resources.

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

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

Schema description coverage is only 25%, so the description must compensate, but it only loosely maps “store destination” to store_url and “coverage mode” to device_matching_mode. It leaves name, platform, bundle_id, timezone semantics, idempotency_key, and the enum values unexplained.

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

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

The description gives a specific verb and resource (update an app) and names several updatable dimensions: metadata, store destination, timezone, and coverage mode. This distinguishes it from sibling mutations like create_app and archive_app, but it omits the required app_id and does not fully scope the operation.

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

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

There is no guidance on when to use this tool versus get_app, create_app, or archive_app, and no mention of prerequisites, ownership requirements, or whether this is a partial update. The agent must infer usage entirely from the name and schema.

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 the mutation and safety profile, and the description adds useful behavior for set_delivery_options: it works in any status and does not touch credential or status. However, it does not explain side effects or requirements for rotate/disable/enable, nor does it mention idempotency behavior beyond the schema field.

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

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

Two sentences, front-loaded, with no wasted wording. The action scope is stated first, followed by the important set_delivery_options constraint.

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 seven-parameter nested mutation tool with no output schema, the description covers the main action semantics and a key conditional requirement. It remains incomplete because the nested owners parameter and several action-specific details are undocumented.

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 description coverage is low at 43%, so the description needs to compensate. It adds meaningful cross-parameter guidance for set_delivery_options and maps rotate to credentials, but it leaves owners and connection_id unexplained and only partially covers credential 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 specific verbs and resources: rotating credentials, enabling/disabling an integration, and changing delivery options. It clearly covers the tool's action scope, though it does not explicitly distinguish itself from sibling tools such as create_integration, delete_integration, or rotate_publishable_key.

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

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

It gives clear usage context for set_delivery_options, including supported networks (Meta/TikTok), availability in any status, and the requirement to supply at least one of delivery_scope or renewal_event. It does not explicitly name alternatives or when-not-to-use cases for rotate/enable/disable.

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 the mutation profile (readOnlyHint=false, destructiveHint=false), so the description earns credit for adding error semantics: a link that already carries a different network id is refused with 409 network_campaign_conflict. It also clarifies that attaching an id is limited to links 'created without one', which is real behavioral scope not present in annotations. It does not explain retry/idempotency behavior despite idempotentHint=false.

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

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

Three sentences, front-loaded with the operation, then the valid input combinations, then the failure mode. No filler and nothing repeated from the title.

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

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

For a two-mode mutation with no output schema, the description covers inputs, preconditions, and one notable error. The main gap is that it never says what the call returns (the updated link?) or how partial updates affect unspecified fields, which an agent may need to chain follow-up calls.

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

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

Schema coverage is 50%, and the description compensates on the two parameters that matter most: status is framed as an active/disabled toggle and network_campaign_id is given purpose plus a precondition (link created without one) that the schema's one-line description does not convey. idempotency_key is left entirely to the schema, and link_id is undocumented in both, but that is low-risk given its uuid format.

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 two concrete verbs on one resource: toggling a tracking link between active and disabled, and attaching a network campaign id. It also names the downstream consumer (pull_network_spend), which lets an agent distinguish this from create_campaign_link or update_app without opening a 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?

'Send status, network_campaign_id, or both' explicitly defines the three valid call shapes, and the parenthetical '(then pull_network_spend can match its spend)' explains the situation that motivates attaching an id. It stops short of naming exclusions, e.g. that this is not the tool for creating a link or for changing cost models.

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, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety and idempotency profile is covered. The description adds value by enumerating the returned auth-context fields, but it does not disclose error behavior or output format.

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

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

The description is a single, front-loaded sentence that immediately states the return value. Every word earns its place, with no repetition or filler.

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

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

For a zero-parameter, read-only introspection tool with rich annotations and no output schema, the description provides enough information by naming the returned fields. Nothing else is needed for an agent to call it correctly.

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

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

The tool has zero parameters, and the schema is empty, so there are no parameter semantics to explain. The baseline for a zero-parameter tool is 4.

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

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

The description uses a specific verb, 'Return', and names the exact resource: the authenticated workspace, plan, app restriction, and read/write scopes. It clearly distinguishes this introspection tool from sibling tools that list or manage keys, apps, and integrations.

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 should call this when it needs to inspect the current authentication context or key scope. However, the description does not explicitly state when to use this tool versus alternatives such as list_api_keys or get_app, nor does it mention any exclusions.

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