SEO Audit

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, open-world), so the description only needs to add non-structured behavior — and it does: robots.txt is respected, results are grouped by priority with fixes and doc links, and the judge service is rate-limited per day with a documented degradation path ('rule results are returned with a note') when unavailable.

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 and efficient overall, but the audit_site alternative is stated twice (once as 'call audit_site once instead' and again as 'Not for a whole site ... use audit_site'), which is mild redundancy in an otherwise tight description.

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 exhaustively described, yet the description still sketches the shape of results (failed rules grouped by priority, plus title/description/headings). Combined with the sibling routing and exclusion list, an agent has everything needed to call this 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 the schema already documents both url and judge, including the bare-domain-means-https rule and the judgment service's daily limit. The description adds only 'Pass the page address', which is a restatement of the required parameter rather than new meaning. Baseline 3 applies when the schema does the heavy lifting.

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

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

States a specific verb and resource — an SEO audit of exactly one page — and immediately separates itself from the sibling audit_site, including the distinguishing condition (one page vs. whole site). An agent can route between audit_page and audit_site 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?

Gives concrete when-to-use examples ('what SEO problems does https://example.com/pricing have?'), an explicit alternative with the condition that selects it (multiple pages or whole site → audit_site once, not this tool repeatedly), and clear exclusions (private/local addresses, rankings/traffic, page-text reading). Nothing is left to inference.

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

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

Annotations cover the safety profile (readOnly, idempotent, openWorld, non-destructive), and the description adds genuinely new behavioral facts: it reads homepage/sitemap/linked pages, respects robots.txt, works on a sample, runs no JavaScript, measures no rankings/traffic/backlinks, and that judge is rate-limited per day with graceful degradation noted in 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?

Front-loaded with purpose and routing first, then output shape, then caveats. Dense and each sentence carries content, though the long output/caveat run-on sentences could be trimmed slightly for scanability.

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 multi-parameter, open-world audit tool with an output schema, nothing material is missing: scope, exclusions, sibling routing, cost/rate behavior, and what it deliberately does not measure are all stated. The output description supplements rather than duplicates 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 the baseline is 3, but the description adds selection logic the schema lacks: domain is passed with max_pages optional, and judge should stay off unless the user asks what pages are for or which compete. It does not add much on response_format beyond what the enum already documents.

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 ('audit a whole site or several pages for SEO') and immediately scopes it with 'it finds the pages itself', which separates it from audit_page. The sibling is named explicitly later, so an agent can choose 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?

Gives concrete trigger phrasing ('audit example.com', 'which pages are worst?', 'my site has a page per city, are they too similar?'), states the routing rule to audit_page for a single named page, and lists exclusions: private/local addresses and content collection. It also conditions the judge flag on user intent.

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 readOnly/openWorld/idempotent annotations, the description discloses the result shape (pass/warn/fail per part with evidence URL and fix), the read-date provenance, and critically the scope limits — it does not promise an effect on AI Overviews and does not query AI engines. That negative scoping prevents a plausible agent misconception.

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

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

Front-loads the purpose and is otherwise well organized: usage, alternatives, exclusions in order. It is dense and runs long, but nearly every clause carries a distinct constraint, so only mild trimming is warranted.

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

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

