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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so safety behavior is covered. The description adds a useful verification constraint (the ad must belong to the ad account), but it does not say what happens on a mismatch (error vs. empty result) or how the ownership check is enforced, so added value 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?

A single front-loaded sentence with no filler. The operation and its key constraint are stated immediately, and nothing redundant is included.

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, complete parameter descriptions, and rich annotations, the description only needs to establish purpose and the ownership constraint, which it does. It is slightly thin on error behavior and sibling differentiation but otherwise complete enough to call the tool correctly.

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

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

Schema description coverage is 100% and already explains both parameters well, including the a2_ prefix and REDDIT_ADS_ACCOUNT_IDS constraint. The description adds no parameter syntax or format details beyond what the schema provides, 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?

States a specific verb and resource ('Read one Reddit ad') and adds a scoping constraint ('verify that it belongs to the ad account'), which distinguishes it from the list-oriented reddit_get_ads. It does not explicitly name the sibling it differs from, 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: fetch a single ad by ID. The description never says when to use this versus reddit_get_ads or reddit_get_ad_group, nor does it state exclusions or prerequisites. Adequate but with clear gaps in routing 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 cover read-only, idempotent, open-world, and non-destructive behavior, so the bar is lower. The description adds an ownership-verification behavior, but it does not say what happens on mismatch, whether an error is returned, or what the verification implies for output.

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 or redundancy. Every clause contributes to the tool's purpose or its ownership-verification 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 simple read operation, complete parameter schema, annotations, and output schema, the description is largely sufficient. Its only meaningful gap is the absence of explicit routing guidance versus the plural list 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%, and the schema already explains that id must belong to adAccountId and that adAccountId is the a2_... account ID, not the business ID. The description only echoes the 'belongs to' constraint without adding format or syntactic 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?

The description states a specific verb, 'Read', and a specific singular resource, 'one Reddit ad group', which distinguishes it from the plural list sibling reddit_get_ad_groups. It also mentions ownership verification, giving a clear purpose beyond simply fetching.

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 'Read one' implies the tool is for single-ad-group retrieval and 'verify that it belongs to the ad account' suggests a validation use case. However, it gives no explicit when-to-use guidance, no exclusions, and does not point to reddit_get_ad_groups for multiple records.

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 value beyond that by disclosing the pagination contract: an opaque cursor with no automatic continuation, which is precisely the kind of behavior an agent needs to plan multi-page reads.

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, both earning their place: the first defines scope and payload, the second defines pagination behavior. Front-loaded with no filler or restatement of 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 low-complexity read/list tool with full schema coverage, full annotations and an output schema, the description covers the one non-obvious behavioral nuance (manual pagination). It stops short of routing the agent away from the singular get_ad_group sibling, which is the only remaining 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% — limit, cursor and adAccountId are all documented in the schema, including the a2_ prefix and the REDDIT_ADS_ACCOUNT_IDS hint. The description restates the cursor being opaque but adds no format or constraint detail beyond what the schema supplies, 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 ("Read Reddit ad groups") and names the returned content (native configuration, configured/effective status). It does not explicitly distinguish itself from the singular sibling reddit_get_ad_group, but the plural resource plus list semantics make the intent clear.

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

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

The sentence about pagination ("every further page needs an explicit call") is a real usage instruction telling the agent it must loop manually rather than rely on auto-pagination. However, there is no guidance on when to pick this over reddit_get_ad_group or reddit_get_campaigns, so the sibling-selection guidance is only implied.

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 the safety profile is covered. The description adds a genuine behavioral trait beyond schema and annotations: pagination returns an opaque cursor and each subsequent page requires an explicit call (no auto-pagination), which an agent needs to know.

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 with the purpose front-loaded and pagination behavior second. Every sentence earns its place with no filler.

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

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

