Proof Holdings

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

No annotations are provided, so the description carries the full burden. It discloses meaningful behavior: enabling the first challenger opts the config into Proof-Me, telegram captures chat_id later, whatsapp must pre-declare phone, and the tool requires a Proof account. It does not describe the return value or whether the operation is reversible, but the core side-effects are clearly stated.

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 with the core purpose, followed by channel-specific notes and an explicit usage workflow. Each sentence earns its place. Minor redundancy with the schema (the whatsapp phone requirement is also in the schema) but the additional context justifies it.

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 output schema and no annotations, the description provides the needed context: what the tool does, when to call it, what happens on first enrollment, channel nuances, and authentication requirements. The missing return-value description is a minor gap, but the operational context is strong enough for correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents all 4 parameters. The description adds value by explaining the telegram vs whatsapp difference and the whatsapp phone requirement beyond the schema's simple field descriptions. This goes beyond baseline without fully detailing formats or constraints already 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 states a specific verb (pre-enroll), a specific resource (a Proof-Me challenger on a HITL config), and explains special behavior (first challenger opts the config into Proof-Me; telegram vs whatsapp enrollment differences). This clearly distinguishes the tool from siblings like invite_challenger, list_challengers, and remove_challenger.

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 an explicit agent-usage workflow: after adding a challenger, call invite_challenger to mint the enrollment link. It also provides an authentication directive and a negative hint (start_login does NOT open this tool), which helps the agent know when and how to use it.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the Telegram chat id is captured later via the enrollment deep link, and mentions authentication requirements. It does not explicitly state side effects (e.g., creates a pending record) or idempotency, but the flow is clear enough. A slight gap is lack of detail on failure modes or return behavior, but the description goes beyond the bare minimum.

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 well-structured with a main sentence, an agent usage note, and an ACCESS block. It front-loads the core purpose and provides necessary operational context. It is not overly verbose, though the ACCESS note could be slightly more concise. Overall, it earns its place without 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?

Given 3 parameters, no output schema, and no annotations, the description covers the tool's role, the follow-up step, and prerequisites. It doesn't detail error handling or idempotency, but for a simple add operation, this is sufficient. The flow is explained, and the agent knows exactly what to do after calling it. A small gap is not specifying what the response contains, but since there's no output schema, this is acceptable.

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 schema already describes each parameter (id, name, whatsapp_phone). The description adds only a minor nuance: 'by name' and 'optional pre-declared WhatsApp phone,' which aligns with the schema but doesn't add new semantic value. Given full schema coverage, the baseline of 3 is appropriate.

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

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

Description clearly states the action: 'Add a pending member to a Circle by name, with an optional pre-declared WhatsApp phone.' It specifies the verb (add), the resource (Circle member), and the parameters. It also distinguishes from siblings like add_challenger and add_circle_member_channel by focusing on membership and the follow-up enrollment link.

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 sequential guidance: 'after adding a member, call invite_circle_member to mint the single-use enrollment link the member taps to bind their messenger identity.' Also states access prerequisites: 'needs a Proof account. Authenticate this client... then call this tool again. start_login does NOT open this tool.' This tells the agent exactly when and how to use it, including what not to do.

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 and does disclose key behaviors: it returns 409 on duplicate channel type, validates the identifier format server-side, and requires a Proof account. These go beyond the basic purpose and inform the agent of error conditions and prerequisites. It does not mention the success response or side effects, but for a simple create-like operation this is adequate.

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 concise sentences, front-loaded with the core purpose and the most important behavioral note (409 on duplicate). The authentication instruction is practical and earns its place. No fluff or redundancy—every sentence contributes.

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 four-parameter tool with no output schema, the description covers the essential context: purpose, duplicate behavior, identifier format, and authentication requirement. It does not state what the success response looks like or whether the circle/member must already exist, but these are not critical for an agent to invoke it correctly. The description is sufficient for basic usage.

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, so the baseline is 3. The description adds a minor nuance about the identifier ('per-channel format validated server-side'), but this largely mirrors the schema's 'Telegram chat id, or E.164 WhatsApp phone with a leading +'. It does not materially enrich parameter meaning beyond what the schema provides.

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 ('Declare') and resource ('channel for a Circle member'), and immediately adds a behavioral differentiator (returns 409 on duplicate). This clearly separates it from siblings like add_circle_member (adds a member) and remove_circle_member_channel (removes a channel), so an agent can tell them apart without opening 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 implies usage by stating the action and includes a critical prerequisite (authentication: 'needs a Proof account... Authenticate this client...'). However, it does not explicitly contrast with alternatives or state when not to use it, only implicitly conveying it is the tool for adding a channel. The note that 'start_login does NOT open this tool' is a helpful exclusion but not a full comparison with siblings.

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 present, so the description carries the behavioral burden. It usefully discloses that a Proof account and an authenticated/session context are required. However, it does not state what effects adding a domain has, such as whether verification starts automatically, whether adds are idempotent, or how failures surface.

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 tool purpose is front-loaded in one clear sentence, and the optional-parameter sentence earns its place. The access note is somewhat verbose but not redundant, as it explains a real precondition.

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

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

For a 3-parameter tool with a fully described schema, the immediate call is documented well. However, in a large domain-verification workflow, the description omits any mention of next steps or its relationship to sibling verification tools, and with no output schema there are no hints about the return or follow-up.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's phrase 'email sending intent and verification method' maps to the two optional parameter fields but adds no new meaning beyond the schema descriptions and enum values.

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 first sentence states a specific verb ('Add'), resource ('domain'), and intent ('verify ownership'), and it mentions optional email-sending and verification-method parameters. This clearly distinguishes it from sibling verification/check/delete domain tools even without naming them, because 'add new domain' is the registration step.

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

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

No guidance contrasts this tool with closely related siblings such as start_domain_verification, verify_domain, or check_domain_verification. The only operational note is the authentication prerequisite, which explains access but not when to use this tool versus alternatives.

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

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

There are no annotations, so the description carries the behavioral burden. It usefully discloses that credentials will be visible in the AI conversation context and that authentication is required. However, it does not mention side effects, failure modes, or whether credentials are added to or replace existing provider credentials beyond the word 'additional.'

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: first the operation, then a critical privacy warning, then the access/authentication requirement. Every sentence earns its place and there is no fluff.

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 mutating tool with three required parameters, a nested credentials object, and no output schema, the description covers the operation, precondition, authentication path, and a notable privacy risk. It omits possible provider identifier values and return behavior, but those are discoverable via sibling tools like get_dns_providers.

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 defines id, provider, and credentials. The description adds only the context that credentials are provider-specific and visible in-conversation; it does not enrich individual parameter meaning beyond the schema.

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

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

The description states a specific verb and resource: 'Add an additional DNS provider for verification to an already-verified domain.' It clearly distinguishes itself from initial-setup tools like connect_dns_provider or add_domain by emphasizing 'additional' and 'already-verified.'

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 clear prerequisites: the domain must already be verified, and a Proof account is required. It also explains the authentication flow via start_login. It does not explicitly list alternatives or when not to use the tool, but the context strongly implies the intended use case.

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 behavioral disclosure burden. It discloses the auth and ownership requirements but does not state whether cancellation is reversible, what side effects occur, or what the response contains. For a mutating tool this leaves meaningful gaps.

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 core purpose and the key precondition are front-loaded in two short sentences. The ACCESS block is dense but each sentence adds necessary auth and onboarding context; 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?

The description covers auth, ownership, and the target resource, which is adequate for a one-parameter cancel operation. It lacks a note distinguishing it from cancel_verification_request and says nothing about response or error behavior, so completeness is only 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?

The single id parameter is already fully described in the schema ('Verification request ID to cancel'), so the description adds no extra semantics. Schema coverage is 100%, so baseline 3 applies; no further compensation is needed.

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

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

States a clear action (cancel) and resource (pending verification request), plus an ownership constraint. However, it does not distinguish itself from the sibling cancel_verification_request, so an agent cannot tell which cancel tool to choose from the description alone.

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

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

Provides explicit preconditions: only the creator may cancel, a Proof account is required, and the client must be authenticated or signed in via start_login. It does not name alternatives or explain when cancel_user_request should be preferred over cancel_verification_request.

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 the key behavioral constraint of only-pending eligibility and the authentication gate, going beyond a mere restatement of the tool name. It does not describe side effects, irreversibility, or error behavior for non-pending requests, but for this simple cancellation action the disclosed traits are reasonably sufficient.

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: the main action and constraint appear in the first sentence, followed by a concise ACCESS note. There is no fluff or redundant restatement of the tool name.

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 mutation tool with no output schema, the description covers the essential operational context: what it does, when it applies, and the authentication prerequisite. It could be slightly more complete by explicitly distinguishing itself from cancel_user_request, but the name and pending-request wording already reduce confusion.

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 single parameter 'id' is already fully described in the input schema as 'Verification request ID' (100% schema description coverage). The tool description adds no extra meaning or context to the parameter, 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 'Cancel' with the resource 'verification request' and constrains it to 'pending' requests. This clearly differentiates it from sibling tools like cancel_user_request and create_verification_request without requiring the reader to open 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 explicitly states the precondition that only pending requests can be cancelled and provides an authentication requirement with a concrete instruction to re-call after authenticating. However, it does not explicitly mention alternatives such as cancel_user_request or explain 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?