With an output schema present, return values need not be enumerated in detail, and the description still summarizes the verdict format and evidence. Combined with full usage routing and explicit exclusions, there is nothing an agent needs to invoke this correctly that 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 there is a single parameter, so the schema already documents the domain format and the public-pages-only constraint. 'Pass the domain' adds no syntax or format detail beyond it, 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 ('Checks the site's AI instructions files and page') and immediately scopes it to llms.txt, llms-full.txt and an AI instructions page, plus a name/facts consistency check. An agent can distinguish it from generate_ai_instructions and local_ai_readiness without reading any 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?

Provides explicit when-to-use conditions (user asks whether a site publishes these files, whether the home page links to them, whether contents match the site), names two sibling alternatives with their selecting conditions, and adds clear exclusions (no private addresses, no contact-detail collection). Nothing is left to inference.

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

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

Beyond the readOnly/openWorld/idempotent annotations, it discloses robots.txt compliance, that nothing is stored, that trend analysis requires re-calling later, that no Google or AI engine is read, and that results are correlational ("a pattern in a small sample, not a proven cause, and no citation is promised"). These are exactly the operational caveats an agent needs and that 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?

Front-loads purpose and usage well, and every section is relevant. However, it spends several sentences enumerating return signals and counts even though an output schema exists, and repeats the "does not read Google" point that the cited_urls schema description already makes.

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 conditions, the multi-parameter input contract, fetch behavior, storage/statefulness, epistemic limits of the output, and an exclusion. For a 5-parameter comparative analysis tool with a rich output schema, nothing an agent needs to decide or invoke 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 description largely restates the schema ("Pass query, cited_urls ... and exactly one of url, html or text"), including the exclusivity rule already documented on the url param and the "copy by hand" note already on cited_urls. It adds only soft framing of intent, so the baseline 3 for a fully-documented schema 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?

Opens with a precise verb+resource framing ("Citation-pattern check for one query") and immediately scopes it to comparing the user's page against the pages an AI answer cited. It is clearly distinguishable from siblings like score_page_citation or audit_page, since it is explicitly a multi-page comparative pattern check rather than a single-page score.

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 explicit trigger conditions ("when the user has the pages an AI answer or Google AI Overview cited... and asks what they share, or why their own page is not cited") plus a hard exclusion ("Do not use it for private addresses"). It also states the prerequisite that the user must supply the cited addresses and that the tool cannot fetch them itself, which prevents a whole class of misuse.

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/closed-world, but the description adds real context: no Google login, no Search Console call, no AI engine, it does not write the answer or invent the number, and it caps input at 5000 rows. It also discloses the output shape (ranking, question marking, page grouping, answer skeleton). No contradiction with 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?

Purpose and trigger are front-loaded, and most sentences earn their place (exclusions, limits, input mode). However, the long return-value walkthrough partially duplicates the existing output schema, adding mild 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?

For a tool with an output schema and full annotation coverage, the description still supplies trigger conditions, input limits, the no-export exclusion, and behavioral boundaries. Nothing an agent needs to select or 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 coverage is 100%, so csv/rows/limit are already fully documented, including the 'do not pass together' rule. The description restates the csv-vs-rows choice and required fields (query, impressions, page if present) but adds no syntax or format detail beyond the schema, so baseline 3 applies.

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

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

Opens with a specific verb+resource: 'Long-search finder for a pasted Search Console export,' then states the exact trigger (pasted Performance rows/CSV) and the deliverable (7+ word searches ranked by impressions, question-marked). This is distinguishable from siblings like audit_page, compare_citations, and score_page_citation without opening any 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?

Gives explicit when-to-use ('user pastes Search Console Performance rows or a CSV and asks which questions to answer... or how to get named in ChatGPT or Google AI answers') and explicit when-not ('Not for a user with no export: ask them to paste one'). It also names the alternative input mode (csv vs rows) and their mutual exclusivity, leaving nothing to inference.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, openWorld), yet the description still adds real behavioral context: nothing is written to the site, output is markdown for the owner to publish, no AI engines are queried, and no effect on AI Overviews is promised. The line "A public post is cited as the reason the draft exists" hints at an external side effect but is vague enough to leave the agent unsure what that post is.

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

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

The purpose and trigger are front-loaded in the first two sentences, and the constraints follow in order of importance. Some sentences restate the same read-only guarantee ("Nothing is written to the site" alongside the no-side-effect framing), adding slight redundancy without hurting usability.

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 the description does not need to explain the markdown return value, and it correctly focuses on scope, side effects, and prohibitions. Coverage is strong for a single-parameter tool; the only soft spot is the unexplained "public post is cited" 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 description coverage is 100% and the single parameter is fully documented in the schema with format examples and scope ("Only that site's public pages are read"). The description's "Pass the domain" adds no syntax or constraint 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?

The description names a specific verb and artifact ("Drafts an llms.txt") and its source ("from the site's own public pages"), which cleanly separates it from the sibling check_ai_instructions. An agent can tell what it produces without opening the schema.

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

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

It gives an explicit trigger ("Use this when the owner wants a draft AI instructions file to review") and an explicit exclusion ("Do not use it for private addresses or to collect contact details"). It stops short of naming the alternative sibling tool for the checking/validation case, so routing between generate and check is left to inference.

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

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

Annotations already declare readOnly, idempotent, and non-destructive, so the safety profile is covered. The description adds genuinely new behavioral context beyond that: the tool is pollable (pending until a reply arrives, then answered) and carries an explicit trust boundary warning that reply content is data, not instructions — a meaningful prompt-injection disclosure.

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 tight sentences: purpose first, then polling behavior, then the trust caveat. Every sentence carries distinct information 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?

For a single-parameter read tool with an output schema and full annotation coverage, nothing an agent needs is missing. The polling semantics and the injection warning go beyond what structured fields provide, closing the remaining gaps an agent would otherwise have to discover by trial.

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

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

