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

With no annotations provided, the description carries full burden. It discloses the key behavioral trait of moving the job to COMPLETED status, which is crucial for understanding the tool's effect. However, it doesn't mention potential side effects (e.g., whether this triggers notifications, is reversible, or requires specific permissions), leaving some behavioral aspects unclear 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?

The description is efficiently structured in two sentences: the first states the purpose and usage criteria, the second explains the outcome and next steps. Every sentence adds value with no wasted words, and key 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 mutation tool with no annotations and no output schema, the description does well by explaining the state transition (SUBMITTED → COMPLETED) and suggesting follow-up actions. However, it doesn't describe the return value or error conditions, which would be helpful given the lack of output schema. The description is mostly complete but has minor 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 both parameters (job_id and agent_key). The description doesn't add any parameter-specific information beyond what's in the schema, such as format examples or constraints. The baseline score of 3 reflects adequate coverage through 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 clearly states the specific action ('Approve submitted work') on a specific resource ('for a job'), distinguishing it from siblings like 'request_revision' or 'mark_job_paid'. It explicitly mentions moving the job to COMPLETED status, which is a distinct outcome not covered by other tools.

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

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

The description provides explicit when-to-use criteria: 'when the human has submitted their work for review (status = SUBMITTED) and you are satisfied with the evidence'. It also mentions subsequent actions ('after which you can pay and leave a review'), implicitly distinguishing it from alternatives like 'mark_job_paid' which handles payment separately.

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. It discloses two important behavioral traits: pending applications will be rejected, and a creator-only permission check. It does not mention return values or irreversibility, but these are secondary for a simple cancel 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 sentences, front-loaded with the primary action, followed by a side effect and an access constraint. Every sentence earns its place with no wasted 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?

Given the tool's simplicity (2 params, no output schema, no annotations), the description covers the key aspects: purpose, side effect, and authorization. It does not explain what happens to the listing after cancellation, but this is not essential for invoking the tool.

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

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

Schema coverage is 100%, so the schema documents the parameters. The description adds value by linking agent_key to the creator of the listing, clarifying that the agent_key must correspond to the listing's creator. This goes beyond the schema's simple 'Your agent API key' and 'The listing ID'.

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: 'Cancel an open listing' with a specific verb and resource. It distinguishes itself from sibling tools like create_listing and get_listing, and no other sibling tool performs cancellation.

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 use context by scoping to 'open listings' and specifies an exclusion: only the creator agent can cancel. It does not mention alternative tools explicitly, but there are no alternative cancellation tools among siblings, and the ownership constraint serves as a when-not.

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

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

No annotations exist, so the description carries the full burden. It explicitly states the operation is read-only and details the return data (verified, score, tier, timestamp). However, it does not cover error cases (e.g., invalid human_id) or other side effects, making it adequate 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 three concise sentences, each serving a clear purpose: stating the main action, listing the return values, and noting the read-only nature. There is no redundancy or filler, and the key action 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?

The tool is simple with one required parameter, no output schema, and no annotations. The description sufficiently covers the return values and side-effect profile (read-only). It omits details like error behavior or score scale, but given the low complexity, 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?

The input schema already provides a full description for human_id ('The ID of the human to check') with 100% coverage. The description only reinforces this by saying 'for a specific human,' adding no additional semantic information. Baseline 3 applies per the rubric.

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 checks humanity verification status for a specific human, and it enumerates the returned fields (verified, score, tier, when verified). This specific verb+resource combination distinguishes it from broader sibling tools like get_human or get_human_profile.

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

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

The description makes it evident that this tool is for checking a specific human's verification status, providing clear context. However, it does not mention exclusions or alternatives, such as when to use get_human instead, so it lacks explicit alternative guidance but 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?

The description discloses that the endpoint is a no-op for agents already on PRO and is deprecated, which is key behavioral information. However, it is ambiguous whether it is a no-op for all agents or might act for non-PRO agents, and it does not mention response behavior or error handling. Since no annotations are present, the description carries the burden but only partially covers it.

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 'Deprecated,' and every word provides relevant context. There is no wasted space or redundant 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 deprecated simple tool with one parameter and no output schema, the description covers the essential context: it tells the agent this is legacy and likely a no-op. The ambiguity about non-PRO agents and lack of response details prevent a perfect score, but the overall information is sufficient for an agent to understand the tool's current status.

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 the only parameter (agent_key) with full coverage (100%). The description adds no additional meaning about the parameter, such as how it affects behavior or whether it is still required, so it does not improve on 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 clearly identifies the tool as deprecated and a no-op for PRO agents, which conveys its current purpose (legacy endpoint). It uses a specific verb ('claim') and resource ('free pro upgrade') but the primary purpose is to indicate it does nothing, which is clear enough. It does not explicitly state what happens for non-PRO agents, so slight ambiguity remains.

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 tool is deprecated and that agents are auto-activated on PRO tier at registration, making it clear that this tool should not be used. This is strong when-to-not-use guidance, effectively telling the agent it is unnecessary. No alternative is named, but the instruction 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 provided, the description carries the full burden of behavioral disclosure and excels at it. It clearly explains authentication methods (API key or x402 payment), rate limits (PRO tier = 15 offers/day, x402 bypasses limits), spam filters (minOfferPrice, maxOfferDistance constraints), and error handling (rejection with specific error codes). This provides comprehensive operational context beyond basic functionality.

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 efficiently structured with three sentences that each serve distinct purposes: stating the core function, explaining authentication and rate limits, and detailing spam filters. While slightly dense due to the complex operational details, every sentence earns its place by providing essential behavioral context that isn't captured elsewhere.

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 mutation tool with 18 parameters and no annotations or output schema, the description provides strong contextual completeness. It covers authentication, payment, rate limiting, and filtering constraints that are crucial for correct usage. The main gap is the lack of information about return values or success/failure responses, which would be helpful given there's no output schema.

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

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

