Recordsure website

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint=false, so the safety profile is covered. The description adds the useful detail that output is pre-formatted citation bullets rather than raw results, but it does not explain what 'clean' means (deduplication, filtering?), how top_n interacts with per_page, or whether paging is possible.

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 padding. It is efficient, though 'query context' is slightly vague where 'query string' would be sharper.

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

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

There is no output schema, so the description carries responsibility for explaining the return value, and it only gestures at it ('clean source links and markdown citation bullets'). For a read-only retrieval tool that is mostly adequate, but the interaction between the two paging parameters and the exact return structure are missing.

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

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

Schema coverage is 100%, so both integer parameters are formally documented, and the description's 'query context' only echoes the schema's 'search phrase used to collect source links.' With the schema doing the work, baseline 3 applies, and notably the top_n vs per_page relationship is left unexplained in both places.

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 concrete verb and resource: returns source links plus markdown citation bullets for a query. The output shape (clean links, markdown bullets) is specific enough to distinguish it from siblings like search_content or get_page_content_with_schema, though it never names those 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 signal about when to call this instead of search_content, search_documents, or search_enriched_page_contexts, all of which overlap with the query-search pattern. An agent is left to infer the choice from tool names alone.

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

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

Goes well beyond the annotations: it discloses that unpublished facts are omitted, that hours/routes are quoted as published rather than promised, that no personal data is accepted and nothing is sent, and that non-card clients get a text fallback. These are exactly the behavioral traits an agent needs and that readOnlyHint/idempotentHint do not 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?

Front-loaded with the usage trigger, then follows with scope and behavioral caveats. It is dense and slightly long-winded in the middle clause, but every sentence contributes a distinct fact rather than repeating the schema or annotations.

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, yet it still summarizes card contents and the text fallback. Combined with the annotation profile, nothing an agent needs to select or call this tool is missing.

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

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

Zero parameters, so the baseline is 4; the description reinforces this with 'Takes no arguments', confirming the empty schema. No additional parameter detail is possible or needed.

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 ('show contact options as a card') and immediately distinguishes it from the sibling get_contact_options by noting it presents the same facts in card form. An agent can tell the two apart without opening either schema.

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

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

The opening clause gives a clear trigger ('when a person asks how to get in touch ... and would like to see it as a card'), and the sibling get_contact_options is named as the source of the same facts. It stops short of explicitly stating when to prefer get_contact_options instead, leaving the converse to be inferred.

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

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

Beyond the annotations (readOnly, idempotent, non-destructive, openWorld=false), it discloses that unpublished facts are omitted, that hours/routes reflect the site rather than a promise of availability, and — crucially — that no personal data is accepted and nothing is sent because the user completes the enquiry themselves. That is substantial behavioral context the annotations cannot carry.

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

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

Purpose is front-loaded in the first sentence, followed by usage and then caveats. Slightly wordy in the final clause, where 'sends nothing' and 'the person completes any enquiry on the contact page themselves' partly overlap, but no sentence is wasted.

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

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

An output schema exists, so return-value detail is not needed, and annotations already cover the safety profile. Combined with the no-argument note and the omissions/no-side-effects caveats, the description is complete for an agent to call it correctly.

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

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

Zero-parameter tool, so baseline is 4; the schema is fully specified (additionalProperties false) and there is nothing for the description to disambiguate. It correctly notes 'takes no arguments', reinforcing 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?

States a specific verb and resource ('how a person can contact this organisation') and enumerates the concrete outputs: contact page address, enquiry routes, email, telephone, office hours. This clearly distinguishes it from siblings like get_contact_card or get_person_profile.

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

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

'Use it when a person asks how to get in touch' gives a clear triggering context. It does not explicitly exclude near-neighbors (e.g. get_contact_card, get_team_directory) or name alternatives, so it stops short of a 5.

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

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

Annotations already declare readOnly/idempotent/non-destructive and closed-world, so the safety profile is covered. The description adds genuinely non-obvious behavior beyond them: a missing document and an unpublished document return the identical not-found answer, which tells the agent not to infer publication state from the error.

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

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

