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

No annotations are provided, so the description carries the behavioral burden. It explicitly discloses the DNS mutation, the exact record name, that propagation is fast, and that the ACME client should continue afterward. It does not mention cleanup of the challenge record or behavior when a TXT record already exists, which is a modest gap for a mutating DNS operation.

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 four sentences, front-loaded with the core operation and target, followed by use cases, propagation timing, and a useful guardrail. Every sentence earns its place and nothing is redundant.

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 DNS mutation tool without annotations or an output schema, the description covers why, when, what happens, and what to do next. The main omission is what to do with the challenge record after validation, and there is no mention of what the tool returns or whether it can overwrite an existing record.

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 parameters. The description adds useful meaning by linking label, domain, and value to the generated _acme-challenge hostname and says the value must be published verbatim, but it does not need to compensate for missing schema entries.

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: it creates a Let's Encrypt DNS-01 TXT record at _acme-challenge.<label>.<domain>. It clearly distinguishes this from generic DNS record operations and from HTTP-01 validation.

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 explicit when-to-use guidance: get a certificate without exposing port 80, such as a wildcard cert or a NAT-hosted domain. It also gives a when-not-to-use signal: normal public web servers should use HTTP-01 validation and need no DNS record at all.

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

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

With no annotations provided, the description carries full behavioral burden and excels: it states records are added without replacing existing ones, and warns that individual records cannot be deleted. The note about delete_domain removing all records is a clear, honest caveat about consequences.

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

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

Three sentences, front-loaded with the core action, then type guidance, then an important destructive caveat. Every sentence earns its place and there is no redundancy.

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

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

For a simple add operation with no output schema, the description covers the key prerequisites, type semantics, add-only behavior, and deletion limitations. It lacks an explicit pointer to the add_acme_challenge sibling for ACME-specific use cases, but overall the tool can be called correctly from this description alone.

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

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

Input schema coverage is 100%, so the baseline is 3, but the description adds valuable semantic meaning for the type parameter by explaining what values are appropriate for IPs, hostnames, and TXT strings. This supplements the schema rather than merely repeating it.

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 clearly defines the action as adding a DNS record to a subdomain the user owns, and specifies the record types A, AAAA, CNAME, and TXT. This distinguishes it from sibling tools like delete_domain and add_acme_challenge.

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 explicit guidance on what each record type is for, which serves as strong usage direction. However, it does not explicitly compare itself to the similarly named add_acme_challenge or state when not to use this tool.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure, and it delivers. It reveals that the account is provisional, that a human must click the verification link, that the deadline is 30 days, and that the account and its domains will be deleted if verification doesn't happen. This is exactly the kind of side effect an agent needs to know before calling a mutation 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?

The description is only two sentences long, yet it packs the core action, the required human action, the deadline, the deletion consequence, and the usage timing. Every sentence earns its place, and the most important directive is front-loaded.

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

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

For a single-parameter tool with no output schema and no annotations, this description gives an agent enough to decide when to call it, what input to provide, and what significant behavioral risks exist. The only minor gap is that success/error response behavior is not described, but that is not essential for invoking such a tool correctly.

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

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

The input schema already provides complete coverage of the only parameter, including its type and intended meaning. The description adds essentially no semantic information beyond what the schema states, 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 states a specific action ('attach an email address'), the resource ('the account'), and a concrete follow-up behavior (sending a verification link). It also ties the tool to the signup flow, making its purpose easy to distinguish from domain-related siblings like claim_domain or set_forward.

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

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

The description explicitly says 'Use this right after signup,' giving the agent a clear temporal instruction for when to invoke this tool. It does not explicitly name alternatives or exclusions, but the placement in the signup flow makes the intended context 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?

With no annotations, the description carries the full burden. It discloses that no API key is required, defines the full return shape, enumerates the possible reason values, and clarifies the detail field. It doesn't mention rate limits or edge cases, but for a simple check this is solid coverage.

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

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

Two tight sentences: the first states the action and timing, the second covers auth and the exact return contract. No filler, no repetition of schema. The key scoping context ('before claiming it') is front-loaded.

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

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

There is no output schema or annotations, so the description must directly compensate. It provides the complete return structure, explains every reason value, and includes domaine-related fields. For an agent that needs to decide, call, and parse the result, this is sufficient.

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

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

Input schema already covers both parameters with 100% description coverage, so a baseline score of 3 is appropriate. The description adds no input-specific semantics beyond the return shape mentioning 'domain' and 'fqdn'; it doesn't elaborate on label constraints or domain nuance that the schema already handles.

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?

Description uses a specific verb ('check') and resource ('subdomain label'), and states the precise predicate (whether free) while explicitly tying to claim action. It clearly reads as a pre-check for claim_domain and is not confusable with listing, creating, or deleting domains.

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 'before claiming it' gives a clear usage context relative to claim_domain, but it does not explicitly name alternatives or state when not to use the tool. This is contextual but relies on the agent to infer the connection to claim_domain.

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

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