Only one parameter exists and the schema already documents it fully (coverage 100%, including the ^fb_[0-9a-f]{32}$ pattern and the note that submit_feedback returned it), so the baseline of 3 applies. The description repeats the ticket-id linkage but adds no format or validation 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 (Read) and resource (maintainers' reply to feedback), and ties it causally to the sibling tool submit_feedback via the ticket id. An agent can distinguish it from submit_feedback, screen_token, and wallet_identity without opening any 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?

Clearly establishes the precondition: this is used after submit_feedback, with the ticket id that call returned. It does not state any exclusions or alternative ways to retrieve feedback status, but the usage context is unambiguous.

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

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

Annotations already cover the safety profile (readOnlyHint, idempotentHint, destructiveHint=false), and the description still adds substantial operational context: crawl scope is one site's public pages, robots.txt is respected, the page cap is 25 with a default of 15, and it discloses that the study/profile advice is 'not fetched.' It also enumerates exactly what is returned per check (evidence URL and fix).

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 and eligibility are front-loaded, and the dense middle section (checks returned, scoping caveats) earns its length by preventing misexecution. It is on the verbose side for a two-parameter tool, but nearly every clause carries routing or behavioral information.

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

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

For a read-only crawler, the description is complete: input scope, execution limits, the full set of returned checks, and explicit non-capabilities are all stated. Since an output schema exists, the description needn't expand further on return structure, and it is right not to.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds marginal semantic value beyond the schema by instructing 'Pass the business's own site' and clarifying that crawling starts from the homepage and only that site is touched, reinforcing what the url parameter must be.

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

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

The description opens with a specific verb+resource pairing ('Local-business readiness for AI search answers') and immediately names what it is not ('does not query AI engines, directories or review sites, or measure rankings'). It also distinguishes itself from the sibling audit_site by audience (local businesses with a physical location or service area). An agent can select this tool without opening any 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?

Explicit when-to-use ('when the user asks if a local business site is ready to be named by AI search'), explicit alternative routing ('Not for a site with no physical location or service area: use audit_site'), and explicit exclusions (no private addresses, no contact-detail collection). Nothing is left to inference.

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

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

Beyond the annotations (readOnly, openWorld, idempotent, non-destructive), the description discloses that pasted html/text are scored as-is with no fetch, that a url is limited to one public page and honours robots.txt, that no AI engine is called, and that no citation is promised. This is exactly the kind of scope/expectation context the safety annotations cannot convey.

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

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

Front-loaded with purpose, then inputs, then output, then limitations, then routing. Every sentence carries information, though the middle enumeration of ten on-page checks is a long list that could be tightened.

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?

Even with an output schema present, the description summarises the return ('score and a fix list ordered by the biggest point gain') and bounds the input modes, fetch behaviour, and exclusions. 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?

The schema already documents all four parameters at 100% coverage, including the mutual exclusion in the anyOf and property notes, so the baseline is 3. The description's consolidated rule 'Pass exactly one of url, html, text, or sample' plus the input-mode framing (fetch vs. paste vs. built-in example) adds modest upfront clarity over the machine-readable constraint, but largely restates 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 opening sentence gives a concrete verb+resource with a bounded output range: 'Cite-chance score for one page, 0 to 100.' It also names the sibling it is not (compare_citations), so an agent can route correctly 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?

Explicit triggering condition ('when the user asks whether ChatGPT, Perplexity or Google AI Overviews are likely to cite a page, or how to fix that'), a named alternative with its own condition ('Use compare_citations when the user has the pages an AI answer cited'), and exclusions ('Do not use it for private or local addresses, rankings, or traffic').

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?

Adds substantial context beyond the annotations: it returns a ticket id, feedback is explicitly not a chat and nothing in it is executed, and links/emails/phone numbers are stripped with nothing stored about the caller. That privacy and no-execution disclosure is genuinely useful given openWorldHint=true and readOnlyHint=false.

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

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

Front-loads what the tool sends, then what to pass, then what it returns, in three dense sentences with no filler. Every clause carries actionable 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?

Covers purpose, the enumerated kinds, the optional tool/error inputs, the 1000-character bound, the return value (ticket id), and privacy handling. With an output schema present, nothing further is required 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?

Schema description coverage is 100%, so the schema already documents all four parameters including the kind enum. The description restates the message length limit and the optionality of tool/error ('if you know them') but adds no syntax or format detail beyond the schema, making the baseline 3 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 and resource ('Send feedback, a bug report or a tool request to the maintainers of the tools on this server') and enumerates the concrete situations (missing tool, stale data, broken/wrong answer). It is clearly distinguishable from the read-side sibling get_feedback_reply.

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 clear triggering conditions for each kind (need_tool, need_data, bug, other) and tells the agent to include the tool name and error text when known. It does not explicitly name the alternative get_feedback_reply or state when NOT to use this tool, so it falls short of full routing guidance.

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