No annotations are present, so the description carries the burden. It discloses the check-only nature, the Proof-account requirement, and that a session/login may be needed before the call succeeds. It could explicitly state that no DNS changes are made, but 'Check if...' and the pre-verification framing already imply a read-only 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 short and front-loaded, with purpose first, then usage, then access. The auth sentence is slightly convoluted ('a session opens this tool') and contains client-specific guidance, but every sentence contributes information 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 one-parameter tool with no output schema, the description covers what the tool does, when to call it, and the prerequisite authentication, which is enough to invoke it correctly. The main minor gap is that it does not describe what the returned result looks like beyond implying 'confirm the credentials work.'

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 describes the only parameter (`id`: 'Domain ID to check credentials for') at 100% coverage. The description adds little about parameter semantics beyond connecting the domain to stored credentials, so the high-schema-coverage 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 first sentence states a specific verb and resource: 'Check if stored DNS credentials have access to a domain.' It is not a tautology, and the phrase 'before triggering verification' distinguishes this preflight check from verification/check siblings such as verify_domain or check_domain_verification.

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 context: 'Use before triggering verification to confirm the credentials work.' It also spells out the authentication prerequisite and retry flow (start_login, then call again). It does not name the exact alternative tools or say when not to use it, so it does not earn a 5.

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

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

With no annotations, the description carries the full burden. It discloses the auth/session prerequisite and that the result includes DNS record configuration progress, which is genuinely helpful. It still says nothing about failure modes (e.g. domain not yet configured) or whether the check is purely read-only and side-effect free.

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 blocks: purpose first, then the access prerequisite, with no filler. The trailing 'then call this tool again' is slightly redundant but frames the retry-after-auth flow clearly.

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 and no annotations, the description covers purpose, the shape of the returned status, and the auth precondition. Only the absence of any error/edge-case behavior keeps it short of complete.

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

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

Schema coverage is 100% with a single documented 'id' (Domain ID) parameter, so the schema already does the work. The description adds no syntax, format, or sourcing detail (e.g. where to obtain the domain ID) beyond what is 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?

