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 one useful behavioral fact — that ownership by the ad account is verified — but does not say what happens on mismatch (error vs empty result).

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 waste. It is efficient, though the brevity leaves little room for the usage and failure-mode context an agent would benefit from.

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 an output schema, rich annotations, and full parameter documentation, the description only needs to frame the call, which it does. The main gap is the mismatch behavior when the ad does not belong to the account.

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

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

Schema coverage is 100% and both parameters are documented there, including the ownership constraint the description repeats. The description adds no syntax, format, or cross-parameter nuance beyond the schema.

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

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

States a specific verb ('Read') and resource ('one Reddit ad'), with an added verification scope (belongs to the ad account). The singular 'one' implicitly contrasts with the plural reddit_get_ads sibling, though that sibling is never named.

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: fetch a single ad rather than a list. There is no explicit statement of when to prefer this over reddit_get_ads or what to do when the ad is not found or belongs to another account.

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 operation. The description adds the ownership-verification behavior, but does not explain what happens if the ad group does not belong to the ad account, which is the main behavioral detail an agent might need.

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 wasted wording. It communicates the core operation and the ownership constraint 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?

The description is adequate for a simple two-parameter read tool, especially since annotations cover safety traits and an output schema exists. It is only slightly incomplete in not clarifying the relationship to the plural list tool.

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

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

Schema coverage is 100%, and both parameters are well described in the schema, including the ad-account ID format and ownership constraint. The description adds little beyond saying the ad group must belong to the account, which is already conveyed by the schema.

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

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

States a specific verb and resource: read one Reddit ad group. The word 'one' distinguishes it from the plural sibling reddit_get_ad_groups, though it does not name that sibling 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?

Implies this is the single-item retrieval tool by saying 'Read one Reddit ad group,' but gives no explicit guidance on when to use it versus reddit_get_ad_groups or what to do if the ad group is not in the account.

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

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

With annotations already declaring readOnly, idempotent, non-destructive, and openWorld behavior, the description adds meaningful pagination context: the cursor is opaque and each additional page requires a separate explicit call. It does not cover authorization or rate-limit behavior, but the annotations already carry the safety profile.

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 compact sentences with no filler. The core read purpose is front-loaded, and the pagination caveat follows 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?

The tool has an output schema, so return values need not be explained, and the input schema fully documents parameters. The description covers the main non-obvious behavior, pagination, but could be slightly more complete by clarifying how this list tool relates to the singular ad-group sibling.

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

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

Schema description coverage is 100%, so all three parameters are already documented in the schema. The description reinforces cursor pagination but does not add syntax, defaults, or constraints 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 states a specific read operation on Reddit ad groups and mentions the included data (native configuration and configured/effective status). It clearly implies a list endpoint, though it does not explicitly distinguish itself from the singular sibling reddit_get_ad_group.

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

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

The description explains pagination mechanics—opaque cursor and explicit follow-up calls—which is useful calling guidance. However, it does not state when to use this tool versus the singular reddit_get_ad_group or any other sibling, leaving selection 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?

The annotations already establish readOnly, idempotent, non-destructive, and openWorld behavior. The description adds meaningful operational context by explaining that pagination returns an opaque cursor and that every further page requires an explicit call. It does not contradict 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 two tightly scoped sentences with no filler. The primary action is front-loaded, and the pagination caveat follows 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?

An output schema exists and the annotations plus schema cover safety, parameters, and return structure. The description is nearly complete for a simple read/list tool, though it could be stronger if it explicitly distinguished listing ads from fetching a single ad.

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

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

Schema description coverage is 100%, so the schema already documents limit, cursor, and adAccountId thoroughly. The description reinforces cursor pagination behavior but does not add significant meaning beyond what the structured 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 uses a clear verb and resource: 'Read Reddit ads,' and adds useful scope details like 'native configuration and configured/effective status.' It does not explicitly distinguish this plural listing tool from the sibling singular tool reddit_get_ad, which keeps it from 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?

The description gives no explicit guidance on when to use this tool versus alternatives such as reddit_get_ad or reddit_get_campaigns. It only states what the tool reads, leaving routing decisions to inference from the tool name and siblings.

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

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

The clause "ACTIVE is media-ready, not advertising delivery" adds genuine domain semantics beyond the readOnly/idempotent annotations — it prevents an agent from misreporting upload success as ad delivery readiness. However, it says nothing about other terminal statuses (failed, rejected), expected processing latency, or polling cadence, which are the behaviors an agent most needs for a polling tool.

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

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

