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

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety is covered. The description adds a real behavioral trait beyond annotations — the operation is free and consumes no verification credits — which is precisely the kind of cost/rate context an agent needs when choosing among paid siblings. It stops short of saying what a missing or malformed record yields.

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 zero padding: the operation first, the cost caveat second. 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 no output schema, the description should convey something about what a check returns (pass/fail, expected vs found record) and the behavior of the optional selector. Those gaps are meaningful for a diagnostic tool, though low overall complexity keeps the impact moderate.

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 examples for both domain and selector, so the schema does the heavy lifting. The description names the selector parameter but adds no guidance beyond it, notably omitting what happens when the optional selector is left out.

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 (Check), a specific resource (a domain's DKIM signing record), and the scoping parameter (selector). The explicit 'DKIM' framing cleanly separates it from sibling record checks such as check_spf, check_dmarc, and check_mx without needing to name 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?

Usage is only implied: an agent can infer this is the tool for DKIM lookups, and 'Free — no verification credits' hints there's a cost tradeoff versus paid verification tools like verify_email. But there is no explicit when-to-use/when-not statement and no routing to alternatives such as check_domain_health for combined checks.

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 openWorldHint=true, so the safety profile is covered. The description contributes a genuinely new behavioral fact — 'Free — no verification credits' — which affects how an agent budgets calls, but says nothing about behavior when a domain has no DMARC record or about rate limits. Useful but thin beyond 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 tight sentence that front-loads the action and resource, then appends the cost note. Every clause 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?

For a single-parameter read-only lookup with full schema coverage and no output schema, the definition is nearly sufficient: it names the tool, its target, its return domain, and its cost. The one meaningful gap is what happens when no DMARC record is published, which an agent would want to know before interpreting a result.

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

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

Only one parameter exists and schema coverage is 100%, with the schema documenting 'domain' and giving an example. The description adds no syntax, normalization, or format guidance beyond that, so the schema is doing all the work. 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 (check) and a specific resource (a domain's DMARC policy), and even enumerates the possible policy outcomes (none | quarantine | reject) plus alignment. This cleanly separates it from siblings like check_spf, check_dkim, and check_mx, which target different records.

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

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

Usage is implied by the resource name and the note that it's free, but the description never says when to reach for this versus check_domain_health (which likely aggregates DMARC/SPF/MX) or how it fits a full domain audit. No exclusions or alternative routing are stated.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safe-read profile is covered. The description adds genuinely useful non-schema context: it is 'Free — no verification credits', which bears on cost-sensitive tool selection, and it discloses the return shape (a graded summary with findings). It does not mention rate limits or what happens on an unresolvable domain.

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 clauses with the aggregate purpose and scope front-loaded, followed by the cost note. Nothing is redundant and every clause earns its place.

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

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

For a single-parameter read tool with no output schema, the description covers what it does, what it aggregates, the rough return shape, and cost — enough to call it correctly. The grade scale and failure behavior for invalid domains are the only remaining gaps, and they are minor.

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 is a single required parameter whose schema description is fully covered ('The domain to inspect, e.g. example.com'). The prose adds no further semantics about the domain argument (e.g. subdomains, IDN, validation), so the schema carries the burden and 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 ('Run an overall email-deliverability health check for a domain') and makes clear it is an aggregate of MX, SPF, DKIM and DMARC. An agent can distinguish it from the sibling single-check tools (check_mx, check_spf, check_dmarc, check_dkim) 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?

The phrase 'combines MX, SPF, DKIM, DMARC and related signals into a single graded summary' implies this is the one-shot aggregate to use instead of calling the individual check_* siblings, giving clear usage context. It stops short of an explicit 'use this instead of X when Y' routing statement or naming exclusions.

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 and openWorldHint, so safety is covered; the description adds the valuable non-annotation detail that the call consumes no verification credits. It does not describe what the response contains (raw MX list vs. a boolean deliverability verdict), leaving some ambiguity.

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

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

Two short sentences, zero filler; the core purpose comes first and the cost note second. Every clause earns its place.

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

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

For a single-parameter read-only DNS lookup with annotations covering safety and the schema covering the input, this is nearly complete. The one gap is what an agent gets back — whether it's a record list, a boolean, or both — since no output schema exists to compensate.

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, and the schema documents it fully (100% coverage) with a format example. The description adds no further meaning about domain handling (IDN, subdomains, casing), 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 (look up) and resource (a domain's MX records) plus the derived outcome (can receive email). It implicitly distinguishes itself from check_spf/check_dkim/check_dmarc, but never names those siblings or check_domain_health, so the routing signal is weaker than it could be.

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 'Free — no verification credits' note gives a cost-based reason to prefer this over paid checks like verify_email, which is useful implied guidance. It stops short of saying when to call this versus check_domain_health or the other DNS record checks, or what preconditions exist.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds genuinely new behavioral context not in annotations: the tool both validates and flags misconfigurations, and it costs no verification credits — a meaningful constraint for an open-world network lookup tool.

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

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

Two compact sentences with zero filler; the core action is front-loaded and the cost note follows as supporting context. Every clause earns its place.

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

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

For a single-parameter read-only lookup with annotations and no output schema, this is nearly complete. The only soft gap is that it doesn't characterize the response (e.g., whether it returns pass/fail plus a list of specific issues), which an agent might want to know when composing follow-ups.

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 is only one parameter (domain) and schema description coverage is 100%, with the schema already giving the example 'example.com'. The description adds no format or constraint 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 and resource (check a domain's SPF record) plus the outcome (flag common misconfigurations). The SPF-specific framing naturally distinguishes it from siblings like check_dmarc and check_dkim, 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 by the resource name — an agent can infer this is the SPF-specific check versus check_dmarc/check_dkim/check_mx. There is no explicit when-to-use, prerequisite, or routing guidance, and no mention of check_domain_health as the aggregate alternative.

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 openWorldHint=false, so safety is covered. The description adds the useful pagination trait, but omits behaviorally relevant facts such as whether a still-processing batch yields partial/empty results or errors, and there is no mention of ordering or result volume.

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

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

Two short sentences: the core action first, then the pagination qualifier. Nothing redundant and nothing 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?

With no output schema, the description carries the burden of describing return shape but only says 'a page of results' — it doesn't indicate what a result row contains or how to detect the end of pagination. Annotations and full schema coverage keep it viable, but the polling/results-availability question an agent will actually face is unanswered.

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

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

Schema description coverage is 100% — page (1-based, default 1), pageSize (1–1000, default 100), and batchId are all documented in the schema. The description only restates that page/pageSize exist, adding no new semantics, so the baseline of 3 applies.

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

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

States a specific verb ('Fetch') and resource ('a page of results for a bulk verification batch'), which clearly separates it from the verify/check siblings. It does not explicitly contrast with the closest sibling, get_batch_status, so the agent must infer the results-vs-status split.

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 note tells the agent to use page/pageSize for large batches, and the schema ties batchId to verify_batch. However, there is no guidance on when results are actually available (i.e., whether get_batch_status should be polled first) and no explicit exclusion of the status sibling.

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 openWorldHint=false, so safety is covered; the description adds real value by disclosing the return shape (state, addresses processed, per-status counts) and the 'once available' nuance that some fields are absent until processing progresses. It stops short of stating behavior for an unknown/expired batchId.

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

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

One sentence, front-loaded with the verb and resource, then the return payload in a compact enumerated form. 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?

With no output schema, the description carries the return-value burden and does so adequately by naming the state enum and the count fields. It is slightly incomplete on failure semantics (invalid or expired batchId) and on whether repeated calls are expected while queued.

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 description already explains that batchId is the value returned by verify_batch, so the description need not repeat it. It adds nothing about parameter syntax or provenance beyond the schema, which is the correct baseline-3 outcome for a single fully documented 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?

The description uses a specific verb ('Check') plus resource ('bulk verification batch') and enumerates exactly what is returned: lifecycle state with its four possible values, addresses processed, and per-status counts. It never names get_batch_results explicitly, so the status-vs-results distinction must be inferred from the wording 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?

Usage is only implied: the schema notes batchId comes from verify_batch, which tells the agent this is a follow-up call, and the word 'progress' suggests polling while processing. There is no explicit when-to-use versus get_batch_results, and no guidance on whether to poll, how often, or what to do on a failed batch.

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

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

Annotations only declare this is a non-read-only, non-idempotent, non-destructive open-world operation. The description adds the critical behavioral facts the annotations cannot convey: the call is asynchronous and returns immediately, the job runs in the background, status must be polled, and each address costs 1 credit.

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?

Five short sentences, front-loaded with the async submit semantics, then the workflow, then the cost, then the alternative routing. Nothing is redundant or 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?

With no output schema, the description correctly explains the return (a batchId) and how to retrieve results later. Combined with the fully-documented parameter schema, an agent has everything required to call this correctly and complete the workflow.

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 name, emails, and webhookUrl are already documented in the schema. The description adds no format, ordering, or deduplication detail beyond the schema, so the baseline of 3 applies.

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

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

The description gives a specific verb and resource (submit email addresses for asynchronous bulk verification) plus the immediate return value (batchId). It explicitly distinguishes itself from the sibling verify_email, so the 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?

It names the alternative for the single-address case ('Prefer verify_email for one-off checks') and lays out the exact follow-up sequence: poll get_batch_status until 'completed', then call get_batch_results. When-to-use, when-not-to-use, and next steps are all explicit.

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 by disclosing the credit cost ('Spends 1 verification credit per call') and a zero-cost sandbox domain with canned fixtures for each verdict. The annotations already declare openWorldHint=true and idempotentHint=false, and the description complements rather than repeats them.

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 verb and the verdict set, then cost, then the free-test-domain tip last. Every sentence carries information an agent needs; the return-value enumeration is justified because no output schema exists.

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 supplies the return shape (verdict enum, 0–100 confidence, safeToSend, signals) and the cost model. For a 3-parameter read-style verification call, nothing material 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%, so email, smtpProbe and catchAllDetection are already documented with defaults. The description adds no meaning about the two boolean probes (e.g. cost or latency tradeoff of skipping SMTP), so it sits at the baseline.

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

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

States a specific verb and resource ('Verify whether a single email address is real and safe to send to, in real time') and the word 'single' implicitly separates it from the batch sibling. An agent can distinguish it from check_mx/check_spf/verify_batch 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?

The 'single email address' framing plus the test-domain tip gives clear context for when this tool applies and how to exercise it for free. It does not explicitly name exclusions (e.g. 'use verify_batch for lists'), so routing guidance is strong but not fully spelled out.

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