With no annotations provided, the description carries the behavioral burden. It discloses the email confirmation requirement, the 30-day reaping risk, and the fact that the name is registered on this account. It also explicitly states the return values (fqdn and optional created record), which is valuable for an agent.

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 compact and front-loaded: it states the core action, key prerequisites, consequences, and return behavior in three sentences. Each sentence adds necessary information and there is 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?

Given 6 parameters, no annotations, and no output schema, the description is quite complete: it explains first-time email requirements, the 30-day reaping policy, available domains via schema, and what is returned. It could additionally guide the agent toward add_dns_record for subsequent records or check_availability for pre-checking, but that is not a major 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 schema already covers 100% of the parameters with detailed descriptions, so the baseline is 3. The description adds context by mentioning the email requirement and registration flow, but it does not add much meaning beyond what the schema already documents for each 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 states a specific verb and resource: 'Register a subdomain (label.makes.fyi or label.agentdomains.co)', and clearly explains that it can optionally create the first DNS record in the same call. This distinguishes it from related DNA record tools like add_dns_record.

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 clear usage context: email is required on first registration, and you can either pass email here or call attach_email first. It also communicates the default domain and when to specify domain. It does not explicitly contrast this tool against alternatives like check_availability or add_dns_record, but it names a relevant sibling for the email prerequisite.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, and it does well: it warns that existing AgentDomains records, forwards, and proxies will no longer apply once delegation is active. It also states the requirement of at least two nameservers, which adds operational expectations beyond a simple tool name.

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 efficient, front-loaded with the core action, and uses every sentence to convey material information: control shift, behavior change, and input requirement. No repetition or 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 destructive-ish but reversible action, the description explains the concrete consequences and the minimum input, and the schema covers all parameter details. It does not state whether delegation can be undone, but given the strength of the other context, this is a relatively minor gap.

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

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

Schema description coverage is 100%, so all three parameters are already documented meaningfully in the schema. The description does little to add semantic value beyond reinforcing the 'at least two nameservers' rule, which was already present in the schema.

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

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

The description names a specific verb and resource ('Delegate the subdomain to your own nameservers') and clearly distinguishes itself from sibling tools by stating AgentDomains stops answering and existing records/forwards/proxies no longer apply. This makes the tool's unique role obvious without needing to inspect other schemas.

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 clear context for when this tool is appropriate: when you want full control via your own nameservers rather than using AgentDomains' built-in DNS, forwards, or proxies. It does not explicitly name alternative tools as recommendations, but the behavior contrast with those futures is enough to infer the choice.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It covers permanence, irreversibility, cascading deletion of attached resources, immediate resolution loss, and the label being released. This is comprehensive for the context, and there is no contradiction with annotations because annotations do not exist.

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 compact, front-loaded with the most important warning—'DESTRUCTIVE AND IRREVERSIBLE'—and every sentence contributes to user intent, consequences, or invocation conditions. There is 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 destructive delete operation with no output schema and no annotations, the description covers the material facts an agent needs: what gets deleted, immediate resolution impact, irreversibility, and when it is appropriate to call. It is sufficient on its own.

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 input schema already describes both parameters fully—label format is documented with an example and domain has its values and default explained. Since schema coverage is 100%, the description's high-level language about deleting a subdomain is sufficient; it does not need to add parameter-level detail.

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

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

The description is explicit and specific: 'permanently delete a subdomain and every DNS record, forward, and proxy attached to it.' It names the exact resource and the full scope of deletion, which cleanly distinguishes this from sibling tools like remove_forward or remove_proxy.

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 provides a strong decision rule: 'Only call this when the user has explicitly asked for this specific name to be deleted.' It also explains why caution is needed—destruction is permanent and affects DNS, forwarding, proxying, and label availability. This is the kind of when/when-not guidance an agent needs for a destructive operation.

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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It communicates that this is a read-oriented inspection tool and enumerates the specific data elements returned. It does not discuss error behavior, auth requirements, or side effects, but the 'Show' verb makes the non-mutating nature clear.

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 compact sentence that front-loads the core action ('Show one subdomain in full') and then lists the relevant content areas. No filler, repetition, or schema restating.

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

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

For a low-complexity read tool with two simple parameters, the description adequately describes the operation and return content. The lack of an output schema is mitigated by the explicit list of fields returned, though error behavior for nonexistent labels is not mentioned.

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 input schema already covers both parameters thoroughly, including the default for domain and the distinction between makes.fyi and agentdomains.co. The description adds no additional parameter-level meaning, 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 ('Show') and identifies the exact resource ('one subdomain in full') along with the details returned (fqdn, DNS records, forward/proxy configuration, delegation state). This clearly distinguishes it from sibling tools like list_domains, which show multiple subdomains at a higher level.

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 context is clear: use this when you need complete detail for a single subdomain. It does not explicitly name alternatives or state when not to use them, but the contrast with list_domains is strongly implied by 'one subdomain in full'.

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

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