States a specific verb and resource ('Check the email sending setup status for a domain') and adds scope ('including DNS record configuration progress'), so an agent can tell it apart from write-oriented siblings like setup_domain_email or start_domain_email_verification. It does not, however, explicitly name which sibling to use instead (e.g. check_domain_verification).

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 ACCESS block gives a real precondition: a Proof account is required and an authentication flow (start_login or the client's /mcp Authenticate) must complete before this call succeeds. That is useful operational guidance, but there is no when-to-use/when-not-to-use guidance relative to the many adjacent status and verification tools.

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 behavioral disclosure. It does well by revealing that the tool actively triggers a DNS/HTTP check and returns updated status, and by flagging authentication requirements. It doesn't mention rate limits, failure behavior, or exact response shape, 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 compact and front-loaded: purpose first, then behavioral effect, then the access note. Every sentence carries useful information without padding.

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

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

Given the tool's low complexity (one required parameter, no output schema), the description covers purpose, behavior, return nature, and authentication context. It could add clarity around polling lifecycle or possible domain verification statuses, but these are minor gaps for a simple check tool.

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

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

The input schema covers 100% of the single parameter, id, described as 'Domain verification ID', so the baseline is 3. The tool description adds no additional meaning beyond the schema for this parameter.

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

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

The description clearly states the tool's purpose: checking the status of a pending domain verification and triggering a DNS/HTTP check to return updated status. It names a specific resource and action, though it doesn't explicitly contrast with similar siblings like check_user_domain_verification or get_user_domain_verification_status.

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 provides explicit access and authentication guidance: a Proof account is required, the client must be authenticated, and start_login does not open this tool. However, it doesn't state when to use this tool versus alternative verification-status tools, so it stops short of full alternative routing.

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

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

With no annotations provided, the description carries the full burden and does disclose meaningful behavioral context: the call is a trigger with a sequencing dependency (must follow DNS/HTTP setup) and requires prior authentication, including a retry path. However, it doesn't disclose what happens on failure, whether the check is synchronous or asynchronous, or what a successful check returns, leaving the agent guessing about response semantics.

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 call timing are front-loaded in the first two sentences, and the access note is actionable. The middle section is slightly verbose with the parenthetical Claude Code path, but every sentence earns its place and the overall length is appropriate.

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 1-param tool this is operationally close to complete: it covers what the tool does, when to call it, and how to authenticate. It falls short on return-value behavior (no output schema exists to compensate) and on differentiating from the similar siblings check_domain_verification and get_user_domain_verification_status, leaving an agent without enough information to fully interpret the 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?

Schema description coverage is 100%, and the single session_id parameter is already described as 'Domain verification session ID'. The description adds no additional parameter-level meaning beyond what the schema provides, which is acceptable at the high-coverage 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 action ('Trigger a check') on a specific resource ('domain verification challenge') and gives the triggering condition (after placing DNS record or HTTP file). It stops short of 5 because it doesn't distinguish itself from the near-identical sibling check_domain_verification, leaving an agent to wonder which of the two it should pick.

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?

Explicitly states when to call ('Call after placing DNS record or HTTP file') and provides a detailed authentication prerequisite with a practical retry flow (start_login opens the tool, then call again). It doesn't name alternatives or state when not to use this tool versus check_domain_verification or get_user_domain_verification_status, but the timing and auth guidance are concrete and actionable.

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?

Since no annotations are provided, the description carries the burden of explaining side effects. It does disclose the authentication requirement and the completed-request precondition, which is useful. However, it does not state whether claiming transfers or revokes ownership, is one-time or idempotent, or what happens when assets were already claimed. 'Claim' is the only side-effect signal.

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: the first sentence states the operation, and the second provides the access prerequisite. Every sentence earns its place, and there is no padding or redundant restating of the tool name.

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?

This is a minimal, state-changing tool with no output schema and no annotations. The description adequately explains the operation and authentication, but it omits return behavior and post-claim effectsached feet. For a one-parameter tool this is minimally viable, but there are real gaps that could affect 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?

The schema already describes the only parameter, id, as 'Verification request ID', and schema coverage is 100%. The description adds no extra detail about the ID format, how to obtain it, or what makes a request eligible, 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 clearly identifies the action ('Claim'), the object ('shared assets'), and the source ('a completed verification request'), so an agent can understand what the tool does. It does not explicitly differentiate this from sibling tools like claim_username or get_asset, so it stops short of a 5.

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

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

The description gives a clear precondition: the caller needs a Proof account and an authenticated session, and it instructs the agent to authenticate or call start_login, then retry. It does not explicitly mention when to prefer this over alternatives or what to do if the request is not yet completed, but the context is clear and actionable.

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 must carry behavioral disclosure. It only mentions the action and constraints, but does not state what happens on conflict (username taken), whether it overwrites an existing username, or what the return value/error behavior is. This is a significant gap for 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?

Two sentences, front-loaded with the verb and resource, then constraints, then access instructions. Every sentence adds value; no redundant text.

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

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

The tool is simple (one parameter, no output schema), and the description covers access and constraints. However, it omits failure semantics and return value, which an agent needs to know to handle the call correctly. Given the lack of annotations, slightly more detail would improve completeness.

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% (the parameter is fully described in the schema), so the baseline is 3. The description adds the 'unique' and 'public profile' context, but primarily restates constraints already present in the schema. No additional syntax or behavior details beyond 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+resource: claim a unique username for the authenticated user's public profile. Distinguishes clearly from sibling profile tools like create_profile or update_my_profile by focusing specifically on the username claim action.

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

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

Provides clear context: requires a Proof account and authentication, with two concrete options (authenticate this client or use start_login). It does not explicitly exclude alternatives or name sibling tools, but the prerequisite flow is 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 are provided, so the description carries the burden. It discloses the access requirement (Proof account) and the authentication prerequisite, which is useful. However, it doesn't disclose what happens on success or failure, whether the code is consumed, or any rate limits. The description adds some behavioral context but not comprehensive.

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 concise and front-loaded with the core action. The access note is a second sentence that adds necessary context. No wasted words, though the authentication instructions could be seen as slightly verbose.

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

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

For a two-parameter tool with no output schema, the description covers the essential flow: authenticate, get the code, submit it. It doesn't explain what happens after confirmation or how to handle errors, but the core invocation context is present. The sibling list includes related tools, and the description gives enough to distinguish this step.

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 parameters ('Domain ID' and 'Verification code from the email'). The description adds minimal extra meaning beyond the schema, but it does clarify that the code is sent to the corporate email. Baseline 3 is appropriate.

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

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

The description states a specific verb and resource: 'Confirm domain email verification by submitting the code sent to the corporate email address.' This clearly distinguishes it from related tools like start_domain_email_verification and resend_domain_email. It doesn't explicitly name sibling tools, but the action is specific enough to be understood.

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 provides clear context: it is used after a code has been sent to the corporate email, and it mentions the prerequisite of authentication. It doesn't explicitly state when not to use it or name alternatives, but the flow is implied well enough for an agent to know when to invoke it.

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

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

No annotations are present, so the description carries full responsibility. It discloses the privacy risk (token visible in conversation), the account requirement, and the recovery workflow if unauthenticated. It doesn't mention reversibility or overwrite behavior, but covers the most important side effects for a secret-bearing connection 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 sentences plus an access note, all substantive. Purpose is front-loaded, the security warning follows immediately, and no filler or redundant restating of schema fields.

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

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

For a two-parameter tool with no output schema and no annotations, the description provides the necessary authentication context, prerequisite, and security caveat. Minor gap: it doesn't state what happens if the domain already has a Cloudflare connection, but this is not critical for initial invocation.

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

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

Schema covers both parameters fully (id as Domain ID, api_token with DNS edit permissions), so baseline 3 applies. The description adds a behavioral note about token visibility but no new semantic detail about either 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?

Description states 'Connect a Cloudflare API token to a domain for automated DNS record management' – a specific verb, resource, and purpose. The Cloudflare-specific wording clearly differentiates it from sibling tools like connect_dns_provider and connect_godaddy.

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 prerequisites: requires a Proof account, and provides two authentication paths (Claude Code authenticate or start_login then call again). It does not explicitly name alternative tools, but the Cloudflare-specific purpose makes selection obvious.

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

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

The description warns that credentials will be visible in the AI conversation context, which is crucial behavioral disclosure. It also notes the Proof account requirement and authentication steps. However, it doesn't describe side effects like whether this replaces an existing DNS connection or what happens on success.

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-loads the purpose, followed by the security warning and the access workflow. Every sentence adds necessary information, though the access section could be slightly shorter.

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 three required params and no output schema, the description covers the authentication prerequisite and credential exposure, but doesn't state expected outcome or side effects. It's adequate for a simple connect action but leaves some operational details to the agent's inference.

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

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

Schema coverage is 100% and each parameter has an adequate description ('Domain ID', 'DNS provider identifier', 'Provider-specific credential key-value pairs'). The description only echoes the generic 'provider-specific credentials' phrase, adding no extra meaning beyond the schema.

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

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

The description uses a specific verb ('Connect') and the resource ('DNS provider') plus the target ('domain'), and differentiates itself from siblings like connect_cloudflare and connect_godaddy by saying 'generic DNS provider'. An agent can immediately tell this is the fallback for providers without a dedicated tool.

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

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

It gives clear context: the tool is for generic providers, and it explains the authentication flow (needs a Proof account, authenticate or sign in with start_login, then call again). It doesn't explicitly name alternatives or exclusions, but 'generic' implies it's the fallback for non-Cloudflare/GoDaddy providers.

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 usefully warns that the API key and secret will be visible in the AI conversation context and explains the authentication prerequisite. It does not disclose what happens after connection (e.g., whether credentials are validated, overwritten, or stored), but the most important side-effect and security trait are 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 concise and front-loaded: the core purpose is in the first sentence, followed by a security-relevant warning and access instructions. Every sentence adds value and there is no redundant 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 credential-connecting tool with no output schema and no annotations, the description covers the essential invocation context: purpose, required account, authentication flow, and a security caution. It is slightly incomplete in that it does not describe expected return behavior or failure modes, but the provided context is sufficient for an agent to attempt the call 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 all three parameters (id, api_key, api_secret) are already documented in the schema. The description adds no new parameter-level meaning beyond mentioning that API key and secret will be visible, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: 'Connect GoDaddy API credentials to a domain for automated DNS record management.' It clearly identifies the provider (GoDaddy), the action (connect credentials), and the purpose (automated DNS management), and is readily distinguishable from siblings like connect_cloudflare and connect_dns_provider.

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 provides explicit prerequisites and a usage sequence: it requires a Proof account, instructs the agent to authenticate the client or use start_login, and notes that a session opens the tool before calling it again. It does not explicitly state when not to use it or contrast it with connect_dns_provider/connect_cloudflare, but the context is clear enough for the GoDaddy case.

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 fully carries the behavioral disclosure burden. It reveals that the endpoint is public, that it creates a user or logs one in, that the response is intentionally uniform to avoid user enumeration, that email sends nothing, that sms responses contain no destination number, and that verification sets JWT and refresh cookies. This is exceptionally 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?

Although lengthy, the description is dense, well-structured, and front-loaded with the core purpose before the workflow. Every paragraph and numbered step earns its place given the channel-specific caveats, and the warnings are concrete rather than generic.

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

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

There is no output schema, so the description takes on the burden of explaining return fields and follow-up expectations. It covers session id, deep_link, qr_code, qr_text, sms_message, email_sent, send_required, and the verification handoff. It also covers edge cases like sms lacking a destination number and the danger of treating qr_text as a link. This is complete for an onboarding tool with this complexity.

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 all three parameters with 100% coverage, so the baseline is 3. The description adds meaningful channel-specific semantics: email requires confirmation and a follow-up call, sms requires a phone number with no destination in the response, and telegram/whatsapp use deep_link for rendering. It does not fully enumerate parameter formats beyond the schema, but it substantially augments 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 identifies a specific verb and resource ('Create an account-bootstrap session for agent-driven onboarding') and adds the public-endpoint qualifier. It is clear, but it does not explicitly differentiate itself from closely related siblings like create_session, start_login, or create_verification, so an agent must infer the distinction from context.

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 an explicit numbered agent workflow, including when to call send_account_email versus relying on deep_link, when to use render_auth_link, and when to call wait_for_account_creation. It also states the condition for calling get_current_user to distinguish new vs. returning users, and warns against using sms deep_link or handing qr_text to a link renderer.

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—and it delivers. It discloses that the secret is shown only once, that it remains visible in the AI conversation context, that profile_id is immutable after creation, that 2FA must be completed first, and that a 403 means the 2FA session expired.

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 longer than average, but it is front-loaded with the core behavior and organized into clear sections for agent usage and access. Each sentence carries operational weight—security warnings, 2FA steps, and error recovery—so the length is justified by the tool's complexity.

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 complex, security-sensitive creation tool with no output schema, the description covers all critical aspects: response behavior (secret only in this response), parameter nuances, 2FA prerequisite, authentication path, and failure handling. Nothing essential for correct invocation 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 the schema already documents name, scopes, profile_id, and environment. The description adds meaning beyond the schema by explaining how profile_id affects behavior: outbound messages sent with the key are branded as that project. This extra semantic context justifies a score above 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?

The description opens with a specific verb and resource: 'Create a new API key.' It adds distinguishing details—the secret is returned only once, and the key can be bound to a sub-account via profile_id—which separate it clearly from siblings like regenerate_api_key, revoke_api_key, and list_api_keys.

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 an explicit, numbered 2FA workflow and states the access prerequisite ('needs a Proof account', authenticate or start_login). It clearly explains when create_api_key can be called and how to recover from a 403. It does not explicitly contrast this tool with sibling API-key tools, but the usage path 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?

With no annotations, the description carries the burden and does add useful behavior: the authorization is only a request until the user approves, and authentication is required. It does not disclose the result of a successful call, error conditions, or side effects beyond creation.

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 earns its place: purpose, permission semantics, approval behavior, access prerequisite, and a clarifying exclusion about start_login. The access note is front-loaded after the core purpose and is not padding.

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

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

For a 9-parameter creation tool with no annotations and no output schema, the description covers the high-level lifecycle and authentication prerequisite but omits the return value/success response and next step after creation. This is adequate but has clear gaps.

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 nine parameters. The description adds business context (channel-specific permissions, approval requirement) but no parameter-level detail beyond the schema.

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

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

The description opens with a specific verb and resource: 'Create a new authorization request' and explains that authorizations permit sending confirmations via a channel. It does not explicitly distinguish from sibling request_hitl_authorization, so it misses the top bar.

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 clear context: the tool is for creating an authorization that requires user approval before confirmations are sent, and it must be preceded by Proof account authentication. It lacks explicit alternatives or when-not-to-use statements beyond noting start_login does not open 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 provided, the description takes on the full burden of behavior disclosure. It reveals the authentication prerequisite (Proof account, /mcp → Authenticate), the need to call the tool again after auth, and the special rendering behavior of qr_text. It could add token lifecycle details (e.g., expiration) but already covers the most critical behavioral traits.

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 longer than strictly necessary but is well-structured into purpose, agent usage, and access prerequisites. Every sentence contributes to correct invocation. It is front-loaded with the core purpose and return fields before deeper instructions.

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 parameterless tool with no output schema, the description effectively covers the full workflow: what it returns, how to use the returns with siblings, the authentication requirement, and the downstream use of the discovered chat_id. It even clarifies the relationship to start_login. Nothing critical is missing for an agent to invoke this 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 has zero parameters, so the baseline is 4. The description adds useful context about the return values and how they should be consumed, but there are no parameters to clarify. It does not need to compensate for undocumented parameters since none exist.

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

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

The description states a clear verb ('Create'), a specific resource ('Telegram chat ID discovery token'), and lists the exact return fields (deep_link, qr_code, qr_text). It also distinguishes itself from related siblings by explicitly referencing render_auth_link, poll_chat_id_discovery, and start_login.

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 agent usage instructions: pass deep_link to render_auth_link, never hand qr_text to a link renderer, print qr_text in a fenced block only for a terminal, and then poll poll_chat_id_discovery. Also states start_login does NOT open this tool, clarifying when not to use it.

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

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

With no annotations, the description carries the behavioral burden. It discloses the Proof account authentication prerequisite, warns that start_login will not open the tool, and explains that declared member channels are stored for later enrollment. It does not describe the return value or other side effects, but the key operational behaviors are 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?

Three short paragraphs with no filler: the definition is front-loaded, the workflow is isolated under 'Agent usage', and the authentication caveat is clearly separated. Every sentence contributes either to understanding the resource or calling it correctly.

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 create tool with no output schema and no annotations, the description covers the essential context: what a Circle is, how to seed members, what to do next, and the auth precondition. It falls just short of perfect because it does not mention what the tool returns, such as the Circle ID an agent would likely need for add_circle_member or invite_circle_member.

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 100% of the parameters, so the baseline is 3. The description adds value by explaining that members are optional initial seeds, that declared channels are stored so members can later be invited to enroll, and by linking parameters to the follow-up workflow.

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: 'Create a Circle' and defines it as a named group of trusted contacts powering Proof-Me and Approvals-on-Circle. This clearly distinguishes it from the many sibling tools and explains the optional members-seeding behavior.

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 'Agent usage' paragraph gives an explicit workflow: create the Circle, add members via add_circle_member or seed them here, then invite_circle_member to mint the enrollment deep link. The ACCESS note also clarifies when not to use this tool, stating that start_login does NOT open it.

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

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

With no annotations, the description carries the burden and largely delivers: it discloses the important behavioral trait that the drill carries the scheduled-safety-check label, so the account owner sees it as a practice confirmation. It also states the authentication requirement. It stops short of explaining side effects or what happens after the drill fires, but the core effect 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 compact and front-loaded: action, target, key label nuance, and relationship to automated drills appear first; the access/authentication note is brief and useful. No sentence wastes space or merely restates the tool name.

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 two documented parameters, no output schema, and no annotations, the description covers what the tool does, the scope (one member), the access prerequisite, and the on-demand vs. automated context. The main gap is post-call behavior (what the caller should expect after the drill fires), but the absence of an output schema reduces that burden.

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 documents both parameters with patterns and descriptions, providing 100% coverage. The description adds only a small semantic nuance: the member must be 'enrolled.' Since the schema does the heavy lifting, 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 uses a specific verb ('fire') and a specific resource ('an on-demand Proof-Me drill against one enrolled member'), and clarifies the nature of the drill as a cross-channel identity challenge with a scheduled-safety-check label. It distinguishes itself from automated drills by calling out 'on-demand' and 'Complements the automated daily drill + monthly reinforcement sweeps,' though it does not explicitly name a sibling tool like trigger_drill.

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: use this for an on-demand drill against a single enrolled member, complementing automated sweeps. It provides a concrete prerequisite ('needs a Proof account'), tells the agent to authenticate before retrying, and includes an explicit exclusion ('start_login does NOT open this tool'). It does not route among drill-related sibling tools, but enough guidance exists for correct selection.

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 behavioral burden and meets it: it discloses destination channels, first-response-wins semantics, mandatory encryption, the 403/400 failure modes, and v1/v2 recipient behavior. The agent can predict outcomes and error handling before calling.

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 long but modular: summary sentence, 'Agent usage', 'Encryption' with v1/v2 bullets, and 'ACCESS'. Every sentence earns its place given the encryption complexity and auth prerequisite, and critical information is front-loaded in the first sentence.

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 state-changing tool with nuanced encryption requirements and no output schema, the description covers preconditions, post-call polling, error recovery, and authentication. An agent has enough information to invoke it successfully and handle expected failures.

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?

Although schema coverage is 100%, the description adds substantial meaning: message must be a ciphertext envelope, plaintext gets rejected, v1/v2 key-wrapping differences, AAD as hitlId, and how to construct v2 via SDK calls. This is exactly the kind of parameter semantics an agent cannot infer from 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 states the precise action and object: 'Create a HITL confirmation request' and clarifies that it sends an approval request to channels on a referenced HITL config. This is specific enough to distinguish it from siblings like create_hitl and get_confirmation without needing to open their 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 'Agent usage' section is an explicit playbook: authorize the HITL config first, call request_hitl_authorization on a 403, then poll get_confirmation or use get_confirmation_approval_link. It even warns that start_login does NOT open this tool, removing ambiguity about authentication.

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 fully carries the behavioral disclosure burden. It reveals that the attestation says nothing about the artifact or business behind it, that each mint is billable, that over-long lifetimes are rejected and never truncated, and that the result consistently includes the effective_status/is_valid pair across create/get/list. These are significant behavioral commitments beyond a simple 'creates X' statement.

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 dense but every sentence carries information: core semantics, attestation limits, billing, lifetime behavior, response shape consistency, and authentication requirements. It is front-loaded with the main definition and uses an ACCESS section for operational prerequisites. No filler or repeated schema content is present.

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

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

There is no output schema, so the description appropriately explains the return result (publishable token plus DERIVED effective_status/is_valid). It also covers authentication, proof account requirements, the key lifetime constraint, billing, and the exact scope of the attestation. Given the complexity of a billable, security-sensitive minting operation, this is remarkably complete.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters, including format constraints, examples, and rejection rules. The description adds useful high-level context like the control proof remainder relationship and the publishable signed token, but it does not materially add per-parameter meaning beyond the schema. This meets the baseline for high schema coverage.

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

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

The description states a specific action ('Create a delegation'), the precise resource ('a typed url/purl artifact'), and the exact scope of the operation ('for a set of capability scopes'). It also clarifies what the attestation does and does not mean, which distinguishes it from a generic create tool. This is far beyond a tautology or vague restatement.

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 prerequisites and a when-not condition: it requires a Proof account and explicit authentication, and states that start_login does NOT open this tool. It also frames the operation around control-proven domains, which implies when it is appropriate. It does not explicitly compare against related tools like create_authorization or verify_delegation, but the access guidance is concrete and actionable.

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 transparency burden. It usefully warns that credentials will be visible in the AI conversation context and explains that authentication is required before the tool can be called. It does not address overwrite or idempotency semantics, so it is not a 5.

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

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

The purpose and privacy warning are front-loaded in two compact sentences, and the access note is operationally relevant. The phrasing of the start_login flow is slightly awkward, but there is no wasted text.

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 creation tool, the description covers the operation's purpose, the sensitive-data caveat, and the required authentication flow. It does not describe return values, but there is no output schema and the invocation path is otherwise sufficiently 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 already provides 100% coverage for both parameters, including examples for provider and a description for credentials. The description adds no parameter-level detail beyond the schema, so baseline 3 is appropriate.

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

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

Clearly identifies a specific action ('Store DNS provider credentials') and its purpose ('automated domain verification'). It is distinguishing enough at a glance, though it does not explicitly differentiate itself from similar siblings like connect_dns_provider or add_verification_provider.

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 contextual guidance: this tool is for storing credentials for automated domain verification, and it explains the required access preconditions ('needs a Proof account', authenticate via /mcp or start_login). It does not name alternatives or state when not to use it, so it stops 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.

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

With no annotations, the description carries the full burden, and it does well: it discloses the authentication requirement, that account access is needed, and that creating a config is not sufficient on its own—authorization must be requested before use. It doesn't describe return values or side effects, but the workflow and prerequisite context are strong.

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 organized into three clear paragraphs: core purpose, agent workflow, and access note. Every sentence adds operational value, the purpose is front-loaded, and there is no redundant or vague 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?

The description covers the key contextual needs: prerequisites, authentication, sequencing with sibling tools, and channel-specific setup. It does not explain what the tool returns after creation, but there is no output schema and the steps needed to invoke it correctly are sufficiently complete.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by explaining that channels are for approval requests, and specifically instructs how to obtain and include the Telegram chat_id via create_chat_id_discovery, which is not implied by the schema alone.

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 'Create a HITL config', a specific verb and resource, then clarifies the config's role: defining messaging channels and default timeout. This clearly distinguishes it from related siblings like update_hitl, delete_hitl, get_hitl, and request_hitl_authorization.

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 'Agent usage' section explicitly tells the agent what to do before and after calling this tool: call request_hitl_authorization after creation and create_chat_id_discovery first for Telegram. It also states access requirements and that start_login does NOT open this tool, giving clear when-to-use and when-not-to-use guidance.

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

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

With no annotations, the description carries the full burden and discloses key behavior: it creates an asynchronous challenge, requires polling get_identity_challenge until terminal states (confirmed, denied, expired), and needs an authenticated Proof account. It also clarifies that start_login does not open this tool, preventing a common auth mistake.

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 purpose, then agent usage, then access notes. Every sentence earns its place with no filler.

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

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

For a tool with no annotations and no output schema, the description covers the critical operational details: auth requirements, polling flow, and terminal states. It could go further by describing the non-ID fields in the initial response or error cases, but it is largely complete.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description adds context for why suspicious_channel matters, but does not add syntax or format details beyond what the schema provides.

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 ('Create') and resource ('Proof-Me cross-channel identity challenge'), plus scope ('for an enrolled challenger'). It does not explicitly distinguish this from creation siblings like create_confirmation or create_multi_channel_verification, so sibling differentiation is missing.

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 clear usage scenario: the account holder approves/denies on a different channel than the suspicious contact. It also tells the agent to poll get_identity_challenge with the returned ID. However, it does not state when to prefer this over sibling creation tools.

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 and does so thoroughly: it discloses the first-wins cancellation behavior, single-billing at the winning channel's completion, the response structure (group_id, channels array with deep_link/sms_message, qr_text semantics), and the polling requirement. No behavioral trait is left ambiguous.

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 well-structured and front-loaded with the core semantics, then a clearly labeled 'Agent usage' block. Every sentence earns its place, though it is somewhat dense. It avoids fluff and redundancy, making it easy to parse.

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 compensates fully: it explains the response format (group_id, channels array with deep_link/sms_message, qr_text), how to present links, and how to poll for completion. It also covers access requirements. Nothing an agent needs to call and handle this tool 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 the schema already documents all six parameters. The description adds no additional meaning to the parameters themselves; the 'first to complete wins' behavior for the channels array is already in the schema description. Baseline 3 is appropriate.

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

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

The description opens with a specific verb and resource ('Create a multi-channel phone verification') and immediately distinguishes its semantics (OR/first-wins) from any single-channel alternative. It clearly differentiates from sibling tools like create_verification by the parallel-channels behavior and the explicit mention of group_id and cancellation of losing siblings.

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

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

Provides an explicit 'Agent usage' section that tells the agent exactly how to handle the response (pass deep_link to render_auth_link, print qr_text verbatim or omit, poll with get_multi_channel_verification_status). It also warns that start_login does NOT open this tool and requires a Proof account, giving clear when-to/not-to guidance.

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

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

With no annotations, the description must stand alone, and it does add useful operational context by requiring prior authentication and explaining the retry step. It does not disclose side effects (e.g., is_primary behavior), whether creation is idempotent, or what the success/error contract looks like.

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 action is stated in the first sentence, and the access note is a separate short block. There is no filler, and each sentence contributes either the purpose or a critical precondition.

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

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

The description includes the key gating information (account needed, authentication flow) and a high-level field summary, which is meaningful. However, with no output schema and no annotations, it leaves out return values, error behavior, and profile management semantics, so an agent still has to infer several important calling 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 8 parameters (100% coverage), so the baseline is 3. The description only groups the parameters into categories and adds no semantics beyond the schema, such as constraints or interactions between is_primary, is_public, and is_business.

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 'Create a new profile' and names the supported payload areas (display name, bio, avatar, business info, theme settings), giving a specific verb, resource, and scope. The word 'new' distinguishes it from profile-update and profile-deletion siblings.

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

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

It clearly states the access precondition (Proof account, authenticate the client) and warns that start_login does not open the tool, which prevents a known wrong workflow. However, it never says when to choose create_profile over related tools like update_profile, set_primary_profile, or list_profiles.

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 disclosure burden. It names the three return artifacts and their formats, explains that sessions are hosted with callbacks, warns about the qr_text misuse trap, and calls out the Proof account authentication prerequisite. This goes well beyond what the schema alone reveals.

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 well-organized with clear sections: purpose/returns, agent usage, and access. Every sentence adds operational value, from the terminal-state polling hint to the authentication note. It is longer than average but not padded, and the scoping information 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 tool with 6 parameters, no output schema, and no annotations, the description is remarkably complete: it covers return format, next steps, auth requirements, and lifecycle states. It does not detail error handling or channel-specific behavior, but the schema already documents the channel enum. A small gap remains around side effects like message delivery, which are implied but not explicit.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add parameter-level details beyond what the schema already documents, but it does contextualize some outputs (like qr_text) that relate indirectly to channel and phone_number. It neither harms nor materially enhances parameter understanding.

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: 'Create a new phone verification session', and immediately distinguishes it from sibling tools by naming render_auth_link and wait_for_session as downstream consumers. It also clarifies what the tool returns (deep_link, qr_code, qr_text), leaving no ambiguity about its role.

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 'Agent usage' section gives an explicit orchestration sequence: pass deep_link to render_auth_link, never render qr_text with a link renderer, and poll with wait_for_session. It also explicitly states a when-not-to-use condition: 'start_login does NOT open this tool.' This is exemplary usage guidance.

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

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

No annotations are provided, so the description carries full behavioral disclosure. It does disclose the authentication prerequisite and session dependency, which is useful, but it does not describe the side effects of creation, such as whether the request is cancellable, how it is delivered to the other user, or what happens after submission.

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 succinct sentences with zero filler. The purpose is front-loaded)Skip, and the ACCESS note is directly actionable for an agent that may hit an auth wall on the first call.

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 does not explain how the 'other user' is addressed, given that the schema has no recipient identifier parameter. It also does not clarify the post-creation flow (e.g., sharing a link, claim step, cancellation), and there is no output schema to compensate. For a 10-parameter tool with no annotations, this is a significant 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 input schema already documents all 10 parameters with descriptions (100% coverage), so the baseline is 3. The description adds only a general sense that 'assets' refers to what is requested, which does not go beyond the schema.

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

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

