Wever World Data

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

Annotations indicate it is a mutation (readOnlyHint=false) but not destructive (destructiveHint=false). The description adds valuable behavioral details beyond that: the reference is 'credential-free' and 'expiring,' and it explicitly states 'no permission to other jobs, deletion or resharing.' It also notes the requirement for an explicit intended recipient, which is a precondition. This aligns with the annotations and adds context about side effects 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 three sentences, front-loaded with the core action, then behavioral constraints. It avoids redundancy and every sentence adds information. It is slightly verbose in the third sentence ('Requires explicit intended recipient; no permission to other jobs, deletion or resharing') but remains focused and clear.

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 4 parameters, an output schema (not shown but indicated), and is a creation operation. The description covers the purpose, return type (reference), lifetime (expiring), and permission boundaries. It does not detail error handling or authentication prerequisites beyond the intended recipient, but the annotations and schema fill most gaps. Given the complexity, it is sufficiently complete for an agent to call it correctly.

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

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

Schema description coverage is 75%, meaning most parameters already have descriptions in the schema. The tool description adds minimal parameter-specific guidance: it reinforces that recipient_client_id is the 'explicit intended recipient' but does not explain syntax, defaults, or relationships beyond what the schema provides. Since the schema already documents job_id, request_key, and ttl_seconds, the description adds little incremental value.

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

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

The description opens with a precise verb and resource: 'Authorize one recipient client_id to read one owned result with its own credential.' It clearly states the tool creates an expiring reference for agent handoff, and distinguishes it from siblings like get_result_reference (retrieval) and revoke_result_reference (revocation) by framing it as an authorization action. The scope is explicit: only one owned result, no permissions to other jobs, deletion, or resharing.

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

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

The description gives clear context on when to use it: to grant a recipient access to a specific result via a credential-free reference. It mentions 'Owner access stays in the configured header,' implying this tool is only needed for non-owner recipients. It does not explicitly name alternative tools or say 'use X instead,' but the purpose is well-defined enough to guide selection against sibling names.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false. The description adds valuable behavioral context: it retains an idempotency tombstone until expiry, does not reset quotas, and requires a bearer access header. This goes beyond the annotations and informs the agent of side effects and required authentication.

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 key behavioral details. Every sentence adds value: the first identifies the action, the second covers idempotency, quotas, and authentication. No filler or redundancy.

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

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

The description covers the essential aspects for a single-parameter delete operation: what is deleted, side effects (tombstone, quotas), and required authentication. The output schema likely documents the response, and the tool's simplicity means little is missing. Minor gaps include error conditions (e.g., non-existent job_id) but these may be covered by the 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 documents job_id as a required string with a pattern, but provides no description, and the tool description does not elaborate on this parameter. With schema description coverage at 0%, the description should compensate, but it only vaguely implies that job_id identifies the result content. No additional semantics like naming conventions or the relationship to the owner are given.

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 ('Delete') and the resource ('stored result content'), and it contrasts with sibling tools like get_catalog, get_job, and submit_* by indicating a deletion operation. It also adds specificity about idempotency and quota behavior, making the purpose unmistakable.

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 does not explicitly state when to use this tool versus alternatives. It implies usage for deleting a job's result, but provides no exclusions or conditional guidance (e.g., 'use get_job to retrieve, delete_job to remove'). The authentication note ('Configure the owner's bearer access header') is a prerequisite, not a usage rule.

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

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

Annotations already establish readOnlyHint=true and destructiveHint=false. The description adds meaningful behavioral context by clarifying the operation is a read of public data and explicitly states no access credential is required, which is important auth-related information beyond the annotations.

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

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

A single, front-loaded sentence that efficiently lists the tool's scope and its key auth characteristic. There is no filler, repetition, or unnecessary detail.

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

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

For a parameterless read-only tool with an output schema, the description is complete: it states what will be read, that it is public, and that no credentials are required. An agent has enough context to invoke this tool correctly.

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

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

The tool has zero parameters, so the description carries little parameter burden. The input schema fully defines the lack of parameters, and the description adds relevant context by indicating no credential parameter is needed. Baseline 4 applies for parameterless tools.

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 ('Read') and lists concrete resources: public capabilities, free allowances, access bootstrap, privacy, retention, and HTTP discovery routes. It is clear about what the tool returns but does not explicitly differentiate itself from siblings like search_capabilities or resolve_capability.

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 statement 'No access credential required' gives useful context for when this tool is appropriate, implying it is the entry point for public metadata. However, it does not explicitly say when to prefer this over siblings or when not to use it, so usage guidance remains implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds valuable behavioral context beyond them: results expire within 24 hours and are tied to the owner's access. It does not describe failure cases for expired or unauthorized requests, but the disclosed constraints exceed what annotations alone provide.

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

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