Two sentences, zero filler, and the identifying purpose plus the sibling linkage come first. The behavioral caveat is placed second where it belongs.

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?

Single required param, full schema coverage, output schema present, and annotations covering the safety profile. The description adds the return shape at a high level and the error semantics, leaving nothing an agent needs before calling it.

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

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

Schema coverage is 100% and the schema already carries the UUID pattern, so the baseline is 3. The description adds provenance the schema cannot: the id must be one that search_documents returned, which is the only real semantic risk with this parameter.

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

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

States a specific verb and resource (get one public document card plus its schema.org node) and scopes it to an id. It also names the sibling that produces that id (search_documents), so an agent can distinguish it from the search/browse tools without opening a schema.

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

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

Clear usage context: this is the follow-up call to search_documents, using an id from that result set. No explicit exclusions or comparison against alternatives such as get_page_content_with_schema or get_schema_context, so it stops short of 5.

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

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

Beyond the read-only/idempotent annotations, the description discloses the three-item cap, that unpublished documents are silently dropped, that an empty result mirrors get_document's not-found answer, and that clients without card support receive a text answer. These are non-obvious behaviors an agent could not infer from structured fields.

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

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

Front-loaded with the use case, then the input, then the fallback behavior, then the negative guidance. It is dense but every sentence carries distinct information; only the text-fallback sentence is mildly tangential.

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?

Covers trigger, input source, item cap, filtering of unpublished documents, empty-result semantics, and client-capability fallback. With an output schema present, no further explanation of return values is required.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaning the schema does not: the ids come from the id of each card, and the three-item limit is restated as a practical constraint. The UUID format itself is left to the schema, which 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 ('shows up to three of them as a carousel of cards') plus what each card contains. It also distinguishes itself from get_document and search_documents by naming both siblings directly.

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

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

Gives an explicit trigger ('when a person wants to see documents that search_documents or get_document returned') and an explicit exclusion ('Do not use it to find documents: call search_documents for that'). The alternative tool and the condition that selects it are both stated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds only that this is the primary navigation structure and does not explain return shape, hierarchy, or site scoping.

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

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

A single front-loaded sentence with no wasted words. It is appropriately sized for a simple read-only tool.

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

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

No output schema exists, so the description should clarify what the returned navigation structure contains. It identifies the resource but leaves the return shape and hierarchy unspecified.

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

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

There are zero parameters, so there is no parameter semantics to explain; the empty schema matches the description. Baseline 4 applies for a no-parameter tool.

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

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

States a specific verb and resource: return the primary navigation structure. It is clear what the tool does, though it does not explicitly distinguish itself from siblings such as get_site_info or list_pages.

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

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

Provides no when-to-use guidance, no exclusions, and no alternatives. An agent must infer that this is for site navigation rather than page content, site info, or page listings.

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

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

The annotations already establish that this is a read-only, idempotent, non-destructive, closed-world operation. The description adds that it returns both full textual content and published JSON-LD schema, which is useful beyond the annotations, but it does not disclose limits such as content size, truncation behavior, or whether schema may be absent.

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 wasted wording. The core resource and return content 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?

There is no output schema, but the description names the key return components: full page text and published JSON-LD schema. Combined with the fully documented input schema and safety annotations, this is close to complete, though it leaves identifier-selection behavior unclear.

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 url, slug, and page_id parameters are already documented. The description adds no parameter-level guidance, such as whether one identifier is preferred or whether multiple identifiers may be combined, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb and resource: it retrieves full page textual content plus published JSON-LD schema. That is clear enough to distinguish it from generic document or search tools, but it does not explicitly differentiate it from siblings such as get_schema_context or search_enriched_page_contexts.

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 "for grounded evaluation" gives an implied use case, but the description does not say when to use this tool instead of search_content, get_document, get_schema_context, or other page-content siblings. There are no exclusions or selection criteria.

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=false, so the safety profile is fully covered. The description adds two useful facts beyond that: only 'published' profiles are returned, and the payload is schema.org Person JSON-LD. It does not say what happens for an unknown or unpublished slug (empty result vs. error).

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 that front-loads the singular scope and the return shape, with no filler. Every clause carries information an agent can use.

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 one-parameter read tool with complete annotations and a rich schema, the description covers resource, scope, and output format. The remaining gap is not-found/unpublished behavior, which matters for a slug lookup but is a minor omission overall.

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 slug parameter's schema entry already explains the format with a concrete example derived from get_team_directory. The description only restates 'by slug', so 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 (get), a single resource (one team member profile), and the return format (schema.org Person JSON-LD), scoped to slug and to published profiles. 'One' implicitly contrasts with the sibling get_team_directory, but no sibling is named, 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?