With no annotations, the description carries the burden of explaining behavior, and it does: it is a read-only listing operation that returns specific details per subdomain. It does not mention pagination, rate limits, or authorization, but the lack of parameters and clear return scope make it a transparent description.

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 entire description is a single, information-dense sentence with no filler. It front-loads the main action and then lists the exact attributes returned for each subdomain, making it easy for an agent to quickly parse and 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?

Given zero parameters, no output schema, and no annotations, the description provides enough information to successfully invoke the tool and interpret the response. There is no hidden behavior or missing prerequisite that would prevent an agent from using this tool effectively.

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 input schema has zero parameters, so there are no parameter semantics to clarify. The description also tells the agent what the output contains, which is the only meaningful semantic information. A score of 4 is appropriate for a zero-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?

The description starts with the action 'List every subdomain on this account' and precisely specifies the scope: account-wide. It also states exactly what is included per domain: DNS records, and status flags for forwarding, proxying, or delegated nameservers. This makes it easy to distinguish from the sibling domain-specific tools.

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

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

The account-wide scope and 'list every subdomain' language makes it clear that this is the enumeration tool for a domain overview, rather than a single-domain lookup or mutation tool. It does not explicitly name alternative tools or when-not-to-use conditions, but for a zero-parameter listing operation, the context is sufficiently clear.

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

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

No annotations exist, so the description carries the full transparency burden. It discloses the key non-obvious behavior: the registration is retained and only the redirect is removed, preventing a common misconception. It does not mention idempotency or failure modes, which are minor for such a simple mutation.

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 entire description is two sentences, with the action and scope front-loaded. Every sentence earns its place: the first states the operation, the second clarifies how it differs from deletion.

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

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

Given a simple two-parameter tool with fully covered schema, the description should clarify result and side effects. It did: it confirms the redirect is removed but registration remains. It would be slightly stronger if it noted the expected success response, but it is not necessary for correct invocation.

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

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

Input schema description coverage is 100%, and the parameter descriptions already explain 'label' with an example and 'domain' with defaults/enumerations. The tool description itself adds no parameter-specific semantics, so a 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 opens with a specific verb and resource: 'Stop forwarding a subdomain.' It further clarifies scope by stating the domain name remains registered, which differentiates it from deletion tools like delete_domain or remove_proxy.

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 makes the intended use case clear if you need to stop forwarding, and 'only the redirect is removed' implies you should not choose this if you want to remove the subdomain registration itself. However, it does not explicitly name alternatives or say when not to use it relative to remove_proxy or delete_domain.

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?

There are no annotations, so the description carries the full burden of disclosing behavior. It clearly states what the operation does, that it removes TLS termination and backend serving at the edge, and that the subdomain remains registered on the account. It does not discuss prerequisites or idempotence, but the core behavior is transparent.

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

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

The description is two sentences with no wasted words. The main action is front-loaded, and the second sentence adds a meaningful boundary condition about the registration remaining intact.

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 two-parameter operation with no output schema, the description provides the action, the post-condition of the edge behavior, and the persistence of the domain name. Together with the fully documented input schema, an agent has enough to select and correct the tool correctly.

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

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

Schema description coverage is 100%, so the parameters label and domain are already fully documented. The description adds no parameter-specific detail, but none is needed because the schema already explains formats, defaults, and when domain should be passed.

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 action (stop reverse-proxying), the resource (a subdomain), and concrete consequences (no longer serves the backend or terminates TLS). It also explicitly notes that the name stays registered, which distinguishes it from deletion-focused tools like delete_domain.

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 'Stop reverse-proxying a subdomain' gives a clear use case, and 'the name stays registered' hints that this is not the tool for deleting the domain itself. It does not explicitly compare against set_proxy or remove_forward, but the proxy-specific wording makes the intended scope clear enough.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It discloses the auto-claiming side effect, possible email requirement, default 302 behavior, preserved paths, and that HTTPS is handled automatically. It does not state what happens if the label already has an existing forward, but the provided side effects are far more transparent than most mutation tools in this collection.

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 four compact sentences with the core action front-loaded. Every sentence adds useful context—auto-claiming, email requirements, defaults, and edge handling—without fluff or restatement of the schema.

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

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

Given the tool complexity, 100% schema coverage, and no output schema, the description provides a sufficient operational picture: the action, the default behavior, the side-effect of claiming labels, and the email exception when claiming. It does not provide a detailed response or overload behavior, but for a setter/forwarder with schema support, it is reasonably 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?