Two sentences, no filler. The core action and required credentials are front-loaded, and the expiration constraint earns its place as essential behavioral information.

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

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

For a single-parameter read tool with annotations and an output schema, the description covers the essential operational details: what is retrieved, what credentials are required, and the retention window. It does not explicitly explain how to obtain a job_id, but that is reasonably inferred from the submit_* siblings.

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 mentions 'using its job_id', which adds basic contextual meaning, but does not elaborate on where the job_id comes from or how it relates to the original submission. The schema's pattern already defines the expected format, so the description offers only minimal semantic uplift.

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 ('Recover') and resource ('original complete private CSV or audit result') tied to a job_id. It distinguishes itself from siblings through the job_id-based retrieval, though it does not explicitly name or contrast any sibling tool.

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

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

The description gives clear usage context: clients need a job_id, the owner's bearer access header, and must act within 24 hours before expiration. It does not explicitly state when not to use this tool or mention alternatives, but the context is sufficient for the one-parameter retrieval case.

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

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

Annotations already mark this read-only and non-destructive. The description adds meaningful behavior: authentication via the recipient's configured bearer header, that the reference alone grants no access, and that expired, revoked, or deleted results are unavailable. No contradiction with annotations.

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

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

Three short sentences with no filler. The core action is front-loaded, followed by the critical auth caveat and the unavailability conditions. Every sentence earns its place.

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

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

For a one-parameter read tool with an output schema and read-only annotations, this is largely complete: it covers auth, access semantics, and failure conditions. It could be improved by tying reference_id to the reference-creation flow, but nothing essential is missing 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 0%, so the description must compensate. The text refers generically to 'the reference' but never explicitly explains that reference_id is the token identifying the result or how it relates to create_result_reference. The pattern and property name carry most of the meaning.

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

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

The description states a clear verb and resource: 'Retrieve the full shared result' via a reference. It is distinct from create/revoke siblings by meaning, but it does not explicitly name or compare against them, so it stops short of full differentiation.

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

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

The context of use is implied: use this when you have a reference and need the shared result. It clarifies that the caller must possess the recipient's bearer header and that expired/revoked/deleted results are unavailable, but it gives no explicit when-to-use versus alternatives 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds meaningful behavioral detail: unknown identities are rejected, no URL is fetched, and live availability/authorization are not checked. This goes well beyond the structured annotations and gives the agent accurate expectations.

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 tight sentences with no filler. The main purpose is front-loaded, followed by essential behavioral caveats. Every sentence earns its place.

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

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

For a single-parameter read-only resolver with a rich output schema and full schema description coverage, the description covers all needed call semantics: input type, rejection behavior, and non-guarantees. The output schema handles return values, so nothing essential is missing.

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

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

The schema covers the single parameter completely with constraints and a clear description ('Exact canonical service_id from capability search... Never a URL or credential'). The tool description adds little beyond the schema, so the baseline of 3 applies.

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

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

The description clearly states the action ('Resolve an exact canonical Wever service_id'), the resource (service_id), and the result (connection metadata, contract, limits, access steps). It differentiates itself from sibling tools like search_capabilities by focusing on resolution of an already-known canonical ID rather than discovery.

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

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

The description implies when to use it: with an exact canonical service_id, and it clarifies boundaries such as 'no caller-supplied URL is fetched' and 'does not verify live availability or authorize execution.' It does not explicitly name alternatives, but the schema's 'from capability search' reference provides enough 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?

Annotations already indicate a destructive write, and the description adds useful behavioral context: the action is idempotent ('repeating this action is safe') and irreversible with respect to previously downloaded copies ('cannot be recalled'). This tells the agent the side-effect boundary beyond the annotation flags.

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

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

Two short, front-loaded sentences deliver the core action and the two most important behavioral caveats. There is no filler or repetition of schema/annotation 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 simple one-parameter input, the existing output schema, and annotations, the description covers the needed calling context: owner scope, revocable future retrieval, idempotence, and the inability to recall downloaded copies. No crucial behavior is missing for correct invocation.

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

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

The description only alludes to 'one shared result reference' and never names reference_id or explains the format, so it adds limited parameter semantics. However, with a single required parameter whose schema includes the pattern ^ref_[a-f0-9]{32}$, an agent can map the reference concept to the parameter without difficulty.

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

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