The description gives no guidance on when to use this instead of get_team_directory or other siblings, and no prerequisites or exclusion conditions. The only routing clue (that the slug comes from a URL fragment found in get_team_directory) lives in the schema, not in the description.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds only the 'sitewide' scope, which is useful but minimal; it does not explain what 'schema context' contains or how it is shaped. With annotations doing the heavy lifting, this is adequate but thin.

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 wasted words. It is arguably too terse for an ambiguous concept, but structurally it is clean and efficient.

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

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

There is no output schema, so the description carries the burden of explaining what is returned. 'Organization schema context' is ambiguous — it could mean JSON-LD, SEO metadata, or site configuration — and the description does not clarify the return shape or contents. For a no-parameter read with no output schema, this leaves a meaningful gap.

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

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

The tool takes zero parameters, so there are no parameter semantics to document. The baseline for a parameterless tool is 4, and nothing in the description contradicts or complicates that.

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

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

The description names a verb and resource ('Return the ... Organization schema context'), so the basic action is identifiable. However, 'schema context' is jargon that isn't defined, and the description does not distinguish this from siblings like get_site_info or get_page_content_with_schema, leaving the agent to infer the difference.

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

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

There is no guidance on when to use this tool, when not to use it, or which sibling it replaces. The agent must guess based on the name alone whether this is for SEO metadata, structured data, or site configuration.

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=false, so the safety profile is clear. The description adds that it returns MCP server capabilities, which is useful context beyond annotations, but it does not detail what metadata is included or any caching/rate-limit behavior.

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

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

The description is a single, front-loaded sentence with no wasted words. It efficiently conveys the tool's purpose.

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

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

With no output schema and no parameters, the description should clarify what 'site metadata' and 'MCP server capabilities' entail. It provides only a high-level summary, leaving the agent to guess the exact return contents.

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

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

The tool has zero parameters, so there is no parameter semantics to document. The baseline for zero parameters is 4.

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

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

The description states a specific verb ('Get') and resource ('site metadata and MCP server capabilities'), making the tool's purpose clear. It does not explicitly differentiate itself from sibling tools, but its scope is distinct from content-retrieval 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 guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. The agent must infer that it is for retrieving site-level information.

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=false, so the 'Read-only' clause mostly restates structured data. The genuinely additive detail is that results are limited to published, featured, Core-managed profiles — a real scoping trait — but nothing is said about ordering, pagination, or what an empty directory means. Comparable to the calibration case where scope context without return detail earned a 3.

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

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

Two short sentences with the resource and its scope front-loaded; nothing is buried. The trailing 'like every other tool' adds little and partly duplicates what the annotations already establish.

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

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

A zero-parameter, non-destructive read tool with no output schema is adequately covered: the description says what entity set is returned and under what publication conditions. Only minor gaps remain around result shape and ordering, which are low-risk for a directory 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?

The tool takes zero parameters, so the schema baseline of 4 applies and there is no parameter semantics burden for the description to carry.

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 ('Get the ... team member directory') and narrows scope with 'published, featured' and 'Core-managed People profiles', which distinguishes it from the single-person get_person_profile sibling. It stops short of naming any sibling explicitly, so differentiation is inferred from the resource noun rather than stated.

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

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

The phrase 'Read-only and published-only' implies when the tool applies and excludes unpublished content, but there is no explicit when-to-use statement and no named alternative (e.g. get_person_profile for an individual, search_content for discovery). The agent must infer the routing.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and closed-world scope, so the safety profile is fully covered structurally. The description adds only modest value: the 'published' filtering constraint and implied pagination behavior, but says nothing about ordering, total counts, or how pages beyond the max are handled.

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

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