The description clearly states the action (create a new verification request) and the resource (asking another user to share verified assets). It is specific but does not explicitly differentiate itself from similar siblings like create_verification_request, relying mostly on the word 'user' in the name.

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 concrete usage context: requires a Proof account, and tells the agent exactly how to authenticate if it is not yet authenticated (via start_login). It does not mention alternatives or exclusions, so it misses the top rung.

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 does so thoroughly. It details the response shape (challenge object, status, proof token), the critical LIVE vs pk_test_ telegram_bot difference, the presence of deep_link on messenger channels, the absence of qr_text, and the OTP vs deep-link interaction model. This is genuinely transparent about non-obvious behavior.

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

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

The description is long but dense with necessary operational detail: required parameters, examples, response variations, downstream tool usage, and authentication prerequisites. Every sentence earns its place for a tool with this many branching behaviors, though it could be more scannable with bullet points.

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 complex 9-parameter tool with nested objects and no output schema, the description is unusually complete: it covers required inputs, key response fields, channel-specific flows, follow-up tools, and access requirements. It does not elaborate on less common optional parameters like dns_provider or email_prefix, but the schema descriptions cover those, so nothing critical 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 covers all 9 parameters with descriptions, so the baseline is 3. The description adds meaningful value beyond the schema by giving concrete type/channel/identifier examples, explaining the relationship between type and channel, and clarifying response semantics per channel (challenge vs verified, deep_link vs OTP code). This goes beyond what the schema alone conveys.

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 ('Create a new identity verification') and immediately explains it initiates a verification flow for an asset identifier, listing the asset types. It is clear about what the tool does, though it does not explicitly differentiate it from similarly named siblings like create_verification_request or create_multi_channel_verification.

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 'Agent usage' section gives explicit instructions on what to pass (type, channel, identifier) and includes concrete examples. It also gives clear context on follow-up behavior — polling get_verification, using wait_for_verification, and passing deep_link to render_auth_link — plus a when-not signal: start_login does NOT open this tool. It stops short of naming sibling alternatives for similar creation flows.

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 of behavioral disclosure. It adds useful access-related behavior: authentication is required, and start_login will not open this tool. However, it does not disclose the lifecycle effect of creating a request—whether it is asynchronous, whether user action is required afterward, or what the response contains—so transparency is only partial.

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 front-loaded with purpose and stays tight. The first paragraph states the core behavior, and the second delivers actionable auth guidance plus a non-obvious warning. No sentence is wasted, and it avoids repeating schema details.

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 10-parameter nested-object tool with no output schema and no annotations, this description is functional but not fully complete. It covers authentication and asset scope well, and the rich schema covers parameters, but it doesn't describe the response shape, the asynchronous verification flow, or how redirect/webhook behavior fits into the overall request lifecycle. These gaps are noticeable but not fatal.

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 including assets, expires_in, partial_ok, action_type, callback_url, redirect_url, and reference_id. The description only adds the high-level 'multi-asset in a single flow' framing, which doesn't add parameter-level meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description opens with a specific verb+object: 'Create a multi-asset verification request' and enumerates the supported asset types. This clearly defines the tool's scope and distinguishes it from single-purpose alternatives like create_verification or start_login without needing to open 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?