A single front-loaded clause with no filler; the operation is stated before the ACTIVE caveat. The phrase "through the profile" is slightly awkward phrasing rather than waste, keeping it just short of a 5.

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?

An output schema exists, so return values are covered, and annotations cover the safety profile. What remains missing is polling lifecycle guidance — terminal statuses, backoff, and what to do with a batch of up to 50 upload IDs — which is material for a tool whose entire purpose is polling.

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%: profileId, adAccountId, and uploadIds all carry inline descriptions including the 1–50 array bound and the cross-reference to reddit_upload_creative_assets. The description adds no parameter-level meaning beyond the schema, 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 action (poll processing status of creative imports) tied to a specific resource (uploads scoped through profileId), which is distinguishable from read-only listing tools like reddit_get_creative_assets. It does not name any sibling tool or explicitly contrast itself with reddit_get_creative_assets, so the differentiation is inferable rather than stated.

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

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

"Poll processing" implies usage after reddit_upload_creative_assets (which the schema references for uploadIds), so the calling context is inferable. There is no explicit guidance on when to call it versus reddit_get_creative_assets, how often to poll, or when to stop polling.

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 and non-destructive, so safety is covered. The description adds real behavioral value by revealing an ownership-validation step: the campaign is checked against the ad account, implying failure if it does not belong — context not present in 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?

A single front-loaded sentence with zero filler; the verb, resource and scoping constraint all appear before any trailing detail.

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

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

With rich annotations, 100% schema coverage, two required params and an output schema, the short description is nearly sufficient. Only the failure mode for a campaign/ad-account mismatch (error vs. empty result) is left implicit.

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 both id and adAccountId are already documented in the schema, including the REDDIT_ADS_ACCOUNT_IDS note. The description adds nothing beyond restating the ownership constraint, 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 (read) and resource (one Reddit campaign) with an added scope qualifier: it must belong to the ad account. This clearly distinguishes it from the plural listing sibling reddit_get_campaigns, though it never names that sibling 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 'read one campaign' versus the siblings that list campaigns or fetch ad groups/ads, but there is no explicit when-to-use or when-not statement and no named alternative. The agent must infer routing from sibling names.

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 the safety profile is covered. The description adds meaningful behavior beyond that: the pagination model (opaque cursor, one explicit call per page) and the fact that both configured and effective status are returned.

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

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

Two tightly written sentences with no waste. The resource scope is front-loaded and the pagination constraint follows 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?

An output schema exists, so return values need not be explained, and annotations carry the safety profile. What remains is that the description doesn't disambiguate against reddit_get_campaign or note any auth/account requirements beyond the schema's adAccountId note.

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 nonetheless reinforces cursor semantics ('opaque cursor', explicit call per page) in a way that makes the pagination loop clear, adding modest value beyond the schema.

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

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

The description gives a specific verb and resource ('Read Reddit campaigns') and adds scope detail ('native configuration and configured/effective status'). It does not explicitly distinguish itself from the sibling reddit_get_campaign, so the singular/plural distinction must be inferred from the name 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 a pagination requirement ('every further page needs an explicit call'), which is real usage guidance, but it never says when to use this list tool versus reddit_get_campaign for a single campaign. Usage is implied rather than directed.

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. The description adds the ownership constraint that the catalog belongs to the ad account's business, which is useful context beyond annotations, though it does not describe pagination or return 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 filler, stating the action and resource immediately. It is appropriately concise, though its brevity leaves some usage context unstated.

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 full schema documentation, annotations covering safety behavior, and an output schema, the description provides enough purpose context for an agent to call the tool. The main missing piece is explicit routing guidance relative to sibling catalog tools.

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

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

Schema description coverage is 100%, so all four parameters are documented in the schema, including limit, cursor, catalogId, and adAccountId. The description adds no parameter-level meaning beyond what the schema already provides, which meets the baseline 3.

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

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

The description names a specific verb and resource: "Read catalog imports" with the scope "from a catalog owned by the ad account's business." It is clear enough to distinguish from catalog listing, but it does not explicitly name sibling alternatives such as reddit_get_catalogs or reddit_get_products.

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 when-to-use guidance, prerequisites, or exclusions. An agent can infer that it retrieves catalog imports, but there is no guidance on choosing this tool over sibling catalog/product 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 openWorld, so the safety profile is covered. The description adds one genuinely useful scoping fact — the result belongs to the business that owns the ad account, tying it to adAccountId. It says nothing about pagination behavior, but the schema's cursor/limit descriptions carry that.

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

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