A single front-loaded sentence with zero waste and the scope constraint stated early. It is efficient but borders on under-specified for a tool with this many siblings.

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

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

There is no output schema, so the description could reasonably say what a page record contains or the shape of the paginated response. For a simple two-param list tool this is adequate, but the return-shape gap and missing sibling routing leave it only minimally 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%, so the baseline is 3, and the description only echoes that pagination exists. Both params are documented in the schema with generic text ('Integer value.') but defaults and min/max bounds give the agent enough to call correctly.

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 published WordPress pages') plus a scope qualifier ('published') and pagination. However, it does not distinguish itself from siblings such as list_posts or search_content, leaving the agent to infer the page-vs-post distinction from names 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?

No guidance on when to use this versus list_posts, search_content, or get_page_content_with_schema. The 'published' qualifier hints at a filter but never states exclusions or prerequisites (e.g. auth/site context).

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so the safety profile is covered. The description adds one genuinely useful behavioral fact — only *published* content is returned — but says nothing about pagination behavior, ordering, or result size despite page/per_page parameters existing.

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

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

A single front-loaded sentence with zero filler; the content types are named before the optional filter qualification. Nothing is repeated from the title or schema, and nothing could be cut without losing meaning.

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

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

For a zero-required-parameter list tool with rich annotations this is close to sufficient, but there is no output schema, so the description should indicate what a returned post contains (fields, ordering, pagination envelope) — that gap is left entirely to inference.

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 five parameters including the two enums are already documented in structured form. The description's 'optionally filtered by taxonomy' loosely maps to the taxonomy/term pair but adds no syntax, slug format, or interaction 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 (list) and resource (published posts/insights/case studies) with the filtering dimension named. It implicitly separates itself from list_pages and search_content by naming the exact content types, but it never explicitly contrasts with those siblings.

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

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

Usage is only implied: an agent can infer this is the browse/enumerate option versus search_content for keyword lookup, but the description never says when to prefer it or when a sibling is the better call. No exclusions or prerequisites 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 and non-destructive, so the safety profile is covered. The description adds two facts not in the structured data: only published terms are returned (unpublished ones are silently excluded) and each term carries a count. Neither the return shape nor the count semantics (e.g. count of what) is explained, 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?

One sentence, verb-first, zero filler. Both facts it contains (published scope, counts) are load-bearing.

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

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

A simple, idempotent read tool with one enum parameter, rich annotations and no output schema. The description covers what is returned at a high level (published terms with counts), which is the only thing the schema and annotations do not already say. Nothing needed to call it correctly is missing.

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

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

Schema description coverage is 100% and the single 'taxonomy' parameter has an enum, so the schema does the heavy lifting. The description adds no syntax or format detail for the parameter itself; the only extra meaning ('published') is a filter with no corresponding parameter. 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 (taxonomy terms) plus two scoping details: only published terms, and results include counts. It is clearly distinguishable from every sibling, none of which deals with taxonomies. It stops short of naming a sibling to contrast with, but none is a near-duplicate.

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

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

There is no guidance on when to reach for this versus search_content or get_schema_context, and no prerequisites or exclusions are stated. Usage is only implied by the word 'list'. An agent must infer that this is the enumeration tool for category/tag/sector/solution values.

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 closed-world, so the safety profile is fully covered structurally. The description adds only the scope of content searched, and says nothing about result ordering, pagination behavior, or empty-result handling.

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, correctly sized for a two-parameter read tool. 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?

For a simple idempotent read tool with a fully described two-parameter schema and complete annotations, the essentials are present. The gaps are the sibling-search ambiguity and the absence of any indication of what kinds of results come back, which matters since there is no output schema.

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

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

Schema coverage is 100% (query with min/max length, per_page with bounds and default), so the schema does the heavy lifting and baseline 3 applies. The description adds no meaning about query matching semantics or how per_page interacts with result sets.

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 (search) plus the resource classes it covers (public pages, posts, insights, case studies), which is more informative than the bare name. However, it draws no distinction from sibling search tools such as search_documents, search_enriched_page_contexts, or search_media_assets, so an agent cannot tell which search surface to pick from the description 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?