The description names a precise action ('revokes future retrieval') and an explicit object ('shared result reference'), clearly differentiating it from create_result_reference and get_result_reference. It avoids tautology and states the resource's effect.

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

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

The phrase 'Owner revokes future retrieval' provides clear context for when the tool should be selected: the caller owns a shared reference and wants to stop future access. It doesn't explicitly contrast with delete_job or other siblings, but the purpose statement is specific enough to establish the appropriate use case.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds beyond that by disclosing that it returns only fixed known services and does not verify live availability, search the web, execute work, or grant permissions. This provides behavioral context that annotations do not convey.

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

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

Two sentences with zero wasted words. The primary purpose and key differentiators are front-loaded, and the exclusions are listed succinctly. It is appropriately sized for the information it conveys.

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 output schema exists and annotations cover safety, the description is mostly complete: it specifies input, return content, and behavioral limits. The main gap is the lack of guidance on how this tool differs from resolve_capability and the undocumented limit parameter, but the core calling context is clear enough.

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 has descriptions for query only (50% coverage). The description adds meaning to query by specifying 'short task description or keyword', which is more specific than the schema's generic 'nonblank query'. However, the limit parameter has no description in either the schema or the tool description, leaving its purpose and constraints undocumented. With partial coverage, the description only partially compensates.

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

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

Description clearly states the verb 'Find' and resource 'maintained Wever capabilities', and specifies the input as a short task description or keyword. It also lists what it returns (connection details, contracts, limits, access steps) and what it does not do (execute work, grant permissions, search web, verify availability), making its purpose unambiguous even against siblings like resolve_capability.

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?

Description implies when to use: when you need to search for capabilities without executing or granting permissions. It provides clear context by stating exclusions. However, it does not explicitly mention when not to use it or point to alternative tools like resolve_capability, which appears to handle a specific capability resolution rather than broad search.

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 key behavioral traits beyond the annotations: a completed audit can report mismatches or blocked parsing, and callers should inspect result.status, comparison, ambiguities and unsupported rules. It also states that no factual verification or inferred transformations occur, which is valuable and not already provided by the readOnly/destructive hints.

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 dense sentences with no filler. It front-loads the core action and scope, then gives result-inspection guidance, then states boundary conditions. Every sentence earns its place.

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

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

Given the complexity of six parameters and a nested schema, the description is somewhat terse, but the rich input schema and presence of an output schema carry much of the load. It covers the tool's purpose, result shape, and key exclusions, making it sufficient for an agent to invoke correctly without being redundant.

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 input schema already documents all six parameters in detail. The description adds high-level context about caller-supplied expected records and unsupported rules, but it does not add parameter-level semantics beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Audit bounded CSV against caller-supplied expected records.' It further specifies the operation's scope with 'explicit grouping, exact source references, lineage and integrity checks,' making it clearly distinct from sibling tools like submit_csv or get_job.

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

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

The description clearly implies this tool is for validating a supplied CSV against expected records and inspecting comparison results, while explicitly excluding factual verification and inferred transformations. It does not name alternative tools, but the 'audit' framing and boundary statements provide enough 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?

The description adds useful behavioral detail beyond the annotations: it returns a complete private job and checked CSV, requires bearer access in the client header, and instructs callers to reuse request_key on retries for idempotency. It does not detail persistence, error behavior, or concrete side effects, but given the annotations are minimal, this is a solid level of disclosure.

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

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

The description is three short sentences with no filler. Purpose is front-loaded, followed by return value, auth requirement, and retry guidance. Each sentence communicates a distinct, useful fact, 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?

For a tool with nested schema and an output schema present, the description covers the key invocation essentials: what it does, what it returns, auth setup, and idempotency behavior. It does not mention error handling or how to later retrieve the job, but the output schema and sibling get_job tool compensate partially. Overall, it is sufficient for correct selection and invocation.

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

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

Schema description coverage is 67%, and the description itself adds limited parameter-level meaning. 'Bounded CSV' loosely hints at csv_text limits, and 'explicit column rules' maps to the schema parameter, but the description does not expand on how to construct the schema. The retry note reinforce request_key semantics already described in the schema, so the description adds only modest value beyond the structured schema.

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

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

The description states a specific verb and resource: 'Normalize bounded CSV using explicit column rules.' This clearly identifies what the tool does and distinguishes it from sibling tools like submit_audit or create_result_reference. The qualifiers 'bounded' and 'explicit column rules' add meaningful scope.

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: when normalizing a bounded CSV with explicit column rules. It also includes important invocation prerequisites such as bearer access and request_key reuse on retries. However, it does not explicitly contrast this tool with sibling submission or reference tools, so it lacks 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.