The schema description coverage is 100%, providing detailed documentation for all 18 parameters. The description doesn't add significant parameter-specific information beyond what's already in the schema, though it does mention constraints like 'minOfferPrice' and 'maxOfferDistance' that relate to the price_usdc and agent_lat/lng parameters. This meets the baseline expectation when schema coverage 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?

The description clearly states the specific action ('Create a job offer for a human') and identifies the resource ('job offer'), making the purpose immediately apparent. It distinguishes this tool from siblings like 'create_listing' or 'make_listing_offer' by focusing on direct hiring rather than marketplace listings.

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 about when to use this tool by specifying authentication requirements (API key or x402 payment) and constraints (rate limits, spam filters). However, it doesn't explicitly mention when NOT to use it or name alternative tools for related actions, such as 'create_listing' for marketplace posts.

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 effectively describes key behavioral traits: the payment requirement ($0.50 USDC), rate limits (5 listings/day for PRO), bypass options (x402 payment bypasses limits), and the passive recruitment nature ('wait for qualified humans to come to you'). It doesn't fully describe error conditions or response formats, but provides substantial operational context.

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

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

The description is efficiently structured in three sentences that each serve distinct purposes: stating the core function, differentiating from alternatives, and providing operational requirements. There's no wasted language, and the most critical information (purpose and prerequisites) appears first.

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 tool with 16 parameters and no annotations, the description provides strong contextual coverage of purpose, usage guidelines, and behavioral requirements. It lacks information about return values (no output schema exists) and doesn't cover all edge cases, but gives sufficient context for an agent to understand when and how to use this tool effectively.

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

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

Schema description coverage is 100%, so the schema already documents all 16 parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema. This meets the baseline expectation when schema coverage is complete, but doesn't provide additional semantic context.

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 specific action ('Post a job listing'), the target resource ('Human Pages job board'), and the intended outcome ('for humans to discover and apply to'). It explicitly distinguishes this tool from its sibling 'create_job_offer' by explaining that listings are for open recruitment while job offers target specific individuals.

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 guidance on when to use this tool versus alternatives ('Unlike create_job_offer... listings let you describe work and wait for qualified humans'), prerequisites ('Requires a registered agent or x402 payment'), and rate limit information ('PRO = 5 listings/day. x402 bypasses limits'). This gives clear context for tool 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions checking status, tier, and expiry, but does not specify if this is a read-only operation, requires authentication, has rate limits, or what the return format might be. For a tool with no annotations, this leaves significant gaps in understanding its behavior.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded and every part of the sentence contributes to understanding what the tool does, making it highly concise 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?

Given the complexity of checking activation status with no annotations and no output schema, the description is incomplete. It does not explain what the return values are (e.g., format of status, tier, expiry), potential errors, or behavioral traits like authentication needs. For a tool with such gaps in structured data, the description should provide more context to be fully helpful.

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

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

The input schema has 100% description coverage, with the 'agent_key' parameter clearly documented. The description does not add any additional meaning or context beyond what the schema provides, such as explaining why the key is needed or how it's used. Since schema coverage is high, 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 states the action ('Check') and the resources ('activation status, tier, and expiry for your agent'), making the purpose understandable. However, it does not explicitly differentiate this tool from sibling tools like 'get_payment_activation' or 'verify_payment_activation', which might have overlapping or related purposes, so it falls short of a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as 'get_payment_activation' or 'verify_payment_activation', nor does it mention any prerequisites or exclusions. It implies usage for checking activation details but lacks explicit context or comparisons.

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 adds context by saying 'public profile', implying read-only access and no special permissions, and lists specific return data. However, it does not explicitly state that the operation is read-only, nor does it describe error behavior (e.g., what happens if the agent is not registered).

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 sentence, concise and front-loaded with the action and target. Every word adds value without redundancy or irrelevant 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 simple getter with one parameter and no output schema, the description adequately covers the purpose and key return fields. It lacks details on exact response structure or error handling, but given the low complexity, it is sufficiently complete for an agent to use the tool effectively.

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

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

The schema already describes agent_id as 'The registered agent ID' with 100% coverage. The description restates 'registered agent' but does not add new details about the parameter's format, constraints, or valid values. Since schema coverage is high, 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 verb 'Get' and the resource 'a registered agent's public profile', and specifies the included reputation stats (total jobs, completed jobs, payment speed). This distinguishes it from sibling tools like get_human_profile by focusing on agents and their reputation.

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 when an agent's public profile and reputation stats are needed, but it does not explicitly state when to use this tool over alternatives or mention exclusions. The phrase 'registered agent' gives some context, but no direct comparison to siblings like get_human_profile is provided.

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 describes what information is returned (bio, skills, service offerings) and what is not (contact info, wallets, social links), which is useful. However, it doesn't disclose other behavioral traits like authentication requirements, rate limits, error conditions, or response format, leaving gaps for a tool with no annotations.

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

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