The ACCESS section gives an explicit prerequisite and call sequence: a Proof account is required, the client must authenticate via /mcp, then call the tool again. It also warns that start_login does NOT open this tool, which prevents a common misuse. It doesn't name alternative request-creation tools, but the context is still 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?

Since there are no annotations, the description must disclose behavior. It does so clearly: soft delete sets status to archived, it stops appearing in the default list, and it is recoverable via list_circles. It also states the access requirement (Proof account) and that authentication is needed. This goes beyond a simple 'archives a circle' and covers key behavioral aspects an agent needs to know. It lacks details on return value or error cases, but these are less critical for such a simple 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 two well-structured sentences plus a two-line access note. The main action and key behavior are front-loaded ('Archive a Circle (soft delete — sets status to archived)'), followed by the recovery context and access requirement. There is no redundant or extraneous text; every sentence adds value.

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 a single parameter, no output schema, and no annotations, the description is remarkably complete. It covers purpose, behavior (soft delete, visibility change), recovery usage (list_circles with status filter), and access prerequisites (Proof account, authentication, and the note that start_login does not open this tool). An agent has all necessary information to decide whether and how to invoke this 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 provides a 100% description coverage for the single parameter 'id' ('Circle ID to archive'), including a regex pattern. The tool description adds no additional semantics or details about the parameter beyond what the schema already states. Per the rubric, with high schema coverage, a baseline of 3 is appropriate, and the description does not enhance 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 states a clear, specific action: 'Archive a Circle (soft delete — sets status to archived)' with the resource 'Circle'. It clarifies the behavior (soft delete) and distinguishes it from any other sibling (there is no other delete_circle). The purpose is unambiguous and self-contained.

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 provides context for when to use this tool: to archive (soft-delete) a circle, and explicitly notes recoverability via list_circles with status='archived', implying an alternative recovery path. It also includes an access precondition (Proof account, authentication) and explicitly states that start_login does NOT open this tool, giving a clear exclusion. It does not name a direct alternative to this tool because none exists among siblings, but the recovery path and access note constitute reasonable guidance.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It explicitly notes the destructive impact on dependent domains and includes authentication prerequisites, which goes beyond simply saying 'delete.' It does not mention all possible side effects, but the core consequence is disclosed.

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

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

The description is concise and front-loaded with the core action and impact. The access/auth note is slightly verbose but relevant, and no filler sentences detract from the structure.

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 single-parameter delete operation with no output schema, the description covers the action, the consequence, and the authentication requirement. It could mention how to find the credential ID, but that is a minor gap for a tool this simple.

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 fully describes the single parameter: 'DNS credential ID to delete.' The description adds no additional parameter-level meaning, but the 100% schema coverage means the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: 'Delete a stored DNS provider credential.' This clearly distinguishes it from siblings like create_dns_credential and list_dns_credentials by calling out both the action and the object.

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 provides useful context: it warns that domains using this credential will need new credentials for automated verification, which implies this is a consequential action. It does not explicitly name alternatives or when-not-to-use, but the purpose is specific enough that the usage context is 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It openly states that deletion cannot be undone, and it explains the authentication/session requirement. It does not detail cascading effects or response behavior, but the major risks are surfaced.

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 economically written and front-loads the core action and irreversibility before the access instructions. The auth note is slightly verbose but every sentence contributes necessary information for invoking the tool successfully.

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 one-parameter delete operation with no output schema, the description adequately covers what an agent needs to know: what is deleted, that it is irreversible, and how to obtain the required session. It could mention how to find the domain ID, but the sibling list_domains tool makes that discoverable.

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 the single parameter as 'Domain ID to delete,' and the description does not add much beyond that. Since schema description coverage is 100%, the baseline of 3 applies; the description simply reinforces the parameter's purpose without adding new semantic 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 clearly states the action ('Remove a domain from the account') with a specific verb and resource. It is unambiguous and distinct from siblings like add_domain or list_domains, though it does not explicitly name an alternative to differentiate from.

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 explicit context for use: a Proof account is required, and it directs the agent to authenticate or use start_login to establish a session before calling the tool again. It does not discuss alternative tools, but the auth prerequisite is clear and actionable.

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 of behavioral disclosure. It reveals that deletion is an archive operation that sets status to archived and that the config cannot be used for new confirmations after deletion. It also notes the authentication requirement. This provides meaningful context about the tool's effects and consequences, going beyond a simple 'deletes a config'.

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 concise, with the main action front-loaded. The ACCESS note is useful and not excessive. Every sentence contributes information: the action, the consequence, and the auth prerequisite. It is appropriately sized for a simple tool.

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

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