The input schema has 100% parameter coverage, so all seven parameters are already described structurally. The description adds value by stating the default behavior for preserve_path and permanent ('302 temporary redirect that preserves the request path and query'), but it does not add meaning beyond the schema for most parameters.

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 and resource: 'Forward (HTTP-redirect) a subdomain to another URL.' It clearly identifies the operation, differentiates it from the proxying sibling, and explains the auto-claim behavior that clarifies what 'set_forward' actually does.

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

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

The description implies when to use the tool—when you need an HTTP redirect rather than a proxy or DNS change—but does not explicitly name alternatives or state when not to use it. The mention of claim_domain for the email requirement gives useful cross-tool context, but the when-to-use guidance remains implicit rather than 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?

Despite having no annotations, the description discloses important behavioral traits: TLS is terminated by the edge's own certificate, the URL stays on the domain, the response is proxied, and the label is claimed if needed. It also notes the OAuth/hardcoded-hostname caveat. It doesn't mention output, errors, or reversibility, but the core behavior is well covered.

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 compact — three sentences — and each sentence carries distinct value: TLS claims the label, proxy not redirect, and caveat about hostname registration. It is a little dense with em-dashes, but it is efficient and front-loaded with the main action.

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

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

The description is sufficiently complete for an uncomplicated tool: it explains what the backend is, where it is, how TLS is handled, and one important caveat. The lack of an output schema and annotations means the agent is still left inferring about response/error behaviors, but the schema carries most of the missing details.

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 input schema already describes all four parameters with 100% coverage. The description adds no parameter-specific details beyond what is already in 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 clearly states the verb–resource relationship: it 'serves a backend at a subdomain' through the AgentDomains edge, and contrasts proxy behavior with redirect behavior. This strongly differentiates it from siblings like set_forward or add_dns_record, so an agent can identify the intended operation 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 a concrete use case — 'getting working HTTPS on an origin that has no certificate of its own' — and explains the proxy vs. redirect difference. It doesn't explicitly name the alternative tool or list when-not to use it, but the contrast with a 'forward' provides clear 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?

With no annotations present, the description carries the full burden and does so excellently. It discloses the one-time visibility of the API key, the need to store it immediately, the 30-day provisional account policy, deletion consequences, and per-IP rate limiting—all behaviors an agent must know to avoid losing the account.

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

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

Every sentence carries essential, non-redundant information: creation action, credential requirement, security-critical key-retrieval warning, provisional-account deletion policy, and rate limiting. The key warning is front-loaded, and there is no filler or repetition.

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

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

Given the tool has no parameters, no annotations, and no output schema, the description compensates fully. It tells the agent what will happen, what to do with the result, how long the account lasts, and what follow-up action is needed. Nothing critical is missing for successful invocation.

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

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

The tool has zero parameters, so the baseline is 4. The description adds no parameter-specific meaning, but this is not a gap because there are no parameters to document. The API key return behavior is described, which is relevant but not parameter semantics.

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 clearly states the action ('Create a new AgentDomains account') and the result ('get an API key'), distinguishing it from siblings by being the only account-creation tool. It also clarifies that no existing key is required, which separates it from all other tools.

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

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

The description gives clear context for when to use this tool: when creating an account and obtaining an API key, and explicitly notes 'Requires no existing key.' It references attach_email as a follow-up step, but it does not explicitly describe scenarios where another tool should be chosen 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?

With no annotations present, the description carries the full behavioral disclosure burden. It clearly labels the operation as 'Show' (read-only) and specifies the information included, which is sufficient for a zero-parameter status tool. It does not mention potential authentication requirements, but 'current account' implicitly communicates that context.

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

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

The description is a single, front-loaded sentence beginning with the core action ('Show the current account') and immediately lists tangible output fields. Every part of the sentence adds information; there is no filler or repetition.

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

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

Given this is a no-parameter, no-side-effect account-status tool, the description fully covers what an agent needs to know to select and invoke it. The output schema is absent, but the description compensates by naming the fields that the tool returns. No critical invocation details are missing for this simple read operation.

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?

This tool has zero parameters, so the parameter documentation baseline is 4. The description does not need to explain parameters, and the schema already covers the empty parameter set. The description's field list provides semantically useful output context instead.

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 the clear verb 'Show' with a specific resource ('current account') and then enumerates the exact fields returned: id, state, email/verified status, quota, domains used, and claimable domains. This clearly distinguishes whoami from sibling tools like list_domains or get_domain, which operate on domain resources rather than account identity.

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 makes it obvious that this tool is for inspecting the current authenticated account's state. It does not explicitly name alternatives or exclusions, but no sibling tool appears to overlap with this account-summary purpose, so sufficient guidance is implied.

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