A single sentence with no filler, and the scope qualifier is front-loaded. Nothing here needs to be trimmed.

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?

An output schema exists so return values need not be described, and all three parameters are documented in-schema. The only real gap is the absence of any pointer to the closely related catalog/import/product siblings.

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

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

Schema description coverage is 100%, so the baseline is 3; adAccountId, limit, and cursor are all documented in-schema, including the a2_ prefix and the 'not the business ID' caveat. The description adds nothing beyond that.

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?

Specific verb (Read) plus specific resource (product catalogs), scoped to the business owning the ad account. It is distinguishable from reddit_get_products and reddit_get_catalog_imports by naming catalogs rather than products or imports, though it does not explicitly contrast itself with those siblings.

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 instead of reddit_get_catalog_imports, reddit_get_products, or reddit_get_product_sets, and no prerequisites or exclusions. The agent must infer the selection criteria from the tool names alone.

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

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

Annotations already declare readOnly, idempotent, non-destructive and openWorld, so the safety profile is covered. The description adds a genuinely useful semantic point — that the library may contain files that are not ads — but says nothing about result shape, pagination, or scoping behavior beyond the profile/ad-account pair.

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 compact sentence with the resource front-loaded and no filler. The semicolon clause is terse to the point of being cryptic, which slightly undercuts clarity but not length.

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?

An output schema exists and the schema fully documents all four parameters, so the description only needs to convey scope and intent. It does that, with the sole gap being the lack of explicit routing versus sibling listing tools.

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

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

Schema description coverage is 100%, with limit, cursor, profileId and adAccountId all documented including formats and a pointer to reddit_get_profiles. The description adds no parameter-level detail beyond what the schema already provides, 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 (List) and resource (asset library of a profile attached to the ad account), which is enough to identify the operation. It does not explicitly distinguish itself from near-siblings like reddit_list_ad_creatives or reddit_get_asset_uploads, so an agent must infer the boundary from the trailing caveat.

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 clause 'unused files are not necessarily ads' hints that this is broader than an ad-creatives listing, implicitly suggesting when it is the right call. However, there is no explicit when-to-use, when-not-to-use, or named alternative among the many sibling list 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. The description adds useful behavioral context by saying the tool verifies that the custom audience belongs to the ad account, though it does not describe failure behavior or permissions.

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

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

The description is a single front-loaded sentence with no wasted text. It communicates the action, cardinality, and key verification behavior 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 tool with full parameter schema coverage, rich annotations, and an output schema, the description is nearly complete. It could be slightly stronger by explicitly routing list-style retrieval to reddit_get_custom_audiences.

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 both parameters are fully documented in the input schema. The description reinforces the relationship between the audience and adAccountId but adds no syntax or format details beyond the schema.

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

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

The description states a specific verb and resource: 'Read one Reddit custom audience.' The cardinality ('one') distinguishes it from the plural sibling reddit_get_custom_audiences, and it also names the ownership verification behavior.

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

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

Usage is implied by 'Read one' versus the list-oriented sibling, but the description does not explicitly say when to use this tool instead of reddit_get_custom_audiences or what to do when the audience is not in the ad account.

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 goes beyond them by disclosing that each page requires a separate call and that the cursor is opaque, which is meaningful operational context an agent cannot get from annotations. It stops short of describing any result-shape or rate-limit behavior, but an output schema exists to cover returns.

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 tight sentences: the resource and returned fields first, then the pagination constraint. No filler, no restatement of the title, and the most operationally important caveat (explicit calls per page) is unambiguous.

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 annotations, a full-coverage schema, and an output schema, the remaining burden is small, and the description covers the main non-obvious behavior (cursor pagination). The one missing piece is guidance on how this tool relates to its singular and saved-audience siblings.

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

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

Schema description coverage is 100%, with limit ranges, cursor semantics, and adAccountId format all documented in the schema, so the baseline of 3 applies. The description's mention of the opaque cursor lightly reinforces the cursor parameter but adds no syntax or constraints beyond the schema.

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

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