For a single-parameter tool with no output schema, the description covers the essential behavioral and consequence information. It explains the archive nature, the post-deletion limitation, and the auth requirement. Nothing critical for an agent to call it correctly is missing.

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

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

Schema description coverage is 100%, so the id parameter is already documented. The description does not add any additional detail about the parameter beyond what the schema provides. According to the rubric, a baseline of 3 is appropriate when the schema covers the parameters, and the description doesn't compensate further.

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

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

The description states a clear verb ('Delete') and resource ('HITL config'), with the parenthetical 'archive' clarifying the operation is a soft delete. It distinguishes from delete_hitl_keys by naming the resource specifically, though it doesn't explicitly contrast with update_hitl or other siblings. The action is unambiguous and specific enough for an agent to understand the tool's purpose.

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 provides no explicit guidance on when to use this tool versus alternatives like update_hitl or delete_hitl_keys. The ACCESS note about authentication is a prerequisite, not a usage directive. It implies usage when you need to archive a HITL config, but there are no exclusions or comparisons to sibling tools.

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 present, so the description must carry the behavioral load. It does so strongly by warning that existing ciphertexts will become permanently unreadable, disclosing the destructive consequences, and clear access requirements.

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

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

The description is compact and front-loaded: first the purpose, then the warning, then access instructions. No sentence is wasted, though the authentication workflow could be slightly tightened without losing 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 one-parameter destructive tool with no output schema, the description covers the essential information: what is deleted, the permanent consequence, and the authentication prerequisite. The agent has enough to decide whether to call it and what to expect.

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 covers hitl_id fully with 100% schema description coverage, so the description does not need to add parameter detail. It adds no extra meaning beyond the schema, which is acceptable for this simple one-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 states a specific action and resource: deleting the encryption keypair from a HITL config. It is distinct from the sibling delete_hitl, which likely deletes the whole config, and from upload_hitl_keys / get_hitl_keys, which manage keys for reading or writing.

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 use: requires a Proof account, requires authenticating the client, and explicitly warns that start_login does NOT open this tool. It does not name alternative key-management tools, but the access instructions and exclusion of start_login provide solid usage guidance.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It adds useful context: the primary-profile restriction and the requirement to authenticate with a Proof account rather than relying on start_login. Still, it doesn't disclose irreversibility, side effects, or what a successful/failed deletion returns.

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: core action first, constraint second, access instructions last. Each sentence adds a distinct piece of information without unnecessary padding.

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

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

For a simple one-parameter destructive tool, the key constraint and authentication requirement are covered. However, with no output schema and no annotation coverage, the description leaves the deletion's permanence, side effects, and expected return behavior to inference.

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

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

There is only one parameter, profile_id, and the schema already describes it as 'Profile ID' with 100% coverage. The description adds no additional parameter meaning beyond saying deletion is by ID, so the baseline score 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 ('Delete'), resource ('profile'), and lookup key ('by ID'). It is clear and unambiguous, though it doesn't explicitly differentiate itself from sibling deletion tools like delete_profile_template.

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

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

The description implies the tool is used when a profile needs to be deleted and gives one important exclusion (cannot delete the primary profile if it is the only one). However, it does not name alternatives or provide explicit when-to-use versus when-not-to-use guidance beyond that constraint.

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 exposing behavior and does so by stating the destructive effect, the fallback to the default template, and the authentication prerequisite. It could add whether the deletion is permanent or how errors are surfaced, 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 short paragraphs with the core behavior first and the access warning second. Every sentence adds information, and there is no filler or repetition of the tool name.

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 three-parameter delete tool with no output schema, the description covers what happens, the required authentication, and a common failure path (unauthenticated use). It is slightly incomplete in not spelling out that profile_id selects the profile whose custom template is deleted, but the overall context 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?

Schema coverage is 100%, so the baseline is 3; the description does not add detail about profile_id beyond the schema. The prose 'channel and message type' mirrors the channel and type fields, and profile_id is left generic while it plausibly refers to the profile whose template is being removed.

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 (Delete) on a specific resource (custom profile template) and describes the consequence: reverting to the default template for the given channel and message type. The qualifier 'custom' distinguishes it from sibling tools like delete_template and delete_profile without relying on the name alone.

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

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

The description gives practical invocation guidance: a Proof account is required, the client must be authenticated, and start_login does not make this tool reachable. However, it does not explicitly say when to choose this over update_profile_template or delete_template, nor does it state conditions under which it should not be used.

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 the key side effect (reverting to the default template) and the Proof account requirement, and even warns that start_login does NOT open this tool. It does not state permanence or behavior when no custom template exists, but it provides meaningful behavioral context beyond the schema.

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

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

The description is compact and front-loaded with the core purpose, followed by directly useful access instructions. Every sentence earns its place, including the specific 'start_login does NOT open this tool' warning, which prevents a common wrong path.

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 tool with no output schema, the description covers what the tool does, the resulting state, and the access prerequisite. It is slightly incomplete only in not mentioning alternative template-management tools or the no-custom-template edge case, but these are not critical for a correct call.

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 schema already documents channel and message_type. The description adds the useful connection that these parameters identify the template to delete and its channel/message-type scope, but it does not need to add more since the schema is complete.

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: 'Delete a custom template, reverting to the default template for that channel and message type.' This names the action, the target, and the consequence, and the channel/message-type scoping distinguishes it from sibling tools like delete_profile_template.

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 first sentence implies the use case: call this when a custom template should be removed and the default restored. The ACCESS note gives an operational precondition ('Authenticate this client... then call this tool again'), but no explicit alternatives or when-not-to-use guidance are provided, so it is inferred rather than 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?

With no annotations, the description carries the behavioral disclosure burden. It adds valuable non-schema behaviors: the 10,000-record maximum, the Proof account requirement, and the authentication caveat about start_login. It does not disclose what happens if the limit is exceeded or whether the export has side effects, but it covers the most critical operational constraints.

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: the core purpose and formats appear in the first sentence, followed by filtering and the record limit, then the access note. Every sentence contributes actionable information with 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?

For a four-parameter export tool with no output schema and no annotations, the description covers the essential information: export purpose, formats, filters, record cap, and authentication prerequisite. The main gap is that it does not describe how the exported data is returned (file, content, URL) or what happens over the 10,000-record limit, but the description is still operationally 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?

Schema description coverage is 100%, so the schema already fully documents to, from, format, and status. The description only restates that date range and status filtering are supported without adding syntax, defaults, or parameter interactions beyond the schema. This meets the baseline but adds no extra semantic value.

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 and resource: 'Export authorizations as CSV or JSON.' This clearly distinguishes it from read/list tools like list_authorizations and get_authorization by emphasizing bulk export with format options. However, it does not explicitly name or contrast sibling tools such as export_data, so it falls just short of full differentiation.

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 concrete usage context: a Proof account is required, the client must be authenticated via /mcp, and the tool should be called again after authentication. It also explicitly warns that start_login does NOT open this tool, providing a useful exclusion. It does not, however, explain when to choose this over list_authorizations or export_data.

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 present, so the description carries the burden. It discloses a strict rate limit (1 export per 24 hours), the account-access requirement, and the fact that this tool is not reachable via start_login. It does not say how the export is delivered, but the operational constraints are unusually explicit for a zero-parameter 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 compact and front-loaded: purpose first, rate limit second, access flow third. Every sentence earns its place, and the authentication warning is concrete and actionable.

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 no-parameter tool in a huge sibling set, it covers the main invoke-blocking factors: what is exported, the legal scope, the rate cap, and the authentication prerequisite with a retry instruction. The only open question is the response/delivery format, but the description gives enough for safe selection and first 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 and schema description coverage is 100%, so there is no parameter ambiguity. The description reinforces this by focusing entirely on action and access prerequisites rather than arguments.

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: 'Export all account data', and ties it to GDPR Article 20. This clearly distinguishes it from narrower siblings like export_authorizations and from list_* retrieval 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?

It gives explicit preconditions: a Proof account is required, and the client must be authenticated before calling, with a concrete remediation path: 'Authenticate this client ... then call this tool again'. It also warns that start_login does NOT open this tool, though it does not explicitly name alternatives for scoped data exports.

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. It discloses the authentication requirement (needs a Proof account, authenticate or sign in) and the sequence to follow. However, it does not disclose other behavioral aspects such as whether the operation is idempotent, what happens if the request is not pending, or any side effects. Given it's a mutation, more disclosure would be helpful, but the authentication note is valuable.

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 concise with two sentences. The purpose is front-loaded, and the authentication note is directly relevant and placed after the purpose. No fluff or 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 one-parameter mutation with no output schema, the description includes the critical authentication prerequisite. It doesn't detail error conditions or result expectations, but given the simplicity and full schema coverage, 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 schema covers 100% of the parameter (id) with a clear description. The tool description does not add extra meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description clearly states the action (extend) and the target (expiration time of a pending verification request). It distinguishes itself from siblings like cancel_verification_request and get_verification_request, which have different purposes.

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

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

The description implies usage from its purpose (when you want to extend expiration) but does not explicitly compare to alternatives or state when not to use it. There is no mention of when to choose a different tool, so guidance is only implicit.

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 disclosure burden. It clearly defines all possible states, explains what 'pending' means, specifies terminal-state behavior, and includes access/auth prerequisites. This is well beyond a minimal 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 description is organized into a concise summary, agent usage instructions, and access requirements. Every paragraph serves a distinct purpose, and critical operational details are front-loaded.

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

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