The description is two sentences, front-loaded with the core purpose and followed by a crucial usage guideline. Every word earns its place—no fluff, no repetition, and it efficiently communicates both what the tool does and when to use 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's low complexity (1 parameter, no nested objects, no output schema) and the description's clear purpose and usage guidelines, it is largely complete. However, the lack of annotations means some behavioral aspects (e.g., auth, errors) are undocumented, and without an output schema, the return format is unspecified, leaving minor 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?

The description adds meaningful context beyond the schema: it clarifies that the ID is for a 'human' and that the tool returns detailed information about that human. With 100% schema description coverage (the schema already documents the ID parameter well), the baseline is 3, but the description provides additional semantic value about what the parameter represents and what data it unlocks.

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 specific action ('Get detailed information'), target resource ('a specific human by their ID'), and scope ('including their bio, skills, and service offerings'). It distinguishes from sibling tools by explicitly contrasting with get_human_profile for contact info, wallets, and social links.

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 guidance on when to use this tool vs. alternatives: use get_human for bio/skills/service offerings, and use get_human_profile for contact info/wallets/social links (with the additional constraint that get_human_profile requires a registered agent). This directly addresses sibling differentiation.

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 effectively describes authentication requirements ('Requires a registered agent API key'), cost implications ('pay $0.05 per view'), and the payment alternative method. However, it doesn't mention rate limits, error handling, or response format details.

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 efficiently structured in two sentences: the first states the purpose and data scope, the second covers authentication requirements and payment alternatives. Every sentence earns its place with essential information, and it's appropriately front-loaded with the core functionality.

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

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

For a read operation with 2 parameters and no output schema, the description provides good context about what data is returned, authentication methods, and cost alternatives. It could be more complete by mentioning response format or error cases, but it covers the essential aspects well given the tool's 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 the schema already documents both parameters. The description doesn't add any additional meaning about the parameters beyond what's in the schema (e.g., format examples for human_id or agent_key). The baseline score of 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the verb 'Get' and the resource 'full profile of a human', specifying the data included (contact info, wallet addresses, fiat payment methods, social links). It distinguishes from sibling tools like 'get_human' or 'search_humans' by emphasizing the comprehensive nature of the profile data.

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 when to use this tool ('Get the full profile') and provides a clear alternative ('pay $0.05 per view via x402 (USDC on Base) by including an x-payment header'), helping the agent choose between authentication methods. It also mentions the prerequisite 'Requires a registered agent API key'.

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 mentions that messages are ordered chronologically and include both agent and human messages, which adds useful context beyond the input schema. However, it lacks details on permissions, rate limits, or error handling, leaving some behavioral aspects unclear.

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 well-structured in two sentences. The first sentence states the core purpose, and the second provides usage guidance. Every sentence adds value without redundancy, making it efficient and 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?

Given the tool's moderate complexity (2 parameters, no output schema, no annotations), the description is reasonably complete. It covers purpose, usage, and some behavioral aspects, but lacks details on output format or error scenarios, which could be helpful for an AI agent. With no output schema, more information on return values 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?

The input schema has 100% description coverage, clearly documenting both parameters (job_id and agent_key). The description does not add any additional meaning or clarification about the parameters beyond what the schema provides, so it meets the baseline of 3.

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: 'Get all messages for a job, ordered chronologically.' It specifies the resource (messages for a job) and the verb (get), but does not explicitly distinguish it from potential sibling tools like 'send_job_message' or 'get_job_status', which is why it scores 4 instead of 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 provides clear usage context: 'Use this to check for replies after sending a message or receiving a webhook notification.' This gives practical guidance on when to invoke the tool, though it does not explicitly state when not to use it or name alternatives, keeping it at a 4.

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 states the tool checks status but doesn't disclose behavioral traits like whether it's read-only (implied but not stated), authentication requirements, rate limits, error conditions, or what happens if the job doesn't exist. For a tool with zero annotation coverage, this leaves significant gaps in understanding its operation and 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 two concise sentences that are front-loaded with the core purpose. Every sentence earns its place: the first states what the tool does, and the second provides usage context. There is no wasted verbiage or redundancy, making it 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?