The description names a specific verb and resource ('Read Reddit custom audiences') and clarifies the scope includes native configuration and configured/effective status. It does not, however, distinguish this list tool from the singular reddit_get_custom_audience or from reddit_get_saved_audiences, which an agent could easily confuse with it.

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: the phrase 'Pagination returns an opaque cursor; every further page needs an explicit call' tells the agent how to page through results but never says when to prefer this over the singular sibling or the saved-audiences tool. A caller must infer list-vs-get behavior from the plural name alone.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety bar is low, and the description adds genuinely useful behavioral caveats: empty result sets only prove transport worked, and reported audience demographics diverge from configured targeting. Those are data-interpretation warnings an agent cannot get from the annotations. It still omits rate limits, permission requirements, and pagination termination 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?

Three short sentences, front-loaded with the primary capability, with no filler. The telegraphic phrasing ('Empty results validate transport only') is dense but each sentence carries distinct 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?

An output schema exists, annotations carry the safety profile, and all 8 parameters are described in-schema, so the description only needs to supply the traps: UTC-only hour-aligned windows implied, empty-result semantics, and the demographic-vs-targeting discrepancy. It covers exactly those gaps for a read-only reporting tool.

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

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

Schema coverage is 100%, so every parameter including limit, cursor, startsAt/endsAt and breakdowns is already documented at the field level. The description only echoes 'explicit UTC dates and pagination' without adding format constraints or the alternating/conjunctive rules for breakdown combinations. Baseline 3 applies 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 resource and scope: native Reddit reporting producing metrics with entity/audience breakdowns, UTC date ranges and pagination. That clearly separates it from the entity-lookup siblings (reddit_get_campaigns, reddit_get_ads), though it never names another reporting/reference tool 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?

No sentence says when to reach for this tool versus reddit_get_reporting_schema (which the schema itself points to) or the campaign/ad-group lookup tools. The only conditional guidance is interpretive ('Empty results validate transport only'), which explains a result state rather than directing tool selection.

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

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

Annotations already cover readOnly, idempotent, non-destructive and open-world; the description adds real value beyond them by declaring the return scope ('lead submissions are never returned') and that account ownership is verified. It stops short of saying what happens when verification fails, but the added context is substantive.

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, zero filler, and the core action is front-loaded before the return-scope 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?

With rich annotations, full schema coverage and an output schema, the description only needs to cover scope and it does so cleanly. Minor gap: no mention of error behavior when the form doesn't belong to the account.

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

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

Schema coverage is 100% with both parameters documented, including the a2_ prefix and REDDIT_ADS_ACCOUNT_IDS guidance, so the schema does the heavy lifting. The description restates the ownership relationship between id and adAccountId but adds no new syntax or format detail.

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 (read one Reddit lead form) and scoping ('Form configuration only'), which clearly separates it from the plural list tool reddit_get_lead_gen_forms. It doesn't name the sibling explicitly, and the singular/plural naming mismatch (lead form vs lead_gen_forms) leaves a small inference step.

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 'must belong to adAccountId' constraint hints at the precondition and 'Read one' implies the singular-vs-list split, but no sentence explicitly says when to call this versus reddit_get_lead_gen_forms or what happens on a mismatch. Usage is implied rather than 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 cover readOnly, idempotent, non-destructive, open-world. The description adds real value beyond them: it scopes the payload to configuration (no lead submissions) and discloses the pagination behavior ('opaque cursor; every further page needs an explicit call'), which prevents an agent from assuming auto-pagination.

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

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

Three short sentences, front-loaded with the resource and scope, followed by the two constraints that matter (no submissions, manual pagination). No filler sentences.

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

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

Output schema exists and parameters are fully documented, so the description need not explain returns. It covers scope and pagination adequately; the only missing piece is disambiguation from the singular sibling form tool.

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

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

Schema description coverage is 100%, so limit, cursor, and adAccountId are fully documented in structured data. The description's cursor sentence echoes the schema rather than adding format or semantics beyond it; 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 ('Read Reddit lead gen forms') plus the scope of what is included (native configuration and configured/effective status). However, it never distinguishes itself from the sibling reddit_get_lead_form, so an agent cannot tell from the description alone which one is the list vs. the single-record lookup.

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: 'lead submissions are never returned' tells the agent not to expect leads, which nudges toward config-listing use cases, but there is no explicit statement of when to pick this over reddit_get_lead_form or other form-related siblings.

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

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

Annotations already declare readOnly, idempotent, non-destructive, openWorld, so safety is covered. The description adds that results are scoped to the 'allowed' ad account (a permission boundary), but says nothing about pagination behavior, empty results, or rate limits, so value beyond annotations is modest.

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 short, front-loaded sentence with zero filler. It is efficient, though so terse that it borders on under-specification for a paginated list endpoint.

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?