For a simple one-parameter polling tool with no annotations and no output schema, the description is remarkably complete. It covers how to invoke, response states, terminal state handling, and authentication requirements, so an agent can 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 session_id as '2FA session ID.' The description adds context that this is used after start_2fa, but doesn't add substantial semantics beyond the schema 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?

The description uses a specific verb and resource: 'Check the status of a 2FA session by session ID.' It also enumerates the possible return states, making the tool's function unambiguous and clearly distinct from siblings like start_2fa and verify_2fa.

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 explicitly tells the agent to poll after calling start_2fa, to check every few seconds, and what to do at each terminal state ('expired' → restart with start_2fa, 'verified' → proceed). It lacks an explicit comparison to alternatives like wait_for_2fa, so it doesn't fully cover when-not-to-use.

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 burden. It adds useful access context and the 'in-progress' constraint, but it does not explicitly state that this is a read-only/idempotent operation or describe session lifecycle or return behavior.

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

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

The description is short and front-loaded with the core purpose, followed by an access note. The access note is slightly awkward ('a session opens this tool') but still earns its place by covering an important prerequisite.

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 status-check tool with one parameter and no output schema, the description is mostly adequate. It could be improved by naming start_add_email as the session-creation counterpart and by hinting at what status values the caller might expect.

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

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

Schema coverage is 100% and the single parameter is documented as 'Add-email session ID.' The description adds minimal extra meaning beyond 'by session ID,' which matches the baseline for fully covered schemas.

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: 'Check the status of an in-progress email addition by session ID.' This is precise and distinguishes the tool from related siblings like get_add_phone_status and list_emails.

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 clearly implies this tool is used after an email-addition flow has been initiated and provides explicit auth prerequisites ('needs a Proof account', 'Authenticate this client... or sign in with start_login'). It does not explicitly name alternatives, but the usage context is 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?

With no annotations, the description carries the burden of behavioral disclosure. It usefully reveals that the tool requires an authenticated Proof account and that it is meant to be polled repeatedly. However, it does not describe what terminal states look like, what the response contains, or what happens with an invalid session ID.

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: the purpose appears in the first sentence, followed by a needed access note. The parenthetical '(Claude Code: /mcp → Authenticate)' is somewhat environment-specific, but it does not make the description bloated.

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 one-parameter tool, this is close to sufficient: it explains what to call, with what key, and the authentication prerequisite. The main gap is the absence of return-value or terminal-state details, which matters because there is no output schema to fill that 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 only parameter, session_id, is already fully described in the schema ('Add-phone session ID'), so schema coverage is 100%. The description's 'by session ID' simply restates the parameter and adds no extra meaning about format, origin, or lifecycle.

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 first sentence states a specific verb ('Check'), the resource ('status of an in-progress phone addition'), and the lookup key ('by session ID'). This makes the tool's purpose unambiguous and clearly separates it from sibling tools like start_add_phone or get_add_email_status.

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 provides clear operating context: it is a polling tool ('Poll until terminal state') and it explicitly warns that authentication is required, including how to authenticate or sign in via start_login. It does not explicitly name alternatives or when-not-to-use conditions, but the invocation context is 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, the description carries the full burden and delivers: it discloses the auth precondition, the access restriction to one's own key, the privacy guarantee ('Counts only — no recipient identifiers'), and the retry-after-login failure path. It does not cover error semantics for invalid/inactive key ids, but the safety and access profile is substantially disclosed.

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

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

Two well-organized paragraphs: the first front-loads purpose, response contents, and restrictions; the second adds the access prerequisite with a concrete remedy. Every sentence earns its place, though the ACCESS guidance is slightly verbose.

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 2-parameter read tool with no output schema, the description enumerates the expected response fields well enough to compensate for the missing schema, and the auth requirement plus counts-only privacy note close the main usage gaps. Minor omissions — specific error behavior and exact failure mode of an unauthenticated call — are acceptable at this complexity.

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 both parameters (id, environment) are already documented in the schema; baseline 3 applies. The description adds only marginal context — it echoes 'key id' and implies that passing another account's key will fail given the own-keys-only scoping — but does not exceed what the schema provides.

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

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

States a specific verb and resource — 'Get per-API-key usage for a given key id' — and enumerates the exact response components (verification counts by type/channel/status, request/confirmation/authorization totals, attribution context). The 'per-API-key' framing plus the 'Counts only — no recipient identifiers' clarification distinguishes it from siblings like get_usage and get_self_api_key.

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

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

Provides clear context: scoped to the authenticated account, API-key callers may read only their own key, and a Proof account with authentication is required — including a concrete recovery path (start_login, then call again). It does not explicitly name alternatives or when-not-to-use conditions relative to get_usage, but the usage envelope is well defined.

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 burden. It discloses the authentication requirement and clarifies that start_login won't open the tool, which is useful. However, it doesn't state whether the operation is read-only, what happens on missing IDs, or any rate limits – though the word 'Get' implies a read. It adds some behavioral context but not deep transparency.

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 paragraphs: a concise purpose sentence and a focused access note. It is front-loaded with the main action and keeps the access instruction separate. No redundant phrasing; each sentence 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 names what it returns (type, value, status, verification timestamps). It also covers the access prerequisite and the start_login caveat. Minor gaps exist – error behavior for non-verified or nonexistent IDs isn't mentioned – but for a single-get tool this is largely 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?

Schema coverage is 100% (id is described as 'Asset ID'). The tool description adds minimal extra meaning – it refers to 'by ID' but doesn't elaborate on ID format, required type, or validation rules. The schema already documents the parameter sufficiently, so the description doesn't compensate beyond 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?

The description clearly states 'Get a single verified asset by ID' – a specific verb, resource, and scope. It distinguishes from list_assets (list vs single) and other get_* tools by asset resource, but it doesn't explicitly name an alternative or contrast with a sibling. The term 'verified' adds precision.

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 provides actionable context: requires a Proof account, how to authenticate, and explicitly warns that start_login does not open this tool. However, it doesn't give guidance on when to choose this over list_assets or other asset-related tools, leaving alternative selection to the agent.

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 behavioral burden. It clearly signals a read-only operation ('Get', 'Returns the current state'), discloses the access requirement, and notes the authentication step. It doesn't overpromise or hide side effects; for a getter this is sufficient transparency.

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 dense sentences: the first defines the operation and return data, the second gives the access prerequisite and concrete authentication steps, the third eliminates a common wrong path (start_login). No fluff 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?

For a single-parameter getter with no output schema, the description covers the essential return content (status and usage statistics) and the access prerequisite. It doesn't describe where the authorization ID comes from, but the sibling list_authorizations implies the discovery path. Minor omission, otherwise complete.

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

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

Schema description coverage is 100%, with 'id' described as 'Authorization ID.' The tool description adds no further meaning about the ID format or how to obtain it. Since the schema already documents the only parameter, 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 opens with a specific verb and resource: 'Get an authorization by ID.' It distinguishes itself from list_authorizations (which lists all) and revoke_authorization by clarifying it returns the current state, not a mutation. The scope is unambiguous.

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 provides clear operational context: requires a Proof account, instructs the agent to authenticate first and then call again, and explicitly warns that start_login does NOT open this tool. It doesn't name alternatives like list_authorizations for finding IDs, but it gives actionable preconditions and an exclusion.

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

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

With no annotations, the description carries the behavioral burden. It discloses a meaningful security behavior ('an identifier is NEVER returned — SEC-PM-006') and the authentication prerequisite, which are not visible in the schema. The read-only nature is only implied by 'Get' rather than stated, but the added privacy and access context is substantial.

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: the core purpose and return shape appear in the first sentence, followed by a tight access note. Every sentence contributes either behavioral disclosure or routing guidance; 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 single-parameter lookup with no output schema, the description explains what is returned, highlights a key privacy constraint, and states the authentication prerequisite. It does not specify error behavior or the exact member data shape, but the essential calling context is covered.

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 one parameter, id, and schema description coverage is 100%: the schema already documents it as a Circle ID with a regex pattern. The description adds only 'by ID', which maps directly to the schema, so it does not meaningfully extend parameter semantics beyond 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?

The description opens with 'Get a Circle by ID', naming a specific verb and resource, and then specifies what is returned (members and per-member channel presence booleans). It is clearly distinguishable from siblings like list_circles, create_circle, update_circle, and delete_circle.

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 a clear access context: a Proof account is required, the client must be authenticated first, and 'start_login does NOT open this tool' is an explicit when-not. It does not explicitly name alternatives like list_circles for discovering the ID, so it falls short of full usage routing.

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

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

No annotations are provided, so the description must carry the behavioral burden. It discloses that authentication is required and that the tool returns the full confirmation with specific fields. However, it does not mention error handling, idempotency, or any side effects (though read-only is implied). This is adequate but not rich.

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 extremely concise: two sentences plus an access note. The main purpose is front-loaded, and the access requirement is clearly separated. No unnecessary words.

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 get-by-ID tool with one parameter and no output schema, the description covers purpose, return fields, and access prerequisites. It doesn't explain what a 'confirmation' is or potential error scenarios, but given the simplicity and sibling context, it is sufficiently complete for an agent to call it correctly.

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

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

Schema description coverage is 100% because the only parameter (id) is described as 'Confirmation ID'. The description adds nothing beyond the schema's meaning, only reiterating that it fetches by ID. Baseline 3 is appropriate when schema fully documents the 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 ('Get'), a resource ('confirmation by ID'), and the return content ('full confirmation including status, response, and proof token'). It clearly distinguishes from siblings like get_confirmation_approval_link and list_confirmations by specifying retrieval by ID and the returned fields.

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?