There is no guidance on when to use this tool versus the three sibling search tools, nor any statement of preconditions or exclusions. Usage can only be inferred from the loosely enumerated content types.

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, closed-world behavior, so the description's added value is the publication filter ('only published, open documents appear') and the explicit warning that results may be empty. That empty-result caveat is genuinely useful operational context. It stops short of explaining pagination or how multiple filters interact.

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

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

Four short sentences, front-loaded with what is searched and returned, followed by the filter options and the sibling hand-off. Minor redundancy in restating topic/sector as 'slugs' twice, but no filler.

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

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

With a rich annotation set and an output schema covering the return values, the description supplies the remaining essentials: scope, filter modes, the open/published restriction, and the follow-up tool. The one meaningful gap is whether filters combine (AND vs OR) and what limit does, which matters for a five-parameter search 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 every parameter is already documented in the schema, establishing a baseline of 3. The description reinforces that topic/sector are slugs and that page_url scopes to documents related to a page, but adds no syntax or format detail beyond what the schema provides and never mentions the limit parameter.

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

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

States a specific verb and resource with scope: 'Search the public documents (PDF files) that this website publishes', and specifies the return shape (document cards with schema.org nodes). It also names the sibling get_document as the follow-up for opening a single result, so an agent can distinguish it from search_content, search_media_assets, and get_document without opening a schema.

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

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

Enumerates three concrete invocation modes (topic/sector slugs, page_url relationship lookup, phrase query) and points to get_document for the drill-down step. It gives clear positive usage context but no exclusions — it never says when to prefer search_content or search_media_assets 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?

The annotations already establish that this is a safe, read-only, idempotent, non-destructive, non-open-world operation. The description adds useful behavioral context by saying results are enriched with full text and JSON-LD schema, but it does not explain ranking, pagination, or how top_n and per_page affect returned results.

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

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

The definition is a single front-loaded sentence with no redundant or filler content. It communicates the action, scope, and enriched return in a compact form.

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 search tool with three parameters and no output schema, the description gives only a high-level indication of return content. It does not clarify result ranking, pagination behavior, or how top_n and per_page interact, though the annotations adequately cover the safety profile.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the schema's parameter descriptions are generic. The description's phrase 'top matching' loosely suggests top_n, but it adds no concrete meaning for top_n or per_page beyond the schema's 'Integer value' descriptions.

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

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

The description states a specific verb and resource: search site content and return top matching page contexts. It also specifies the enrichment as full text and JSON-LD schema, which distinguishes the return shape from a plain search. However, it does not explicitly differentiate itself from close siblings such as search_content or get_page_content_with_schema.

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

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

The enrichment mention implies the tool is appropriate when full-text and JSON-LD page contexts are needed, but there is no explicit when-to-use or when-not-to-use guidance. With many search and page-content siblings available, the description leaves the agent to infer that this is the enriched variant rather than naming 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 readOnly, idempotent, non-destructive, closed-world behavior, so the description does not need to cover the safety profile. It adds genuine context beyond that: what gets filtered out (private and management records) and the return shape ('safe delivery variants plus schema.org MediaObject JSON-LD').

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 front-loaded with the eligibility criteria before the return-shape note; no filler. The phrase 'safe delivery variants' is slightly opaque but does not waste space.

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

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

With no output schema, the description usefully discloses the return payload, and annotations cover the safety profile. Pagination behavior and result ordering are left unstated, a minor gap for a paged search tool.

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

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

Schema coverage is 100%, so kind, query, cursor, and page_size are all documented in the schema itself. The description adds no parameter semantics beyond that baseline, so a 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 plus resource ('Search ... Media Assets') and qualifies the scope with three eligibility conditions (public, active, Core-managed). An agent can distinguish it from search_documents or search_content by resource type, though those siblings are never named.

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

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

The exclusion 'Private and management records are never returned' implies when this tool is and isn't appropriate, but there is no explicit guidance on choosing it over the many search_* siblings. Usage must be inferred from the resource noun alone.

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