A simple read-only list tool with full schema coverage, an output schema, and complete annotations needs little prose. The description covers purpose and scope; pagination and return shape are handled by the schema and output schema, leaving no critical 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%, including the adAccountId pattern note and pagination cursor semantics, so the schema does the heavy lifting. The description adds only the implicit link between 'allowed' accounts and adAccountId, which is baseline-level value.

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

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

States a specific verb ('List') and resource ('pixels') scoped to the allowed Reddit ad account. It is distinguishable from the get_* siblings by resource type (pixels vs campaigns/ads/audiences), though the description itself doesn't explicitly differentiate from them.

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

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

The phrase 'accessible to the allowed Reddit ad account' implies the prerequisite (a configured ad account) and the context in which to call it, but there is no explicit when-to-use vs alternative guidance and no exclusions. Usage is inferred rather than 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=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds an ownership-verification prerequisite, which is useful auth context, but says nothing further about rate limits, failure modes, or response 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 definition is a single front-loaded sentence with no filler. It is efficient, though its terseness contributes to the missing sibling differentiation.

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

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

Given the simple two-parameter read operation, rich annotations, and existing output schema, the description is largely complete for correct invocation. The main remaining gap is selection guidance relative to similar sibling tools.

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

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

Schema description coverage is 100%, and both parameters are well documented in the schema, so no extra parameter explanation is required in the description. The description itself adds no meaning beyond the schema.

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

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

The description states a specific verb ('Read') and resource ('ad structured post'), plus a scoping condition ('after profile ownership verification'). It is clear but does not distinguish this tool from siblings such as reddit_get_posts or reddit_get_post_job.

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 a prerequisite ('after profile ownership verification') but does not explain when to choose this singular post read over reddit_get_posts, reddit_get_post_job, or other retrieval tools. Usage is implied rather than explicitly 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 readOnly/idempotent/non-destructive, so safety is covered; the description adds the meaningful constraint that receipts are account-scoped and arbitrary job IDs are rejected, which explains a likely failure mode. It omits the seven-day receipt lifetime, which lives only in the schema.

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

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

Two short sentences with no filler; the core action leads and the scoping restriction follows 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?

With an output schema and full annotations in place, the description only needed to cover the action and the receipt-scoping rule, which it does. The one gap is what the polled state looks like and how often to poll, which an agent must infer.

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

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

Schema coverage is 100% and both parameters are fully documented there, including the seven-day validity and the a2_ account ID format. The description's 'signed job receipt' phrasing reinforces the receipt parameter but adds no syntax or provenance detail beyond the schema, 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: 'poll a previously created structured post' via a signed job receipt. It is distinguishable from the many reddit_get_* read siblings by the 'job/receipt' framing, though it never names the closest sibling (reddit_get_post) 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?

'Poll a previously created structured post' implies the prerequisite (a prior reddit_create_post) and the repeated-call pattern, and 'does not accept arbitrary job IDs from another account' gives a negative condition. But no alternative is named and no guidance is given on polling cadence or when to stop.

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, so the safety profile is covered. The description adds that results are structured post configurations (image/video/carousel/text), which is useful context, but says nothing about pagination behavior or result volume.

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 tight sentences, front-loaded with the verb and resource, followed by the return-shape hint. No filler, though the second sentence is somewhat redundant with the 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?

Output schema exists and parameters are fully described, so the description only needs to frame scope and selection. It does the minimum but omits any routing guidance among the many siblings and any pagination note.

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%: limit, cursor, profileId (including how to discover it via reddit_get_profiles) and adAccountId are all documented in the schema. The description adds no parameter meaning beyond that, 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: 'List advertising structured posts' scoped to a profile/ad account. It doesn't differentiate itself from the singular reddit_get_post or reddit_list_ad_creatives sibling, which an agent browsing the tool list could confuse it with.

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 or when-not-to-use guidance. With siblings reddit_get_post (single post) and reddit_list_ad_creatives present, the description never says which to pick or whether a profile filter is mandatory context.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered by structured data. The description adds the meaningful access constraint that only products from a catalog owned by the ad account's business are readable, but says nothing about pagination behavior or empty results.

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

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

A single short sentence with no filler and the resource scoping front-loaded. It is efficient, though so terse that nothing beyond the core purpose is conveyed.

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

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

For a low-complexity read-only list tool with full schema coverage, rich annotations, and an output schema, the description is sufficient to call correctly. Pagination semantics are handled by the cursor/limit fields, so no critical gap remains.

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

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