Explicitly states the access prerequisite (needs a Proof account) and provides concrete authentication steps (Claude Code: /mcp → Authenticate) before using the tool. It also clarifies that start_login does NOT open this tool, which helps the agent avoid a wrong path. It doesn't explicitly name alternative tools like list_confirmations, but the context is 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, the description carries the full burden and reasonably delivers: it discloses the pending-only constraint, the expiry behavior, the authentication requirement, and explicitly warns that start_login does NOT open this tool. It stops short of describing any side effects of generating a 'fresh' link (e.g., whether prior links are invalidated) or error behavior for already-approved confirmations.

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 tightly scoped sentences deliver the core action, key constraints, and access prerequisite with no filler. The main function is front-loaded, and the access note is clearly separated yet still relevant. Every sentence 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 one-parameter tool with no output schema, the description covers the essential inputs, constraints, and auth prerequisites. It does not describe the return value's shape or format, but the purpose implicitly tells the agent a link is returned. Minor gaps like side effects of 'fresh' links and error handling prevent a 5.

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

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

The schema already documents the single 'id' parameter with a pattern and description 'Confirmation ID', giving 100% coverage. The description reinforces that the ID must refer to a pending confirmation but adds no format or syntax detail beyond the schema. Baseline 3 is appropriate.

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

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

The description states a specific verb ('Generate'), a precise resource ('fresh approval link'), and a crucial constraint ('Only works for pending confirmations'). This clearly differentiates it from siblings like get_confirmation, which presumably retrieves confirmation details rather than generating a link. The expiry inheritance note adds precision.

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 states the precondition ('pending confirmation') and gives clear auth instructions ('needs a Proof account', 'Authenticate this client... then call this tool again'). It also explicitly rules out start_login as a way to access this tool. It doesn't compare against all relevant alternatives, but the guidance is unambiguous about when it works.

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 provide crucial context: it reveals that authentication is required and implies a session dependency. However, it does not describe the exact return format or error behavior (e.g., what happens if not authenticated). The description starts to cover behavioral traits but is not exhaustive, so a 3 is appropriate.

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

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

The description is two sentences, front-loaded with the core purpose, then immediately addressing the access requirement. Every word earns its place; there is no fluff. It efficiently communicates both function and usage-critical constraints.

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

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

The tool is simple (no params, no output schema), so the description is nearly complete: it states what it returns and how to authenticate. It lacks explicit detail on the return schema, but with no output schema, the agent might appreciate a hint about the structure; however, the description of 'account details, plan, and settings' is sufficient for a basic understanding. Minor gap, hence 4.

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 parameter semantics are N/A. The baseline for 0 parameters is 4, and since the description provides context about what the tool returns and its preconditions, it contributes meaningfully beyond the schema. There is no schema coverage issue; the description adds value by explaining the tool's purpose and access requirements.

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 ('Get') and the resource ('current authenticated user'), and explicitly lists what it returns (account details, plan, settings). It is distinct from siblings like get_my_profile and get_verified_user by focusing on the API key owner rather than a profile or another user. No ambiguity remains about what the tool 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 explicitly states the prerequisite (needs a Proof account) and provides specific authentication steps, including naming the alternative tool (start_login) and describing the session flow. It tells the agent exactly when to use this tool (after authentication) and what to do if not authenticated (sign in with start_login, then call again). This is exemplary guidance.

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

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

With no annotations, the description carries the burden, and it discloses the key behavioral constraint: authentication is required and start_login won't unlock it. The verb "Get" implies a read-only operation, and no side effects are suggested. Minor gaps like error behavior are not covered, but the essential access-dependent 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 definition is compact and front-loaded: the first sentence states the tool's purpose, and the second paragraph gives the required access steps. Every sentence adds relevant information without repetition or fluff.

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

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

For a zero-parameter read-only listing tool with no output schema, the description covers the necessary context: what is returned (all default message templates), their role, and the prerequisite to call it successfully. No important context 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 tool has zero parameters, so the baseline is 4. The description doesn't need to explain parameter meaning because there are none to document.

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: "Get all default message templates," and further clarifies these are "built-in templates used when no custom template is set." This clearly differentiates the tool from siblings like get_template and list_templates by scoping it to defaults.

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 concrete invocation context: a Proof account is required, the client must be authenticated, and the tool should be called again after authentication. It also warns that start_login does not open this tool. It doesn't explicitly name alternatives, but the access conditions and exclusion are actionable.

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 and does this well. It discloses that effective_status/is_valid is derived from the underlying control proof, that revoked/suspended/expired domain proofs invalidate the delegation, and that the delegation never outlives its own expires_at. This is meaningful behavioral context beyond the schema.

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

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

The description is well organized: purpose and return value first, then the derivation rule, then access requirements. Every sentence carries useful information and there is no padding 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?

For a one-parameter read tool with no output schema, the description is fully sufficient. It explains what is returned, the meaning of derived fields, the dependency on proof validity, and the authentication prerequisite. No critical missing information prevents correct invocation.

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

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

Schema description coverage is 100%, and the pattern already documents the two accepted formats. The description reinforces this by mentioning 'Mongo id or ph_dlg_* handle,' but adds no fundamentally new parameter semantics beyond what the schema provides.

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: 'Get one of your delegations by Mongo id or ph_dlg_* handle.' It also clarifies what is returned (publishable token plus effective_status/is_valid), making the tool's role distinct from list or verification siblings.

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

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

The description clearly explains the authentication precondition: a Proof account is required, and start_login does NOT open this tool. It does not explicitly name alternatives like list_delegations or verify_delegation, but the single-item retrieval purpose and the exclusion of start_login provide good 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, the description carries the burden, and it discloses the access requirement, the need to authenticate, and the call-after-session behavior. It also states the returned content (metadata, credential fields, docs links), making the read-only nature clear for a getter with no side-effect warnings.

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 is front-loaded in the first sentence, and the access note is a compact second paragraph with no filler. The structure makes the primary action and prerequisite immediately visible.

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

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

For a zero-parameter metadata getter with no output schema, the description covers what it returns, the account requirement, and the exact authentication path. Nothing essential 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 tool has zero parameters and 100% schema coverage, so there is nothing for the description to add. The phrase 'all supported DNS providers' usefully confirms the unparameterized, unfiltered scope.

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

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

States a specific verb and resource: 'Get metadata for all supported DNS providers,' and specifies the content (required credential fields, documentation links). This differentiates it from sibling tools like list_dns_credentials, which would cover user-created DNS credentials rather than the catalog of supported providers.

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

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

Provides clear context: a Proof account is required and explains the authentication flow via /mcp authenticate or start_login before calling the tool. It does not explicitly name alternatives or exclusions, but the prerequisite instructions are enough for correct use.

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 burden. It discloses the authentication requirement and the data returned, but does not explicitly state that the operation is read-only and side-effect free. This is an implication from the verb, but not explicitly stated; the auth note is useful.

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 focused sentence on purpose followed by a concise authentication note. No filler; the most important information is front-loaded. Efficient and well-structured.

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 one-parameter getter with no output schema or annotations, the description is nearly complete. It states what is returned and how to authenticate, but does not explicitly mention it is a safe read-only call or what happens if the domain doesn't exist. Minor gaps, but largely 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?

Schema coverage is 100% for the single 'id' parameter, so the schema already documents it. The description only repeats that it's 'by ID' without adding extra context like where to find the ID or format constraints. Baseline 3 is appropriate.

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

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

The description clearly states the tool fetches details of a specific domain by ID, listing the returned information (verification status, DNS records, provider connections). This is a specific verb-resource combination and distinguishes it from siblings like list_domains or get_user_domain_verification_status.

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 implicitly indicates this is for a single known domain (by ID) and provides explicit authentication prerequisites (Proof account, authenticate via /mcp or start_login). It does not explicitly mention alternatives like list_domains for discovery, but the usage intent is 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, the description carries the full burden and does add value: it discloses the return shape (channels, timeout, status) and an important auth behavior. The note that 'start_login does NOT open this tool' is a genuinely useful non-obvious trait that prevents a wrong remediation path.

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 front-load the purpose and return shape, followed by a clearly separated ACCESS block. No filler, though the auth mechanics are somewhat verbose.

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 usefully enumerates the returned fields and covers the auth prerequisite. Nothing critical is missing for correct invocation.

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

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

Schema coverage is 100% for the single 'id' parameter, and the schema already documents it as 'HITL config ID'. The description's 'by ID' adds no format, source, or lookup 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?

States a specific verb and resource ('Get a HITL config by ID') and enumerates the returned fields (channels, timeout, status). It implicitly distinguishes itself from list_hitls by requiring an ID, but never names the sibling alternative explicitly.

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

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

The 'by ID' phrasing implies you call this when you already have a config ID, and the ACCESS note tells the agent it must authenticate first. However there is no explicit guidance on when to prefer this over list_hitls or other HITL siblings.

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 behavioral burden. It discloses the auth prerequisite, implies a first-call failure if unauthenticated by saying 'then call this tool again,' and documents the returned key material. It could add a note that the keypair is sensitive, but the read-only nature is clear from 'Get' and 'Returns.'

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 tight: one sentence for purpose and return value, one short block for access. Every sentence earns its place, including the caveat about start_login.

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

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

For a one-parameter read tool with no output schema, the description supplies the return shape and the prerequisite auth flow. There is no obvious missing information that would prevent an agent from invoking 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 coverage is 100% and the single parameter hitl_id is documented as 'HITL config ID.' The description adds no deeper meaning beyond the schema, but none is really needed for a single, well-named 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 and resource: 'Get the encryption keypair for a HITL config,' and states the exact return fields (public key, encrypted private key, KDF salt, key ID). This clearly separates it from related HITL siblings like upload_hitl_keys or delete_hitl_keys.

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?