An output schema exists, so return values needn't be explained, and annotations cover the safety profile. The description adds pagination behavior, making it nearly complete; the only gap is lack of explicit differentiation from sibling fetch-one/list 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 three parameters (limit, cursor, adAccountId) are already documented in the schema. The description adds no parameter-level 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 (Read) and resource (Reddit ads) plus scope detail ('native configuration and configured/effective status'). It's clear it lists ads, but it never explicitly distinguishes itself from the sibling reddit_get_ad, leaving the agent to infer plural=list vs singular=fetch-one.

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 implies how to iterate ('every further page needs an explicit call'), which is usage context, but there is no explicit when-to-use vs alternatives guidance (e.g. versus reddit_get_ad or reddit_get_ad_groups). Usage is only implied.

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 read-only, idempotent, non-destructive, and open-world, so the description is not responsible for basic safety disclosure. It adds important behavioral meaning beyond annotations by explaining that ACTIVE means 'media-ready, not advertising delivery,' which prevents misreading the status as ad delivery readiness.

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 the action and status caveat front-loaded, and every clause contributes: 'Poll processing' states the operation, 'through the profile' scopes it, and the ACTIVE caveat clarifies the result. There is no filler or redundant restatement of 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 read-only polling tool with three fully documented required parameters, an output schema, and rich annotations, the description covers the essential operation and clarifies the most likely misinterpretation of the ACTIVE status. It could optionally mention polling cadence or the relationship to the upload tool, but the schema and annotations carry the rest.

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 explains adAccountId, profileId, uploadIds, the t2_/a2_ formats, and the link to reddit_upload_creative_assets. The description only adds 'through the profile,' which does not materially extend parameter semantics beyond the schema.

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

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

The description uses a specific verb, 'Poll,' and a specific resource, 'processing of creative imports through the profile,' so the agent can tell this checks upload/import status rather than fetching finished creative assets. It does not name a sibling tool explicitly, but the resource and status semantics distinguish it sufficiently from reddit_get_creative_assets and reddit_list_ad_creatives.

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 word 'Poll' implies this is called after an upload or import submission and may be called repeatedly, but the description gives no explicit when-to-use condition, no when-not-to-use condition, and no named alternative. The schema's uploadIds field references reddit_upload_creative_assets, but that guidance is not in the description itself.

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 mildly useful ownership-verification constraint, but doesn't say what happens on a mismatch (empty result vs. error) or note any rate limits, so it adds only modest context beyond the annotations.

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

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

A single front-loaded sentence with no filler; the key scope and the ownership constraint come first. It errs slightly toward under-specification rather than bloat, but nothing in it 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 no explanation, annotations cover the safety profile, and both parameters are fully documented in the schema. The only real gap is failure behavior when the campaign doesn't belong to the ad account, which keeps it 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 description coverage is 100%: both id and adAccountId are already documented, including the a2_ prefix convention and the REDDIT_ADS_ACCOUNT_IDS source. The description only restates the ownership relationship already present in the id field, 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'), and the singular scope distinguishes it from the plural sibling reddit_get_campaigns. It doesn't explicitly name the sibling, but the singular/plural contrast plus the ownership check is enough for an agent to disambiguate.

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

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

The description implies usage by requiring an adAccountId-scoped campaign read, but it never says when to prefer this over reddit_get_campaigns or what to do if the ownership check fails. Usage context 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 readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so safety is covered. The description adds behavior beyond that: results are paginated with an opaque cursor and every additional page requires an explicit follow-up call, which is exactly the operational detail an agent needs to avoid 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?

Two tight sentences with zero filler. Scope and return content come first, pagination caveat second — front-loaded and 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?

An output schema exists, so return values need not be described, and all three parameters are documented. The description covers scope and pagination adequately, though it says nothing about permission requirements or what happens with an expired/invalid cursor for this ad-account-scoped read.

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 ranges, cursor opacity and the adAccountId format/prefix are all documented in the schema. The description only echoes the cursor behavior, adding no new parameter meaning, 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 ('Read Reddit campaigns') plus the data surfaced (native configuration, configured/effective status). This implicitly separates it from the singular sibling reddit_get_campaign, but the list-vs-single distinction is left to the tool name rather than stated 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 pagination sentence tells the agent how to continue iterating (opaque cursor, explicit call per page), which is genuine usage guidance. However, there is no explicit when-to-use framing and no named alternative, e.g. it never says to use reddit_get_campaign for a single campaign or which tool to pick when the campaign ID is already known.

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 fully covered. The description adds the meaningful constraint that the catalog must belong to the ad account's business, but says nothing about result volume, pagination semantics, or error behavior for non-owned catalogs.

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 key scoping constraint front-loaded. It is arguably too terse for a list tool, but nothing in it 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 and the input schema is fully documented, so much of the burden is lifted. Still, for a paginated listing endpoint the description gives no hint about pagination, result shape, or what an 'import' record represents, leaving the agent to rely entirely on structured 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?