Schema description coverage is 100%, with limit, cursor, catalogId, and adAccountId all well documented including a pointer to reddit_get_catalogs. The description adds no parameter meaning beyond the schema, 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 ('Read') and resource ('products from a catalog') with a clear owning-scope qualifier. It does not, however, distinguish this from near siblings such as reddit_get_catalogs or reddit_get_product_sets, so an agent still has to 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?

The description gives no when-to-use, when-not-to-use, or alternative-tool guidance. The 'list catalogs with reddit_get_catalogs' hint lives only in the catalogId schema field, not in the description, so the description itself 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 already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful ownership context ('catalog owned by the ad account's business') but does not mention pagination, rate limits, or output 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 is perhaps overly terse, but conciseness itself is strong.

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/list tool with rich annotations and an output schema, the description sufficiently states what is returned and from where. Pagination and return format are covered by the schema and output schema, though sibling routing is still left implicit.

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 schema already documents adAccountId, catalogId, limit, and cursor in detail. The description adds no parameter syntax or semantics beyond saying the catalog belongs to the ad account's business, so the baseline 3 is appropriate.

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

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

States a specific verb and resource ('Read product sets') plus a clear ownership scope ('from a catalog owned by the ad account's business'). It is distinguishable from get_catalogs and get_products, but does not explicitly contrast with those sibling tools.

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

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

The sentence implies the tool is used for product sets within a catalog, but it gives no explicit when-to-use guidance, prerequisites, or alternatives such as reddit_get_products or reddit_get_catalogs.

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 safety behavior is covered. The description adds the scoping constraint of allowed ad accounts but does not mention pagination or response characteristics; it meets the lower bar set by annotations without adding much extra context.

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

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

A single, front-loaded sentence with no redundant or filler content. It communicates the core action and scope 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?

Given the presence of annotations and an output schema, the description is largely complete for a list operation. It could clarify what 'profiles' represent or how pagination behaves, but the schema covers parameters and the output schema likely covers return shape.

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 adAccountId, limit, and cursor are already fully documented. The description reinforces the account scoping but adds no parameter-level detail beyond the schema baseline.

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

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

States a specific verb and resource: 'List profiles' scoped to the allowed Reddit ad account. It is clear what the tool returns, though it does not explicitly contrast itself with any sibling tools.

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

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

The phrase 'accessible to the allowed Reddit ad account' implies when the tool applies, but there are no explicit exclusions, prerequisites, or alternatives mentioned. Usage is inferable but not 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 operation as read-only, idempotent, non-destructive, and open-world. The description adds useful scope context by clarifying that targeting is not inferred from the reporting inventory, though it does not add details about output shape or limits.

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

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

The description is two compact clauses with no wasted text, and it front-loads the resource meaning before adding the targeting boundary.

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

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

The tool has no parameters, rich annotations, and an output schema, so the description does not need to explain return values. It supplies the key scope distinction about targeting, which is enough for correct selection.

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 no parameters, so there are no parameter semantics for the description to explain. With zero parameters, the baseline 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 identifies the resource as a Reddit metric and dimension inventory, which is more specific than the tool name alone. It also distinguishes itself from reddit_get_targeting, though it lacks an explicit verb such as 'returns' or 'lists'.

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 a clear usage boundary by stating that configured targeting should be read with reddit_get_targeting and not inferred from reporting. It does not explicitly say when to call this tool, such as before building reporting queries, but the intended context is clear.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is fully covered structurally. The description adds only the ownership-verification behavior, which is real but thin; nothing is said about error behavior when the audience does not belong to the account.

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. The scope constraint ('one', ownership) leads and 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?

Return values need not be explained since an output schema exists, and annotations cover safety and idempotency. What remains unstated is the failure mode when the ownership verification does not hold, which an agent would want to know before 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 coverage is 100% and the schema descriptions are unusually rich, including the ID pattern and the note that adAccountId is a Reddit ad account ID (a2_...) from REDDIT_ADS_ACCOUNT_IDS rather than a business ID. The description's ownership constraint restates what the schema already says, so it adds no new parameter meaning but the baseline is satisfied.

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 ('read') and resource ('one Reddit saved audience'), and adds the verifying-ownership scope. The word 'one' implicitly distinguishes it from the plural sibling reddit_get_saved_audiences, though the sibling is never named.

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

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

The description implies the caller must already know both the audience id and the owning ad account, but gives no explicit when-to-use framing, no comparison to reddit_get_saved_audiences, and no statement of what to do if the ownership check fails.

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/openWorld, so the safety profile is covered. The description adds genuinely new behavior: that paging is cursor-based and that each subsequent page costs a separate explicit call, plus that responses carry both configured and effective status.

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 padding; the resource and payload scope come first, followed by the paging caveat. Every clause carries information an agent needs.

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 an output schema present, the description need not describe return values, and a fully documented input schema covers parameters. It adds the one non-obvious operational caveat (per-page calls), leaving only the sibling differentiation 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%, so limit, cursor, and adAccountId are fully documented in the schema, which sets the baseline at 3. The description's note about the opaque cursor is consistent with but does not exceed schema detail.

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 ('Read Reddit saved audiences') and adds what the payload includes (native configuration, configured/effective status). It does not distinguish itself from the sibling singular tool reddit_get_saved_audience, so it falls short of 5.

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

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

The pagination sentence gives operational guidance (opaque cursor, one call per page), which implies iterative usage. However, there is no explicit statement of when to use this list tool versus reddit_get_saved_audience or how it relates to the custom-audience 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, so the safety bar is met elsewhere; the description adds the useful behavioral fact that this is static orientation content describing limits rather than live account data. It could note that the guide is workspace-independent or cached, but the key trait — read before writes — is disclosed.

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

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

Two short sentences with no waste: the content inventory comes first, then the action trigger. Every clause carries information an agent can act on.

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 an output schema present and no parameters, the description only needs to say what the guide contains and when to call it — both are covered. The one gap is failure to point at the write/reporting schema siblings for field-level detail.

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?

Zero parameters, so the baseline is 4 per the rubric. The description correctly implies a parameterless, content-only call and adds no misleading argument hints.

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

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

The description names the resource (Reddit connector setup/coverage documentation) and enumerates its payload: coverage, prerequisites, units, renaming, known limits. That distinguishes it from data-fetch siblings like reddit_get_campaigns, though the near-identical documentation siblings (reddit_get_write_schema, reddit_get_reporting_schema) are not explicitly differentiated.

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?

"Read it before planning writes or answering what this server cannot do" gives a concrete trigger condition, which is stronger than most tools provide. It stops short of naming the alternative schema tools as the place to go for write/reporting field definitions, so the routing is implied rather than complete.

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 the safety profile is covered. The description adds the meaningful distinction that the payload is configuration rather than delivery demographics, which prevents misreading of the output. It says nothing about scoping, error behavior, or account/ad-group ownership requirements beyond what the schema already carries.

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, zero filler. The field inventory is front-loaded and the disambiguating clause comes last, which is exactly the right ordering for an agent skimming definitions.

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?

An output schema exists so return values need not be explained, and the description still names the returned categories, which helps an agent decide whether this call answers its question. Parameters are fully covered by the schema. What is missing is any routing hint to the neighboring targeting/insights tools.

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

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

Schema description coverage is 100% and both parameters are documented there, including the a2_ prefix convention and the adAccountId/adGroupId ownership constraint. The description adds no parameter-level information 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?

Specific verb + resource ('Read actual ad-group targeting') followed by an explicit field inventory (inclusions, exclusions, geo, age/gender, languages, interests, communities, keywords, devices, audience IDs). The closing clause distinguishes it from delivery-based reporting tools like reddit_get_insights. It does not directly differentiate from the similarly named sibling reddit_get_targeting_options, which keeps it at 4 rather than 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?

'Read actual ad-group targeting' plus 'This is configuration, not delivery demographics' implies the use case (fetch configured settings, not performance data) and gives one useful exclusion. However, no sibling is named and there is no explicit when-to-use statement contrasting it with reddit_get_targeting_options or reddit_get_ad_group.

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 open-world behavior, so the safety profile is covered. The description adds genuinely new behavioral context: large result sets are paginated and may be explicitly marked partial, which is important for an agent interpreting completeness of results and is not in 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?

Two short sentences with no filler, and the core purpose leads before the pagination caveat. It is arguably over-compressed given the tool's breadth, but 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?

An output schema exists so return shape needn't be explained, and parameter documentation is complete in the schema. However, for a six-parameter enumeration tool spanning six targeting kinds with a near-identical sibling, the description does not say enough about scope or selection to be fully self-sufficient.

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

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

Schema description coverage is 100%, so every parameter (kind enum, limit, query, cursor, country, adAccountId) is already documented in the schema, and the description only echoes the community search case. Baseline 3 is appropriate since 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?

The description says it discovers 'valid native targeting values', which conveys that this is a reference/enumeration lookup rather than an entity read, but it never states the scope (geolocations, languages, interests, devices, carriers, communities) even though that is the core of the tool. It also fails to distinguish itself from the sibling reddit_get_targeting, leaving the agent to infer the difference.

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 only guidance is 'Communities can be searched', which implies the query parameter's applicability but does not say when to call this tool versus reddit_get_targeting or the audience/catalog tools. There are no exclusions or routing conditions, so the agent must guess from the name alone.

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

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

Annotations already declare this is a safe, idempotent, read-only lookup, so the description's real contribution is the caveat that provider acceptance is separate from local schema validation — a meaningful warning an agent wouldn't infer. It does not disclose output shape or size, but the output schema exists separately.

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 dense sentences, front-loaded with what is returned, followed by the caveat. Nothing is padded, though the phrase 'all implemented campaign/ad formats' is slightly vague 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 a rich enum parameter and an output schema, the description needs only to frame the resource and its limitation, which it does. Missing guidance on when in the write workflow to call it keeps this from a 5.

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

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

Schema coverage is 100% with a fully described 18-value enum, so the schema already carries parameter meaning. The description adds only a hint that coverage spans campaign and ad formats, which is marginal beyond what the enum enumerates.

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 the specific resource precisely: returns exact pinned native schemas for Reddit creation and edits, covering targeting and all implemented campaign/ad formats. This clearly separates it from data-fetching siblings, though the only same-category sibling (reddit_get_reporting_schema) is never contrasted explicitly.

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

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

The purpose implies the usage (fetch a schema before issuing a create/update), but the description never says when to call it versus its reporting-schema sibling, nor that it should be called prior to a write operation. Usage is inferable but not stated.

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

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

Annotations already declare readOnly, idempotent, and non-destructive, so safety is covered. The description adds genuine behavioral context beyond that: it tells the agent that a successful API read does not prove delivery or full objective eligibility, which is a meaningful interpretation limit not encoded anywhere in 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?

Two short sentences with the resource list front-loaded and no filler. The second sentence is somewhat terse and cryptic in isolation, slightly reducing clarity per word, but 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 an output schema present, return values need not be described, and the single parameter is fully documented. For a simple read-only check this is nearly complete; only an explicit 'run this first to validate credentials/account access' statement 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% and the single adAccountId parameter is fully documented in-schema, including format pattern and the distinction from business ID. The description adds nothing about the parameter, 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 (read) and enumerates the resources returned: the ad account, its business, currency, and timezone. This distinguishes it from the many entity-fetching siblings by being an account-level diagnostic, though it never explicitly says the check is about connectivity/permissions.

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 'health check' framing implies it should be run to verify access before real work, and the closing caveat hints at how to interpret results, but there is no explicit when-to-use or when-not-to-use guidance relative to siblings like reddit_get_campaigns.

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 readOnly, idempotent, non-destructive, openWorld behavior, so the bar is lower, and the description still adds real value: media URLs are returned rather than files downloaded, and a video cover thumbnail does not imply the motion/audio asset exists. That coverage caveat is exactly the kind of trait an agent cannot get from 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?

Three short sentences with no filler, and the core action is front-loaded before the coverage caveat and the download note. "With explicit coverage" is slightly abstract on first read, but the following sentences ground it.

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?

An output schema exists, so return values need no explanation, and the schema plus annotations cover parameters and safety. The description supplies the remaining behavioral nuance (URL-only delivery, cover-vs-full-media distinction) needed to call and interpret the tool correctly.

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

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

Schema description coverage is 100%, including the cap of 20 resolved per call and the page-by-page behavior when adIds is omitted, so the schema carries the full parameter burden. The description adds no parameter-specific syntax or format detail beyond it, which is the expected baseline 3.

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

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

The description names a specific verb and resource: resolving ad-linked image/video/carousel assets. An agent can tell it retrieves creative media rather than ad metadata. However, it never distinguishes itself from sibling reddit_get_creative_assets, which by name overlaps heavily, so the boundary between the two is left to inference.

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?

"Use full media when available" gives a partial rule for choosing which asset to prefer once inside the tool, but there is no guidance on when to call this versus reddit_get_creative_assets or reddit_get_ads. Usage is only implied, not stated with exclusions or alternatives.

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