Given the tool's low complexity (1 parameter, no output schema, no annotations), the description is minimally adequate. It covers the purpose and basic usage but lacks details on behavioral aspects (e.g., error handling, return format) that would be helpful for an agent. Without annotations or output schema, the description should do more to compensate, but it only meets the minimum viable threshold.

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 the single parameter 'job_id' fully documented in the schema as 'The job ID returned from create_job_offer'. The description adds no additional parameter semantics beyond what the schema provides. According to the rules, with high schema coverage (>80%), the baseline is 3 even with no param info in the description, which applies here.

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: 'Check the status of a job offer' with specific outcomes ('see if the human has accepted, and if the job is ready for payment'). It distinguishes from siblings like 'get_job_messages' or 'mark_job_paid' by focusing on status checking. However, it doesn't explicitly differentiate from similar status-checking tools like 'get_activation_status' or 'get_payment_activation'.

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 implied usage context: 'Use this to see if the human has accepted, and if the job is ready for payment.' This suggests when to use it (to check acceptance and payment readiness). However, it doesn't explicitly state when NOT to use it or name alternatives (e.g., vs. 'get_job_messages' for communication status). The guidance is functional but lacks explicit exclusions or comparisons.

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 full burden. It discloses some return content (posting agent's reputation, application count), but does not mention side effects, authentication requirements, error behavior, or confirm it is read-only. The 'Get' verb implies a read operation, but more explicit transparency would be beneficial.

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, clear sentence that front-loads the core verb and object ('Get detailed information about a specific listing') and then adds relevant specifics. No filler or redundant text, making it highly concise 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 read tool with no output schema, the description is adequately complete: it states the purpose and highlights key return fields (reputation, application count). It could mention error behavior or that it retrieves by ID, but the schema covers the ID, and the tool is simple enough that the description suffices.

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% for the single 'listing_id' parameter, so the baseline is 3. The description does not add any extra meaning beyond the schema's 'The listing ID' — it only refers to 'a specific listing', which adds no new parameter semantics.

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

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

The description uses a specific verb ('Get') and resource ('listing'), and adds differentiating details: it's for a specific listing and includes the posting agent's reputation and application count. This clearly distinguishes it from siblings like get_listings (plural) and get_listing_applications.

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 for a single, specific listing via the word 'specific', which differentiates it from get_listings. However, it does not explicitly name alternatives or provide exclusion conditions, so it has clear context but no explicit 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the tool returns applicant profiles with specific attributes, which is useful, but it doesn't disclose critical behavioral traits such as authentication requirements (implied by 'agent_key' but not stated), rate limits, pagination, or error handling. For a read operation with no annotation coverage, this leaves significant 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 description is appropriately sized and front-loaded, consisting of two sentences that efficiently convey the tool's purpose and usage context without any wasted words. Every sentence adds value, making it concise 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?

Given the tool's moderate complexity (a read operation with 2 parameters), no annotations, and no output schema, the description is partially complete. It covers the purpose and output content but lacks details on behavioral aspects like authentication, errors, or return format. This is adequate for basic understanding but has clear gaps that could hinder an agent's effective use.

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

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

The input schema has 100% description coverage, with both parameters ('listing_id' and 'agent_key') documented in the schema. The description doesn't add any additional meaning or context beyond what the schema provides, such as format examples or usage tips. According to the rules, with high schema coverage (>80%), the baseline is 3 even with no param info in the description.

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 with a specific verb ('View') and resource ('applications for a listing you created'), and it distinguishes the output content (applicant profiles with skills, location, reputation, and pitch message). However, it doesn't explicitly differentiate from sibling tools like 'get_listing' or 'get_listings', which focus on listings rather than applications, so it doesn't fully achieve sibling 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 provides clear context for when to use the tool ('to evaluate candidates before making an offer'), which implies a workflow step. It doesn't explicitly mention when not to use it or name alternatives, but the context is sufficient for an agent to infer usage in candidate evaluation scenarios.

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 effectively describes the core behavior (returns listings with agent reputation and application counts) and mentions filtering support, but lacks details on pagination behavior, rate limits, authentication requirements, or error handling. It adds value beyond the schema but doesn't fully compensate for the missing annotations.

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

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

The description is perfectly concise and front-loaded: the first sentence states the core purpose, the second adds key return details, and the third efficiently summarizes filtering options. Every sentence earns its place with zero wasted words, making it highly scannable for an AI agent.

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 moderate complexity (10 parameters, no output schema, no annotations), the description is reasonably complete. It covers purpose, return data, and filtering scope, but could better address behavioral aspects like pagination or error cases. The absence of an output schema means the description doesn't explain return values, which is acceptable per the rules.

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 description coverage is 100%, so the schema already documents all 10 parameters thoroughly. The description adds marginal value by summarizing the filtering capabilities ('filtering by skill, category, work mode, budget range, and location'), but doesn't provide additional syntax or format details beyond what the schema specifies. 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 clearly states the specific action ('Browse open job listings'), identifies the resource ('Human Pages job board'), and distinguishes it from siblings like 'get_listing' (singular) by indicating it returns multiple listings with filtering capabilities. The verb+resource combination is precise and 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 context for when to use this tool ('Browse open job listings') and implicitly suggests alternatives like 'get_listing' (singular) for single listings or 'create_listing' for posting jobs. However, it doesn't explicitly state when NOT to use it or name specific sibling alternatives, which prevents a perfect score.

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. It states what the tool returns (a deposit address and payment instructions) but does not disclose potential side effects, authentication prerequisites beyond the agent_key, address expiry, or whether it initiates any state change. This is acceptable but not detailed.

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 clear sentence, front-loaded with the action and resource. No wasted words or redundant 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?

Given the tool's simplicity (one parameter, no output schema, no annotations), the description covers the core purpose but lacks usage context and does not enumerate the expected return fields beyond a vague 'deposit address and payment instructions.' It is minimally adequate.

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 fully describes agent_key with 100% coverage. The description adds no extra meaning or usage details about the parameter, 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?

The description uses a specific verb ('Get') and identifies the exact resource ('deposit address and payment instructions for PRO tier activation via on-chain payment'). It clearly distinguishes this tool from siblings like verify_payment_activation and request_activation_code.

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 explicit guidance is given on when to use this tool versus alternatives such as claim_free_pro_upgrade, request_activation_code, or verify_payment_activation. The purpose is implied but not compared to other activation-related 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 provided, so the description carries the full burden. It discloses that no authentication is required and describes the return value (claimed and remaining slots). The read-only nature is implied by 'Check' and 'Returns', though it could explicitly state it does not modify any state.

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 main purpose and then providing key details. Every word serves a purpose, with no filler or redundant 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 simple tool with no parameters and no output schema, the description covers purpose, return value, and authentication requirement. It could possibly mention the exact response format or any caveats (e.g., promo availability), but it is adequately complete for a status check of this simplicity.

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 input schema provides no information. The description adds context about what the status refers to (free PRO tier for first 100 agents) and what details are returned, which is valuable beyond the empty schema. Baseline for 0 params is 4, and the description satisfies that.

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

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

The description states a specific verb ('check') and a specific resource ('launch promo status'), and clearly explains what the tool does: it reports how many of the 100 free PRO slots are claimed and remaining. This distinguishes it from related siblings like 'claim_free_pro_upgrade' and 'check_humanity_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 clearly indicates this is a read-only status check for the promo, with no authentication required. While it doesn't explicitly name alternatives or state when not to use it, the context is clear for a simple tool of this nature.

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 adds important context about the prerequisite condition (job must be marked complete by human) and that reviews are 'only allowed' under this condition, which suggests permission/validation logic. However, it doesn't describe what happens after submission, error conditions, or whether the action is reversible.

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 consists of two concise sentences that efficiently convey the core purpose and critical usage constraint. Every word serves a clear purpose with no redundancy or unnecessary elaboration, making it easy to parse and understand quickly.

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 mutation tool with no annotations and no output schema, the description does well by specifying the prerequisite condition and scope. However, it could be more complete by mentioning what the tool returns or any side effects. The purpose and usage constraints are clearly communicated, making it mostly adequate for the tool's 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 description coverage is 100%, so all parameters are documented in the schema. The description doesn't add any parameter-specific information beyond what's in the schema (job_id, rating 1-5, optional comment). This meets the baseline expectation when schema coverage 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?

The description clearly states the specific action ('Leave a review') and the target resource ('for a COMPLETED job'), distinguishing it from siblings like 'approve_completion' or 'mark_job_paid' that handle different job lifecycle stages. It uses precise language that immediately conveys the tool's function without ambiguity.

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 when to use this tool ('after the human marks the job as complete') and implies when not to use it (for incomplete jobs). While it doesn't name specific alternatives, it provides clear contextual prerequisites that guide proper usage relative to other job-related 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 well by disclosing key behavioral traits: it creates a job, notifies a human, and is a binding commitment with financial implications. It adds value beyond the input schema by explaining consequences, though it could mention permissions or error conditions.

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 the core purpose in the first sentence, followed by additional context in a second sentence. Every sentence adds value without waste, making it 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?

Given the complexity of a binding financial commitment and no annotations or output schema, the description is mostly complete by explaining the action and consequences. However, it lacks details on return values or error handling, which would be helpful for an agent.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds no additional meaning about the parameters beyond what the schema provides, such as format examples or interdependencies, meeting the baseline for high 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 clearly states the specific action ('Make a job offer to a listing applicant'), identifies the resource ('listing applicant'), and distinguishes it from siblings by specifying it creates a standard job from the listing. It goes beyond the tool name to explain the outcome and binding nature.

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 context by mentioning 'listing applicant' and 'chosen applicant,' suggesting it should be used after reviewing applications. However, it does not explicitly state when to use this tool versus alternatives like 'create_job_offer' (a sibling tool), which might cause confusion.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. While it mentions prerequisites and constraints, it does not specify whether this is a read-only or destructive operation, what permissions are required, or what happens upon invocation (e.g., does it update job status, trigger notifications?). For a mutation tool with zero annotation coverage, this is a significant gap.

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, and every sentence adds essential information (prerequisites and constraints) without any waste, making it highly efficient.

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

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

Given the tool's complexity (a mutation operation with 4 required parameters), no annotations, and no output schema, the description is adequate but incomplete. It covers purpose and usage guidelines well but lacks behavioral details (e.g., side effects, error handling) and output information, leaving gaps for an AI agent.

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 description coverage is 100%, so the schema already documents all four parameters. The description adds context by implying that 'payment_amount' should match or exceed the agreed price, but does not provide additional syntax or format details beyond what the schema provides. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the specific action ('Record that payment has been sent') and resource ('for an ACCEPTED job'), distinguishing it from sibling tools like 'approve_completion' or 'get_job_status' by focusing on payment recording rather than job approval or status checking.

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 ('The job must be accepted by the human first') and constraints ('Payment amount must match or exceed the agreed price'), offering clear context for when to use this tool. However, it does not explicitly mention when not to use it or name alternatives among 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 transparency burden. It reveals key behavioral traits: backend verification for Superfluid and tick-skipping for micro-transfer. It does not mention side effects or return values, but for a pause operation this is reasonable.

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 long, front-loaded with the primary purpose, and contains no redundant information. Every word 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?

Given the tool's simplicity and lack of output schema, the description covers the main behavioral variations and prerequisites. It could mention error conditions or resumability, but the current content is adequate for a pause 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 already provides full descriptions for both parameters (job_id and agent_key) with 100% coverage. The description adds no parameter-specific context, 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?

The description clearly states the action ('Pause an active stream') and specifies two protocol-specific variants (Superfluid and micro-transfer). This distinguishes it from sibling tools like stop_stream or resume_stream.

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 usage steps for each protocol: for Superfluid, delete the flow first; for micro-transfer, skip the pending tick. However, it does not explicitly contrast with alternatives like stop_stream or resume_stream, leaving some ambiguity about when to use which.

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?

Without any annotations, the description carries the burden of explaining the tool's behavior. It discloses the key nuance that this only applies to MICRO_TRANSFER streams and that Superfluid is handled automatically, which adds important context. However, it does not mention any side effects, error conditions, or what happens after submission, leaving gaps for a write 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 sentences long, front-loaded with the main verb and resource, and contains no fluff. Every clause serves a purpose: the first sentence states the action, the second provides crucial scope limitations. It is ideal for an AI agent to quickly grasp the tool's purpose.

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

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

Given the tool's simplicity (3 required parameters, no output schema), the description is reasonably complete. It explains the specific scenario (micro-transfer tick payment), the input required (transaction hash), and the distinction from Superfluid streams. It could mention the outcome or potential failure modes, but the core context is sufficient for an agent to invoke 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?

The schema already documents all three parameters with 100% coverage, so the baseline is 3. The description adds extra meaning to the tx_hash parameter by specifying it is for the 'current pending tick', which clarifies how to use it. The other parameters (job_id, agent_key) gain no additional context from the description, but overall the description enriches the parameter semantics slightly.

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 function: 'Record a micro-transfer stream payment' with a specific verb and resource. It distinguishes itself from siblings by specifying that it is 'Only for MICRO_TRANSFER streams' and clarifying that 'Superfluid streams are verified automatically', which sets it apart from other stream-related tools like start_stream or stop_stream.

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

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

The description explicitly says when to use this tool ('Only for MICRO_TRANSFER streams') and when not ('Superfluid streams are verified automatically'). It provides a clear exclusion but does not name an alternative tool for Superfluid streams, so it falls slightly short of a 5 that would require explicit 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?

With no annotations provided, the description carries the full burden and does well by disclosing key behavioral traits: it's a write operation (registration), has activation implications ('auto-activated on PRO tier'), returns a critical output ('API key'), and includes a permanent constraint ('API key cannot be retrieved later'). However, it lacks details on error conditions, rate limits, or authentication requirements, preventing a perfect score.

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 efficiently structured in three sentences: the first states the action and context, the second covers activation and output, and the third adds a critical warning. Each sentence earns its place by providing essential information without redundancy, making it front-loaded and zero-waste.

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 complexity (a write operation with 5 parameters and no output schema), the description is mostly complete: it covers purpose, usage, key behavior, and output implications. However, without annotations or an output schema, it lacks details on response format (e.g., structure of the API key) and error handling, leaving minor gaps for the agent.

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 fully documents all 5 parameters. The description adds no specific parameter semantics beyond implying registration context. This meets the baseline of 3, as the schema handles the heavy lifting, but the description doesn't enhance parameter understanding (e.g., by explaining relationships between fields).

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 specific action ('Register as an agent on Human Pages') and the resource ('agent'), distinguishing it from siblings like 'get_agent_profile' or 'verify_agent_domain'. It explicitly mentions the outcome ('Returns an API key') and the platform context ('Human Pages'), making the purpose unambiguous and distinct.

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 guidance on when to use this tool: for initial registration ('Register as an agent') and not for later retrieval ('The API key cannot be retrieved later'). It implies usage context by stating agents are 'auto-activated on PRO tier (free during launch)', helping differentiate from tools like 'get_activation_status' or 'claim_free_pro_upgrade'.

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 code is for social media and not required for API access, but it doesn't describe the response format, delivery method, whether the code expires, or any side effects.

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 sentences, front-loaded with 'Optional.' Each sentence provides necessary context without any wasted 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?

The tool is simple with one fully documented parameter, but there is no output schema. The description should clarify what the response contains (e.g., whether the code is returned directly or sent via email), which it doesn't. This leaves a gap in understanding the tool's behavior after 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 agent_key, and the schema already describes it as starting with hp_. The description adds no additional parameter 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 clearly states the tool's function: 'Request an activation code (HP-XXXXXXXX) to post on social media for a verified trust badge.' It also distinguishes from siblings by explicitly noting it is not required for API access and that agents are auto-activated.

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 says 'Optional' and clarifies the code is for a social media trust badge, not for API access. This gives clear context for when to use it, though it doesn't explicitly name alternative tools like get_activation_status or verify_social_activation.

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 clearly describes the state transition (SUBMITTED → ACCEPTED) and that the human can resubmit, which are important behavioral traits. However, it doesn't mention authentication requirements (though agent_key is in schema), rate limits, error conditions, or what happens if the job isn't in SUBMITTED status. It provides some behavioral context but not comprehensive coverage.

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

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

The description is perfectly concise with three sentences that each earn their place: first states the purpose, second provides usage guidelines and behavioral context, third gives parameter guidance. No wasted words, and the most important information (what the tool does) 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 mutation tool with no annotations and no output schema, the description does well by explaining the state transition and resubmission capability. It covers the essential 'what happens' context. However, it doesn't describe error cases, authentication requirements (beyond the schema parameter), or what the response looks like. Given the complexity of a state-changing operation, there are some gaps in 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%, so the schema already documents all three parameters. The description adds marginal value by emphasizing that the reason should be 'clear' and 'explaining what needs to be fixed,' which reinforces the schema's description for the reason parameter. However, it doesn't provide additional semantic context beyond what the schema already specifies.

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 specific action ('Request revision') on a specific resource ('submitted work'), and distinguishes it from siblings by specifying it's for work with status=SUBMITTED that doesn't meet requirements. It explicitly mentions the state transition from SUBMITTED back to ACCEPTED, which is a precise operational detail.

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 when-to-use guidance: 'when the human has submitted their work (status = SUBMITTED) but it does not meet requirements.' It also implicitly suggests alternatives by indicating this tool is for revision requests rather than approval (contrasting with 'approve_completion' sibling). The guidance includes both the trigger condition and the expected outcome.

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 disclosure burden. It does reveal key behaviors: Superfluid requires a new flow and backend verification, while micro-transfer creates a new pending tick. However, it omits failure modes, side effects, or what happens upon verification, leaving gaps for an agent to understand operational risks.

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 well-structured: one sentence states the primary purpose, and the second sentence adds essential protocol-specific details. No extraneous information is included.

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

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

The description covers the core action and two modes, but leaves ambiguity about how an agent determines which protocol applies and what happens after backend verification or pending tick creation. Without annotations or an output schema, additional context about expected outcomes or prerequisites 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?

All three parameters are fully described in the schema (100% coverage), including the Superfluid-only sender_address. The description adds no additional parameter-level semantics, 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?

The description clearly states the tool's core function ('Resume a paused stream') and distinguishes between two protocol variants (Superfluid and micro-transfer) that have different behaviors. This differentiates it from siblings like start_stream, stop_stream, and pause_stream.

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 explicit context for when to use the tool: for paused streams. It also gives protocol-specific guidance, such as 'create a new flow first, then call this' for Superfluid. It does not explicitly mention when not to use it, but the two conditional branches offer clear usage direction.

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 burden for behavioral disclosure. It adequately describes the search functionality, filtering options, and return data, but lacks details on pagination, rate limits, error conditions, or authentication requirements. The mention of 'requires registered agent' for get_human_profile hints at access controls but doesn't fully cover this tool's 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 efficiently structured in two sentences: the first covers purpose, filtering, and returns; the second provides important alternative tool guidance. Every element serves a clear purpose with zero wasted words, making it easy to parse while maintaining completeness.

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

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

For a search tool with 12 parameters and no output schema, the description provides good context about filtering scope and return data. However, it doesn't explain the response format (e.g., pagination structure, field details) or error handling. The guidance about get_human_profile partially compensates, but some behavioral aspects remain undocumented.

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 has 100% description coverage, so parameters are well-documented in the structured schema. The description adds value by summarizing filtering capabilities ('skill, equipment, language, location, rate') and clarifying location options ('text or coordinates'), but doesn't provide additional syntax or format details beyond what the schema already covers.

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 specific action ('Search for humans available for hire') and resource ('humans'), distinguishing it from siblings like 'get_human' (singular retrieval) and 'get_human_profile' (detailed profile). It specifies the search context ('available for hire') and return content ('profiles with reputation stats'), making the purpose 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 explicitly provides when-to-use guidance by naming an alternative tool ('Contact info and wallets available via get_human_profile') and specifying a prerequisite ('requires registered agent'). It also implies usage context through filtering capabilities and return data, helping differentiate from other human-related tools like 'create_job_offer' or 'get_listings'.

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

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

With no annotations provided, the description carries the full burden and adds valuable behavioral context beyond the input schema: it specifies notification mechanisms (email and Telegram for agent messages) and a rate limit (10 messages/minute). It does not cover error conditions or response format, but provides practical operational details.

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 appropriately sized and front-loaded: the first sentence states the core purpose, followed by additional context in efficient sentences. Every sentence adds value (messaging direction, valid job statuses, notifications, rate limits) with zero waste.

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 no annotations and no output schema, the description provides good contextual completeness for a messaging tool: it covers purpose, usage context, notifications, and rate limits. It lacks details on error responses or message formatting constraints, but is sufficient for basic use.

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 does not add meaning beyond the schema (e.g., it doesn't explain job_id format or agent_key validation). Baseline 3 is appropriate as the schema handles parameter documentation adequately.

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 specific action ('send a message') on a specific resource ('on a job'), distinguishing it from sibling tools like 'get_job_messages' (which retrieves messages) or 'create_job_offer' (which creates job offers). It specifies the bidirectional nature of messaging between agents and humans.

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 for when to use the tool by listing the job statuses it works on (PENDING, ACCEPTED, PAID, STREAMING, PAUSED), but does not explicitly state when not to use it or name alternatives. It implies usage for communication during active job phases.

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 effectively describes key behaviors: it requires prior on-chain actions for Superfluid, verifies flows on-chain, locks network/token for micro-transfers, and creates pending ticks. However, it lacks details on error handling, response format, or rate limits, leaving some gaps in 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 front-loaded with the core purpose but becomes verbose with step-by-step instructions and implementation details. While informative, some sentences (e.g., specific contract addresses and token wrapping steps) may be overly detailed for a tool description, reducing conciseness without earning their place in guiding tool selection.

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 complexity of blockchain interactions and no output schema, the description is largely complete: it covers purpose, prerequisites, methods (Superfluid/micro-transfer), and network advice. However, it omits expected outputs or error scenarios, which is a minor gap for a tool with no annotations or output schema.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds marginal value by clarifying the sender_address role ('your wallet address that created the flow... or will send payments') and implying token defaults, but it doesn't provide significant additional semantics beyond what the schema offers, aligning with the baseline score.

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: 'Start a stream payment for an ACCEPTED stream job.' It specifies the verb ('Start') and resource ('stream payment') with the condition ('for an ACCEPTED stream job'), distinguishing it from sibling tools like pause_stream, resume_stream, or stop_stream that manage existing streams rather than initiating them.

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

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

The description provides explicit usage guidelines: it states when to use it ('for an ACCEPTED stream job'), prerequisites ('you must FIRST create the on-chain flow, then call this to verify it'), and alternatives (Superfluid vs. micro-transfer methods). It also advises on network preferences ('Prefer L2s... for lower gas costs'), offering clear contextual 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 full transparency burden. It discloses the permanent, irreversible nature of the action and the required job states, but does not elaborate on side effects, such as whether the action can be undone or any cleanup 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 two short sentences with no redundancy. The main action is front-loaded, and each sentence adds distinct information: the action and the usage conditions. Every word 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 two-parameter tool with full schema coverage, the description covers the core action, state preconditions, and permitted callers. It does not describe behavior for invalid states or post-conditions beyond marking as completed, but it is adequately complete for its simplicity.

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 description does not need to add parameter details. The description adds no additional parameter meaning beyond what the schema already provides, 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?

The description clearly states a specific action (stop a stream) and its permanent effect (mark job as completed), distinguishing it from sibling tools like pause_stream or resume_stream by emphasizing 'permanently' and the completion aspect.

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 specifies the applicable job states (STREAMING or PAUSED) and permitted callers (agent or human), giving clear context for when to use the tool. It does not explicitly mention alternatives or exclusions, but the permanent nature implies a distinction from pause_stream.

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 full burden of behavioral disclosure. It does disclose a key prerequisite (websiteUrl must be set) and gives exact instructions for the well-known and dns methods (file path and TXT record). However, it does not mention whether the operation is read-only, what the result/return value looks like, or any side effects. The lack of outcome details is a gap.

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 main purpose, and every word contributes value. It includes the prerequisite, the two methods, and specific technical details without superfluous content.

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 core requirements: it explains what the tool does, the prerequisite, and how to execute both verification methods. However, it does not describe the expected return value or what constitutes a successful verification, which would be helpful for an agent to know how to interpret the result. Given the tool's moderate complexity, the description is nearly complete but leaves out the outcome.

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 exceeds this by adding meaningful detail to the 'method' parameter: it explains the exact file path for 'well-known' and the TXT record host for 'dns', which is not fully specified in the schema. It also adds the prerequisite context about websiteUrl, which relates to the agent_id parameter. This extra explanation compensates for any ambiguity in the enum.

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: 'Verify domain ownership for a registered agent.' The verb 'verify' is specific, and it identifies the resource (domain ownership) and scope (registered agent). It distinguishes itself from sibling verify tools like verify_payment_activation and verify_social_activation by focusing on domain ownership.

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 must be used when an agent needs domain ownership verified, and it includes a prerequisite ('The agent must have a websiteUrl set'). It also explains the two supported methods, giving the user a sense of when each might be appropriate. However, it does not explicitly exclude alternatives or mention 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?

There are no annotations, so the description carries full responsibility. It does disclose a key side effect ('On success, your agent is activated with PRO tier'), but it does not mention failure behavior, idempotency, permission requirements, or whether the verification step is read-only or modifies state beyond activation. This leaves significant unknowns for an agent, especially for a tool that activates a paid tier.

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 primary action, and the second sentence adds the crucial outcome. Every word earns its place; there is no filler, redundancy, or overly technical jargon. It is a model of concise 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?

The tool has 3 required parameters, no output schema, and no annotations. The description conveys the core purpose and success outcome but lacks guidance on when to use it, what happens on failure, or any prerequisites. For a relatively simple verify/activate tool, this is minimally adequate but leaves gaps, hence not a higher score.

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 descriptions for all three parameters (agent_key, tx_hash, network) with 100% coverage. The description adds no parameter-specific meaning or examples beyond what the schema offers. Baseline for high schema coverage is 3, and there is no additional compensation 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?

The description uses a specific verb 'verify' and clearly identifies the resource: 'on-chain payment for PRO tier activation.' It also states the successful outcome ('your agent is activated with PRO tier'), which distinguishes it from likely read-only siblings like get_payment_activation or claim_free_pro_upgrade. The purpose is unambiguous and action-oriented.

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. It does not mention any exclusions, prereqs, or mention sibling tools like get_payment_activation or claim_free_pro_upgrade. The context implies using it after an on-chain payment, but this is not directly stated, so the agent receives no actionable guidance on 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?

No annotations are provided, so the description carries the full behavioral disclosure burden. It adds useful context that the tool is optional and auto-activation occurs, but it does not state whether the operation is read-only, what happens on success, or any potential side effects. The verb 'Verify' implies a read operation, but this is not explicit.

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 'Optional' context, and every clause adds value. There is no fluff or repetition, making it highly efficient.

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

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

The tool is simple with 2 documented parameters, and the description clarifies its purpose and optionality. However, there is no output schema, and the description does not explain what a successful verification returns or what the 'verified trust badge' entails, leaving a modest gap for agents to understand the post-call outcome.

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?

Both parameters have schema descriptions covering 100% of the inputs, so the description need not add parameter details. It mentions 'activation code' and 'social media post,' which aligns with the schema but does not add new format or syntax beyond what the schema already 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 uses the specific verb 'Verify' with the resource 'social media post containing your activation code' and states the purpose 'for a verified trust badge.' It clearly distinguishes from sibling verification tools by focusing on social media posts rather than domain or payment 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 description explicitly labels the tool as 'Optional' and states 'Not required for API access — agents are auto-activated on registration,' providing a clear when-not scenario. However, it does not explicitly mention alternative tools for other verification types (e.g., verify_agent_domain), so it stops short of full alternative guidance.

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