Schema description coverage is 100%, so limit, cursor, catalogId and adAccountId are all documented in the schema, including the pointer to reddit_get_catalogs and the a2_ ID format. The description adds no parameter-level detail beyond the ownership scope, 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 ("Read catalog imports") plus a scoping constraint (catalog must be owned by the ad account's business). It is clearly distinct from siblings like reddit_get_catalogs or reddit_get_products, though it never explicitly contrasts itself with them.

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

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

No when-to-use or when-not-to-use guidance and no named alternatives (e.g. reddit_get_catalogs for discovering catalogId). The only guidance is the implicit ownership precondition, which the agent must infer applies to the calling 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=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds one useful fact — catalogs belong to the business that owns the ad account, implying the account ID drives the lookup — but says nothing about pagination behavior, response shape, or what an empty catalog list means. With annotations carrying most of the burden, a 3 fits.

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 its brevity comes at the cost of the routing and behavioral detail scored above.

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 annotations are rich, so return values and safety need no explanation. Still, with four closely related catalog/product tools in the sibling list, the description is too thin to resolve which tool to call, and it omits whether the read is scoped by business or account-side defaults.

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 all fully documented in the schema, including the a2_... ID format and the 'not the business ID' caveat. The description adds only a light scoping clarification and no syntax or format beyond the schema; baseline 3 is appropriate.

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

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

States a specific verb ('Read') and resource ('product catalogs') plus the ownership scope ('of the business owning the ad account'), so an agent knows what it returns. It does not, however, distinguish itself from close siblings like reddit_get_products, reddit_get_product_sets, or reddit_get_catalog_imports, which is the main remaining ambiguity.

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

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

There is no when-to-use or when-not-to-use guidance and no named alternative. Given four sibling tools in the catalog/product family, an agent has to guess which one to pick, and the description offers no routing signal.

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, non-destructive and open-world, so the safety profile is covered. The description adds one genuinely useful semantic caveat (library assets ≠ ads) but says nothing about ordering, result volume, or pagination behavior beyond what the schema's limit/cursor fields already 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?

A single compact sentence with the core action front-loaded and no filler. It is efficient, though the semicolon clause packs in a caveat that could be phrased more directly.

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, full annotation coverage, and 100% parameter documentation, most of the burden is carried elsewhere. However, for a paginated list tool the description gives no sense of what an 'asset' is (image/video/etc.) or result volume, leaving it minimally adequate rather than complete.

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

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

Schema description coverage is 100% and the parameter descriptions are strong — profileId even points to reddit_get_profiles and adAccountId distinguishes the ad account from the business ID. 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 verb and resource: "List the asset library of a profile attached to the ad account." The trailing clause clarifies what the returned items are (raw library files, not necessarily live ads), which meaningfully separates it from ad/creative listings, 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?

Usage is only implied: the note that "unused files are not necessarily ads" hints this is the raw-library lookup rather than an ad/creative listing. It never names reddit_list_ad_creatives or reddit_get_asset_uploads as alternatives, nor states when to prefer one over the other.

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. The description adds the meaningful constraint that the audience must belong to the ad account, but it does not describe error behavior, auth requirements, or rate 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 a single efficient sentence with no filler. The core action and the ownership constraint are front-loaded.

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

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

An output schema exists and the annotations carry the safety profile, so the description need not explain return values. It is nearly complete for a two-parameter read tool, though it omits what happens when the audience is not found or does not belong to the ad 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 description coverage is 100%, with rich field descriptions for both id and adAccountId, including the ID pattern and ad account format. The description reinforces the ownership relationship between id and adAccountId but adds no syntax or format detail 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, plus an ownership verification requirement. The singular 'one' implicitly distinguishes it from the sibling list tool reddit_get_custom_audiences, 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?

Usage is implied for fetching a single custom audience by ID and confirming it belongs to the ad account. It does not state when to use this versus reddit_get_custom_audiences or reddit_get_saved_audience, nor does it mention exclusions or prerequisites.

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 genuinely useful behavior around pagination – the cursor is opaque and each page requires an explicit call – but says nothing about return shape, ordering, or error conditions beyond 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?

Two sentences with zero waste: the resource and returned fields come first, then a compact pagination caveat. Nothing is repeated and nothing is padded.

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

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

An output schema exists, so return-value explanation is not needed, and annotations cover the safety profile. The description is nearly complete for a paginated read tool; the only missing element an agent would want is disambiguation from the singular 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 (limit, cursor, adAccountId) are fully documented in the schema. The description's cursor sentence paraphrases what the schema already states ('Opaque next_cursor returned by the previous page'), adding no syntax or format detail beyond structured data, 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?

The description gives a specific verb and resource ('Read Reddit custom audiences') plus the scope of returned data (native configuration, configured/effective status). It does not, however, distinguish itself from the singular sibling reddit_get_custom_audience, so an agent must infer the list-vs-single distinction 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?

Usage is only implied by the plural name and the pagination note ('every further page needs an explicit call'). There is no explicit statement of when to use this versus reddit_get_custom_audience or the other audience siblings, and no stated prerequisites (though adAccountId is required and documented in the 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 cover the safety profile (readOnly, idempotent, non-destructive, openWorld), and the description adds genuinely non-obvious behavior: empty results only validate transport, and reported audience demographics differ from configured targeting. Those two caveats materially change how an agent interprets results. It stops short of noting pagination termination or whether missing fields error out vs. return nulls.

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, no padding, and the capability statement is front-loaded ahead of the two caveats. Every 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, so return values need no explanation, and the behavioral caveats are covered. However, for an 8-parameter, 4-required reporting tool whose sibling set includes both schema-discovery tools and entity listers, the description omits the discovery prerequisite and the routing logic an agent needs 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?

Schema description coverage is 100%, so every parameter (limit, cursor, endsAt, fields, filter, startsAt, breakdowns, adAccountId) is already documented in the schema. The description's mention of 'explicit UTC dates and pagination' restates schema content without adding syntax or constraint detail. 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 capability: native Reddit reporting returning metrics plus entity/audience breakdowns. It is clear what the tool retrieves, but it never distinguishes itself from reporting-adjacent siblings, and there is no explicit statement that this is ad-account-level performance data rather than an entity listing.

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 guidance and names no alternatives, even though the 'use reddit_get_reporting_schema for supported fields; never guess names' prerequisite exists only inside the schema parameter text. An agent must infer that it should call the schema tool first and that a plain campaign listing should use reddit_get_campaigns 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 establish this as a read-only, idempotent, non-destructive operation, so the description does not need to restate safety. It adds real behavioral value by clarifying the return boundary: 'Form configuration only; lead submissions are never returned,' and by noting that it verifies ad-account ownership.

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 filler. The key differentiator ('one') and the most important output boundary ('lead submissions are never returned') are front-loaded.

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

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

Given an output schema and full parameter coverage, the description covers the essential scope and output boundary an agent needs. It stops short of describing failure behavior when the form does not exist or does not belong to the ad account, but otherwise it is complete.

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

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

Schema coverage is 100%, so both parameters are already fully documented, including patterns and the requirement that id belongs to adAccountId. The description reinforces the cross-parameter ownership constraint but does not add format or validation 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?

States a specific verb and resource ('Read one Reddit lead form') and immediately scopes it against the sibling list tool by saying 'one'. The ownership-verification clause and the 'form configuration only' boundary further sharpen what is being fetched.

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 'Read one' implies this tool is for single-form retrieval rather than listing, and the ownership check implies a valid adAccountId/id pair is required. However, no alternative tools are named and there is no explicit when-to-use/when-not-to-use guidance beyond what the reader infers from 'one'.

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 useful behavior beyond annotations: it returns configuration and status only, never lead submissions, and pagination requires an explicit call per additional page.

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

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

The description is three tight sentences with no filler. The main purpose is front-loaded, followed by the key exclusion and pagination caveat.

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

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

Given the output schema and rich annotations, the description covers the critical behavioral constraints: configuration-only results and manual pagination. The main remaining gap is explicit differentiation from the singular lead 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 the schema already documents all three parameters. The description adds meaningful pagination semantics around the opaque cursor and explicit page calls, but does not further explain adAccountId or limit 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 clear verb and resource: reading Reddit lead gen forms, including configuration and status. It does not explicitly distinguish this list-style tool from the singular sibling reddit_get_lead_form, leaving a small ambiguity for selection.

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 clarifies that only form configuration is returned and lead submissions are excluded, which implies the appropriate use case. However, it gives no explicit when-to-use guidance versus reddit_get_lead_form or other listing tools, and no exclusions beyond submissions.

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 read-only, idempotent, open-world, and non-destructive behavior. The description adds only the permission-scoping phrase 'accessible to the allowed Reddit ad account'; it does not add meaningful behavioral context beyond that, but 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 a single front-loaded sentence with no filler. Every word contributes to stating the resource and scope.

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 paginated list endpoint, the structured fields are rich: annotations cover safety, the schema documents pagination, and an output schema exists. The description is sufficient, though it could briefly clarify that 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?

Schema description coverage is 100%, so the schema already explains adAccountId, limit, and cursor in detail. The description adds no parameter-level meaning beyond the schema, which is the baseline expectation at full 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 states a specific verb and resource ('List pixels') plus scope ('accessible to the allowed Reddit ad account'). It is clear what the tool does, though it does not explicitly distinguish itself from any sibling tool.

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

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

The description implies the tool is for listing pixels in an allowed ad account, but it gives no explicit when-to-use guidance, no exclusions, and no alternatives. An agent must infer usage from the purpose sentence 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 readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds a modest authorization constraint (profile must be attached to adAccountId), but that same constraint is already spelled out in the schema's id/adAccountId descriptions, so little new context is contributed.

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 the action front-loaded and no filler. The trailing 'after profile ownership verification' clause is slightly awkward but still earns its place as a precondition.

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 both required parameters are fully documented in the schema. The remaining gap is the unresolved relationship to reddit_get_posts, which the description leaves 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%, including the pattern and the a2_ prefix guidance for adAccountId, so the schema carries the parameter burden. The description only alludes to ownership verification and adds no syntax or format detail 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 and resource: 'Read an ad structured post.' The singular scope distinguishes it reasonably from the plural sibling reddit_get_posts, though the description never names that sibling to make the contrast explicit.

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?

'After profile ownership verification' gives a precondition, implying this is a follow-up read rather than a discovery call. However, there is no explicit statement of when to use this versus reddit_get_posts or how to satisfy the verification 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 readOnly, idempotent, non-destructive behavior, so the description's added value is the scoping constraint: the receipt is signed and bound to the account/process that created the job. That is meaningful ownership/authorization context beyond the structured fields. It doesn't describe job state transitions or polling backoff, but the output schema covers the 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?

Two sentences, no waste, with the core action front-loaded ahead of the ownership caveat. Nothing in it is 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 two-parameter poll operation with a rich output schema and full annotation coverage, the description supplies what's missing: the receipt's provenance and its account scoping. Only polling cadence or expected job states would add more.

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 fully documented in the schema (including the seven-day receipt validity and the a2_ account ID pattern). The description only restates that the receipt is a signed job receipt, adding little 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 its job receipt. This clearly distinguishes it from the plain reddit_get_post sibling, though it never names that sibling explicitly. An agent can identify the operation without reading the schema.

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

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

It signals the usage context (polling a job you previously created) and includes an explicit exclusion: it does not accept arbitrary job IDs from another account. It stops short of naming the alternative tool an agent should use if it just wants a post by ID.

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. The description adds that posts carry native image/video/carousel/text configurations, but with an output schema present that return-shape detail is largely redundant and no pagination or scoping behavior beyond the profile link 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 the core scope (posts for a profile) front-loaded and no filler. Nothing is wasted or buried.

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 paginated list tool with full schema coverage and an output schema, the description covers the essential scope. It could be stronger by naming the sibling that fetches a single post, but nothing needed to invoke 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%, with adAccountId, profileId, limit, and cursor all documented in the schema itself, including cross-references to reddit_get_profiles. The description adds no parameter-level meaning, 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 ('List') and resource ('advertising structured posts') scoped to a profile, so the agent knows what entity is being enumerated. It does not distinguish itself from the sibling reddit_get_post (singular), which is the most likely source of confusion among 30+ 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?

There is no statement of when to use this tool versus reddit_get_post, reddit_list_ad_creatives, or reddit_get_creative_assets. The only implied guidance comes from the resource name itself; no exclusions, prerequisites, or alternative routing 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, open-world and non-destructive, so the safety profile is covered. The description adds the ownership constraint (catalog must belong to the ad account's business), which is genuine context, but says nothing about pagination behavior or result 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?

A single sentence with no filler, leading with the verb and resource. Nothing is repeated from the schema or annotations, so every word earns its place.

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

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

With an output schema, full annotation coverage and 100% schema description coverage, the description only needs to orient the caller, which it does. The minor gap is that it never mentions paging or what a product record contains beyond the implicit reliance on 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 100%, so limit, cursor, catalogId and adAccountId are all fully documented in the schema, and the cursor field already explains the paging model. The description only reinforces that catalogId and adAccountId travel together, adding little beyond structured data – 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?

States a specific verb (read) and resource (products) and scopes it to a catalog owned by the ad account's business, which separates it from reddit_get_catalogs and reddit_get_product_sets. It does not explicitly name the siblings, so an agent must infer the boundary rather than being told 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 reader deduces you need a catalogId belonging to the ad account's business. There is no explicit when-to-use, when-not, or named alternative in the description; the helpful pointer to reddit_get_catalogs lives in the schema, not here.

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 fully covered. The description adds the ownership/permission constraint that the catalog must belong to the ad account's business, which is useful context, but says nothing about pagination behavior or the result 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?

It is a single front-loaded sentence with no waste. It is tight, though the brevity leaves out guidance an agent would benefit from rather than being optimally compact.

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 output schema and 100% param coverage relieve the description of documenting return values and pagination. What is missing is the practical context: when to prefer product sets over products or catalogs, and what a product set represents in the catalog hierarchy. That is an adequate-but-gapped definition.

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%: the schema documents the limit/cursor pagination, catalogId, and adAccountId, including the a2_ prefix and the REDDIT_ADS_ACCOUNT_IDS source. The description only reinforces the catalog-to-ad-account ownership relationship. 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?

It states a specific verb ('Read') and resource ('product sets'), and scopes it to a catalog owned by the ad account's business. That distinguishes it from reddit_get_catalogs and reddit_get_products, though it doesn't explicitly name those siblings as alternatives.

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

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

The description gives no when-to-use guidance, no prerequisites, and no routing to reddit_get_catalogs or reddit_get_products. The ownership scoping is a constraint, not usage guidance.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so safety is covered. The description adds the useful scoping fact that results are limited to profiles accessible to the allowed ad account, but says nothing about pagination behavior 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?

A single front-loaded sentence with zero waste. It is perhaps too terse for the scope it needs to convey, but nothing is padding.

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 and annotations relieve some burden, but the description never clarifies what a 'profile' is in Reddit Ads terms or how it relates to targeting/audiences, which matters in a sibling set this dense.

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, adAccountId all documented including the a2_ prefix and cursor opacity), so baseline 3 applies. The description adds no parameter-level 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?

Clear verb+resource: lists profiles scoped to an ad account. The resource (profiles) is distinct from every sibling (campaigns, ads, audiences, pixels, etc.), though the description never explicitly contrasts with them.

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

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

No when-to-use, when-not-to-use, or alternative routing. An agent knows what the tool returns but not under what circumstances to prefer it over, say, reddit_get_targeting or reddit_get_custom_audiences.

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 well covered. The description adds a scope boundary around targeting, but it does not disclose other behavioral context such as whether the schema is static or dynamic, nor does it mention rate limits or auth requirements.

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

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

The description is a single efficiently structured sentence that front-loads the tool's purpose and then adds a precise exclusion. Every clause carries useful information with no redundancy.

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

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

The tool has an output schema, so the description need not explain return values, and annotations already cover safety traits. The description provides enough scope and sibling differentiation for an agent to call it correctly, though it could be slightly more explicit about how the reporting schema relates to reddit_get_insights.

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 explain. The baseline for zero-parameter tools is 4, and the description does not need to compensate for missing parameter documentation.

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,' making clear that the tool returns reporting schema metadata. It distinguishes the tool from reddit_get_targeting by stating that configured targeting is read elsewhere and should not be inferred from reporting, though it lacks an explicit verb like 'retrieve' or 'list.'

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

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

The description explicitly names an alternative (reddit_get_targeting) for configured targeting and clarifies that such data is not available through this reporting schema. However, it does not explicitly state when to use this tool, such as when constructing reporting queries or interpreting available metrics, leaving that use case implied.

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 one useful behavioral note - that it verifies ownership by adAccountId - but does not say what happens on a mismatch (error vs empty). Given annotation coverage, a 3 is appropriate.

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 the core action front-loaded and no filler. 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 2 required params, full schema coverage, an output schema, and complete annotations, the description supplies what's needed to call it correctly. The only minor gap is not describing the ownership-verification failure behavior.

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

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

Schema coverage is 100%, so both parameters (id, adAccountId) are fully documented in the schema itself, including the a2_... format note. The description adds no parameter detail 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 ('one Reddit saved audience'), scoped to exactly one item, which implicitly distinguishes it from the plural reddit_get_saved_audiences sibling. It does not explicitly name that sibling, but the singular scope makes the distinction inferable.

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 saved audience by id within an ad account) but there is no explicit when-to-use, when-not-to-use, or named alternative such as the list tool or the custom-audience tools. An agent must infer the 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 read-only, idempotent, non-destructive, so safety needs no restating. The description adds genuinely non-obvious behavior: pagination returns an opaque cursor and each subsequent page requires a separate call (no auto-pagination), which an agent cannot infer from annotations or schema alone.

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 the core purpose front-loaded and behavioral detail following. Minor redundancy with the schema's cursor/next_cursor wording, 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 covers return values and annotations cover the safety profile, so the description only needs purpose and pagination semantics — both are present. The absence of any account-scoping or sibling-routing note is the only meaningful gap for a list tool with one required parameter.

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, establishing the baseline of 3. The description's only parameter-adjacent content is the opaque-cursor statement, which the cursor schema field already explains.

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 saved audiences') and names what the payload contains (native configuration, configured/effective status). It is clearly a list-all operation, but it never explicitly contrasts itself with the singular reddit_get_saved_audience sibling, which is the main ambiguity an agent could hit.

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: 'Read ... saved audiences' plus a pagination note tells an agent this is a listing call. There is no explicit statement of when to prefer this over reddit_get_saved_audience or any prerequisite/account-scoping 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 readOnly, idempotent, non-destructive and openWorld, so the safety profile is covered. The description adds substantive scope disclosure beyond that: it tells the agent this document carries prerequisites, unit conventions, renaming behavior and known limits — the exact things an agent would otherwise mis-plan around. Return shape is left to the output schema, which exists.

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, no filler, with the content inventory first and the call-to-action second. 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 and no parameters, the description only needs to establish purpose and timing, which it does. The one remaining gap is not positioning this against the two other schema/guide-style siblings, which an agent choosing among three meta tools would want.

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 there is nothing to disambiguate; baseline applies. Nothing in the description conflicts with the 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?

Names the resource precisely (setup guide for the Reddit connector) and enumerates its scope: coverage, prerequisites, units, renaming, known limits. That content list implicitly distinguishes it from every sibling, which are all data-fetching tools, though it never explicitly contrasts with reddit_get_write_schema or reddit_get_reporting_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?

"Read it before planning writes or answering what this server cannot do" gives a clear triggering condition tied to two concrete situations. It stops short of telling the agent when to prefer reddit_get_write_schema or reddit_get_reporting_schema instead, which are the closest alternatives.

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

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

Annotations already declare read-only, idempotent, and open-world behavior. The description adds valuable context that the output is configuration (not delivery data) and enumerates the targeting components, which helps the agent interpret results. No auth or rate-limit details, but those are not expected given 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 sentences, front-loaded with the main purpose and a concise clarification. Every sentence earns its place with no redundancy.

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

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

An output schema exists, so return values need not be explained. Annotations cover safety and idempotency. The description enumerates targeting fields and clarifies the data type (configuration vs. delivery), making the definition complete for correct invocation.

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

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

Schema description coverage is 100%, and both parameters (adAccountId, adGroupId) are fully documented in the schema. The description does not add any meaning beyond what the schema already provides, 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?

States a specific verb ('Read') and resource ('actual ad-group targeting') and enumerates the targeting fields. It distinguishes configuration from delivery demographics, but does not explicitly name the sibling tool reddit_get_targeting_options, leaving some inference to the agent.

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 clear context: use to read actual targeting configuration, not delivery demographics. The contrast with 'delivery demographics' serves as an exclusion, but no explicit alternative tool or when-not-to-use condition is 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 establish read-only, idempotent, open-world behavior, so the description's job is to add non-obvious traits. It does: pagination for large lists and the fact that results may be explicitly marked partial (truncated), which is meaningful for a lookup agent. Permissions or rate-limit behavior are not mentioned, keeping it below 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 short, front-loaded sentences with no filler. It is efficient, though the terseness means the search and pagination notes read as asides rather than organized guidance.

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

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

With a full schema, rich annotations, and an output schema, the description does not need to explain return values. Still, for a six-parameter tool spanning six targeting kinds, it omits any hint about which kinds accept country or query, leaving the agent to infer from the schema alone.

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

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

Schema description coverage is 100%, so the schema already documents kind, limit, query, cursor, country, and adAccountId in detail. The description only re-touches two of them (search for communities, pagination), adding marginal value over the structured fields, so baseline 3 is correct.

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 ('discover valid native targeting values'), so an agent can tell this is a value-lookup endpoint. However, it never contrasts with the similarly named sibling reddit_get_targeting, which is the most likely confusion point.

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?

'Communities can be searched' and 'large lists are paginated or explicitly marked partial' imply when the query/cursor parameters matter. But there is no explicit guidance on when to choose this tool over reddit_get_targeting or when not to use 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, and the description correctly reinforces that this is a pure schema lookup rather than a mutation. It adds genuinely useful context beyond the annotations: the schemas are 'pinned' and native, and local validation succeeding does not guarantee provider acceptance — a real behavioral caveat for anyone building write payloads.

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, both load-bearing: the first establishes what is returned and its scope, the second states the validation-versus-acceptance caveat. Nothing is padded and the scope statement is front-loaded.

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

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

With an output schema present, the description need not explain return values, and a single fully documented parameter plus read-only annotations keeps the burden light. The one remaining ambiguity is the phrase 'all implemented' — it implies some operations in the enum may not be backed by a real schema, which an agent would want stated outright.

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 operation enum lists all 18 values with an inline description, so the schema does the heavy lifting and baseline 3 applies. The description adds only a loose framing ('all implemented campaign/ad formats', 'including targeting') without clarifying what 'implemented' means or how the returned schema is keyed.

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 precisely ('exact pinned native schemas for Reddit creation and edits') and scopes it to targeting and implemented campaign/ad formats, so an agent knows this returns schema documents, not data. It does not name its closest sibling (reddit_get_reporting_schema), so the read-vs-write schema split must be inferred from the phrase 'creation and edits'.

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

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

Usage is only implied: the framing as 'schemas for creation and edits' suggests calling it before a write, and the note that 'provider acceptance is separate from local schema validation' hints at the pre-flight workflow. There is no explicit when-to-use statement, no exclusion, and no pointer to reddit_get_reporting_schema or reddit_get_setup_guide for the non-write cases.

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, so safety is covered. The description adds real behavioral context that annotations cannot: API access is not proof of delivery or full objective eligibility, warning the agent not to over-interpret a successful result. It does not mention auth failure modes or rate 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?

Two sentences, no waste, with the read scope front-loaded and the eligibility caveat immediately after. 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?

An output schema exists, so return values need not be explained, and the one required parameter is fully specified in the schema. What is missing is explicit framing of this as a prerequisite/validation step, which the 'health_check' name implies but the description never states.

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 single parameter is well documented, including the pattern and the explicit warning that it is the ad account ID (a2_...), not the business ID. The description adds nothing further about the parameter, so the baseline 3 is correct.

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: ad account, business, currency, timezone. This distinguishes it from the many reddit_get_* object-fetching siblings, though the name 'health_check' suggests validation while the description describes a plain read – a small friction an agent must reconcile.

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 infers this is a pre-flight/account-validation call to run before other Reddit operations. There is no explicit 'use when' statement, no mention of prerequisites (e.g., run before reporting), and no named alternative or exclusion.

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 meaningful behavior beyond them: media URLs are returned but never downloaded, and a video cover does not represent its motion/audio. That is exactly the kind of non-obvious output semantics an agent needs. It stops short of covering pagination behavior or the per-call 20-ad resolution cap (left to 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?

Three short sentences, front-loaded with the resource and followed by the two operational caveats; nothing is wasted. Minor deduction for the vague opener 'with explicit coverage', which reads as internal jargon rather than information.

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

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

With an output schema, full parameter coverage and read-only annotations, the description only needs to carry the non-obvious semantics, and it does (URLs not downloaded, cover vs full media). The remaining gap is not naming the sibling tool that overlaps with this one.

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 adIds, limit, cursor and adAccountId are fully documented in the schema, including the 'at most 20 resolved per call' cap. The description adds no parameter-level meaning, 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 ('Resolve') and resource ('ad-linked image/video/carousel assets'), which an agent can distinguish from the list/get siblings reasonably well. However it never mentions the near-neighbor reddit_get_creative_assets, and 'resolve ... with explicit coverage' is jargon that partly obscures what a call actually returns.

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: 'use full media when available' tells the agent to prefer full motion/audio media over a cover, but there is no explicit when-to-use statement or routing against reddit_get_creative_assets, reddit_get_ads, or reddit_get_ad for the same assets. An agent can infer the context but not the alternatives.

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